Cheatsheet Phase 1 - Fondamentaux Gemini

Note: 1.5 Pro reste pertinent pour les contextes tres longs (2M natif).

Besoin de raisonnement profond?
  OUI -> Gemini 3 Pro (Deep Think)
  NON ->
    Budget serre / volume eleve?
      OUI -> 2.5 Flash-Lite
      NON ->
        Besoin thinking configurable?
          OUI -> 2.5 Flash
          NON -> Gemini 3 Flash

• Gemini 3 Flash: 15 RPM, 1M TPM, 1500 RPD gratuits
• 2.5 Flash: 10 RPM, 250K TPM, 500 RPD gratuits
• 2.5 Flash-Lite: 30 RPM, 1M TPM, 1500 RPD gratuits
• 1.5 Flash: 15 RPM, 1M TPM, 1500 RPD gratuits

Traitement asynchrone avec 50% de reduction sur tous les modeles :

• Delai: Jusqu'a 24h pour le traitement
• Volume: Ideal pour 10K+ requetes
• Use cases: Evaluation, classification en masse, extraction

# Batch request format
batch_request = {
    "requests": [
        {"id": "req-1",
         "request": {
            "model": "gemini-2.5-flash",
            "contents": [{"parts": [{"text": "..."}]}]
         }}
    ]
}

• Gratuit - Active automatiquement sur requetes repetitives
• Condition: Prefixe identique d'au moins 1024 tokens
• Modeles: 2.5 Flash, 2.5 Pro, 3 Flash, 3 Pro
• Visible: usage_metadata.cached_content_token_count dans la reponse

# Exemple: 10K requetes/jour, 2.5 Flash
# 2000 tokens input + 500 tokens output

# Sans optimisation:
cout_base = 10000 * (2000/1e6 * 0.15 + 500/1e6 * 0.60)
# = $3.00 + $3.00 = $6.00/jour

# Avec cache implicite (80% cache hit):
cout_cache = 10000 * (400/1e6 * 0.15 + 1600/1e6 * 0.0375 + 500/1e6 * 0.60)
# = $0.60 + $0.60 + $3.00 = $4.20/jour (-30%)

# Avec Batch API:
cout_batch = 10000 * (2000/1e6 * 0.075 + 500/1e6 * 0.30)
# = $1.50 + $1.50 = $3.00/jour (-50%)

URL: aistudio.google.com

• Freeform: Prompt unique, ideal pour tester rapidement
• Structured: Exemples input/output en tableau, few-shot visuel
• Chat: Conversation multi-tours avec historique

• Get Code: Export en Python, JavaScript, Kotlin, Swift, Dart, cURL
• API Key: Generation directe depuis l'interface
• Tuning: Fine-tuning supervisee depuis l'interface (Flash uniquement)
• File Upload: Upload images, audio, video, PDF directement

# Code genere par AI Studio (Python)
from google import genai

client = genai.Client(api_key="YOUR_API_KEY")
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Explique le cloud computing"
)
print(response.text)

• Token Counter: Comptage en temps reel des tokens
• Safety Settings: Ajustement des filtres de securite
• Temperature/Top-P: Sliders interactifs
• Model Comparison: Tester plusieurs modeles en parallele
• Prompt Gallery: Templates de prompts pre-construits
• Grounding: Activation de Google Search directement

# Installation
pip install google-genai

# Configuration avec API Key
from google import genai

client = genai.Client(api_key="GEMINI_API_KEY")

# Ou via variable d'environnement
# export GOOGLE_API_KEY=AIza...
client = genai.Client()

# Configuration Vertex AI (GCP)
client = genai.Client(
    vertexai=True,
    project="my-project",
    location="us-central1"
)

# Base URL
https://generativelanguage.googleapis.com/v1beta

# Endpoint principal
POST /models/{model}:generateContent?key={API_KEY}

# Streaming
POST /models/{model}:streamGenerateContent?key={API_KEY}

# Headers
Content-Type: application/json

# cURL exemple
curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/\
models/gemini-2.5-flash:generateContent?key=$API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"contents":[{"parts":[{"text":"Hello"}]}]}'

from google import genai
from google.genai import types

client = genai.Client(api_key="...")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Explique les design patterns",
    config=types.GenerateContentConfig(
        system_instruction="Tu es un architecte logiciel senior.",
        temperature=0.7,
        top_p=0.95,
        top_k=40,
        max_output_tokens=2048,
        candidate_count=1,
    )
)

print(response.text)
print(response.usage_metadata)

# Reponse generateContent
response.text            # Texte de la reponse
response.candidates      # Liste de candidats
response.candidates[0].content.parts[0].text
response.candidates[0].finish_reason
response.candidates[0].safety_ratings

# Usage metadata
response.usage_metadata.prompt_token_count
response.usage_metadata.candidates_token_count
response.usage_metadata.total_token_count
response.usage_metadata.cached_content_token_count

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Content(
            role="user",
            parts=[types.Part(text="Qu'est-ce que REST?")]
        ),
        types.Content(
            role="model",
            parts=[types.Part(text="REST est...")]
        ),
        types.Content(
            role="user",
            parts=[types.Part(text="Compare avec GraphQL")]
        ),
    ]
)

# Streaming avec le SDK google-genai
response = client.models.generate_content_stream(
    model="gemini-2.5-flash",
    contents="Ecris un article sur le cloud",
)

for chunk in response:
    print(chunk.text, end="")

# Chaque chunk contient:
# chunk.text - texte partiel
# chunk.candidates[0].content.parts
# chunk.usage_metadata (dernier chunk)

# Endpoint streaming
POST /models/gemini-2.5-flash:streamGenerateContent\
?alt=sse&key={API_KEY}

# Reponse SSE (Server-Sent Events)
data: {"candidates":[{"content":{"parts":
  [{"text":"Voici"}],"role":"model"}}]}

data: {"candidates":[{"content":{"parts":
  [{"text":" mon"}],"role":"model"}}]}

data: {"candidates":[{"content":{"parts":
  [{"text":" article..."}],"role":"model"},
  "finishReason":"STOP"}],
  "usageMetadata":{"promptTokenCount":8,
  "candidatesTokenCount":150}}

import asyncio
from google import genai

async def stream_response():
    client = genai.Client(api_key="...")

    response = await client.aio.models\
        .generate_content_stream(
        model="gemini-2.5-flash",
        contents="Explique Kubernetes"
    )

    async for chunk in response:
        print(chunk.text, end="")

asyncio.run(stream_response())

RPM = Requetes/min | RPD = Requetes/jour | TPM = Tokens/min

import time
from google.api_core import exceptions

def call_with_retry(prompt, retries=5):
    for i in range(retries):
        try:
            return client.models.generate_content(
                model="gemini-2.5-flash",
                contents=prompt
            )
        except exceptions.ResourceExhausted:
            wait = 2 ** i
            print(f"Rate limit, retry in {wait}s")
            time.sleep(wait)
    raise Exception("Max retries exceeded")

• Mode: Raisonnement profond multi-etapes
• Traces visibles: Pensees intermediaires accessibles
• Use cases: Math, logique, code complexe, analyse
• Activation: Automatique sur requetes complexes

# Gemini 3 Pro avec Deep Think
response = client.models.generate_content(
    model="gemini-3.0-pro",
    contents="Prouve que sqrt(2) est irrationnel",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_budget=8192
        )
    )
)

# Budget configurable: 0 a 24576 tokens
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Optimise cet algorithme...",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_budget=8192  # 0-24576
        )
    )
)

# Lire les thinking tokens
for part in response.candidates[0].content.parts:
    if part.thought:
        print("THINKING:", part.text)
    else:
        print("RESPONSE:", part.text)

# Usage metadata thinking
meta = response.usage_metadata
print(f"Thinking tokens: {meta.thinking_token_count}")
print(f"Total tokens: {meta.total_token_count}")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    config=types.GenerateContentConfig(
        system_instruction="""Tu es un architecte cloud
senior specialise AWS et GCP.

REGLES:
- Reponds toujours en francais
- Fournis des exemples de code
- Cite les services cloud specifiques
- Format: Markdown structure

PERSONNALITE:
- Ton professionnel mais accessible
- Toujours justifier les choix techniques
"""
    ),
    contents="Conçois une archi microservices"
)

• Persona: Definir le role, l'expertise, le ton
• Guardrails: Lister ce que le modele NE DOIT PAS faire
• Format: Specifier le format de sortie attendu
• Contexte: Fournir les informations de fond
• Multi-task: Definir plusieurs comportements selon le type de requete

"""Tu es un assistant technique polyvalent.

TACHE 1 - CODE REVIEW:
Si l'utilisateur envoie du code, analyse:
- Bugs potentiels
- Performance
- Securite
- Suggestions d'amelioration

TACHE 2 - ARCHITECTURE:
Si l'utilisateur decrit un systeme, propose:
- Diagramme textuel
- Composants recommandes
- Points d'attention

TACHE 3 - DEBUGGING:
Si l'utilisateur a une erreur:
- Identifie la cause racine
- Propose un fix
- Explique la prevention

FORMAT: Toujours utiliser des sections Markdown.
LANGUE: Francais uniquement.
"""

# Upload d'un fichier
uploaded_file = client.files.upload(
    file="document.pdf",
    config={"display_name": "Mon Document"}
)

# Verifier le statut
print(uploaded_file.name)       # files/abc123
print(uploaded_file.uri)        # URI pour reference
print(uploaded_file.state)      # ACTIVE
print(uploaded_file.expiration_time)

# Utiliser dans une requete
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_uri(
            file_uri=uploaded_file.uri,
            mime_type=uploaded_file.mime_type
        ),
        "Resume ce document"
    ]
)

# Inline data (base64)
import base64
with open("image.png", "rb") as f:
    data = base64.standard_b64encode(f.read()).decode()

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(
            data=open("image.png", "rb").read(),
            mime_type="image/png"
        ),
        "Decris cette image"
    ]
)

# Lister les fichiers uploades
for f in client.files.list():
    print(f"{f.name} | {f.state} | {f.size_bytes}")

# Recuperer un fichier specifique
file = client.files.get(name="files/abc123")

# Supprimer un fichier
client.files.delete(name="files/abc123")

# Attendre que le fichier soit pret (video)
import time
while uploaded_file.state == "PROCESSING":
    time.sleep(5)
    uploaded_file = client.files.get(
        name=uploaded_file.name)

# Depuis un fichier local
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(
            data=open("screenshot.png", "rb").read(),
            mime_type="image/png"
        ),
        "Analyse cette interface utilisateur. "
        "Identifie les problemes UX."
    ]
)

# Depuis une URL (via File API)
import urllib.request
urllib.request.urlretrieve(url, "temp.jpg")
file = client.files.upload(file="temp.jpg")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(
            data=open("receipt.jpg", "rb").read(),
            mime_type="image/jpeg"
        ),
        """Extrais toutes les informations de ce recu:
- Nom du magasin
- Date
- Liste des articles avec prix
- Total
Format: JSON"""
    ]
)

# Comparer plusieurs images
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(
            data=open("design_v1.png", "rb").read(),
            mime_type="image/png"),
        "Image 1: Design V1",
        types.Part.from_bytes(
            data=open("design_v2.png", "rb").read(),
            mime_type="image/png"),
        "Image 2: Design V2",
        "Compare ces deux designs. "
        "Liste les differences."
    ]
)

Limite: Max 3600 images par requete. Tokens par image ~258 tokens (standard).

# Upload audio via File API
audio = client.files.upload(file="meeting.mp3")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_uri(
            file_uri=audio.uri,
            mime_type="audio/mp3"
        ),
        """Transcris cet audio et fournis:
1. Transcription complete
2. Resume des points cles
3. Actions items identifies
4. Participants detectes"""
    ]
)

Tokens audio: ~32 tokens/seconde. 1h audio = ~115K tokens.

# Upload video (peut prendre du temps)
video = client.files.upload(file="demo.mp4")

# Attendre le traitement
import time
while video.state == "PROCESSING":
    time.sleep(10)
    video = client.files.get(name=video.name)

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_uri(
            file_uri=video.uri,
            mime_type="video/mp4"
        ),
        "Decris ce qui se passe a 0:30, 1:00 et 2:00"
    ]
)

Tokens video: ~263 tokens/seconde (audio+visuel). Video max: 2GB ou ~2h.

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_uri(
            file_uri=video.uri,
            mime_type="video/mp4"
        ),
        """Analyse cette video et cree:
1. Un chapitrage avec timestamps
2. Un resume de chaque section
3. Les moments cles
Format: MM:SS - Description"""
    ]
)

# PDF via File API
pdf = client.files.upload(file="rapport.pdf")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_uri(
            file_uri=pdf.uri,
            mime_type="application/pdf"
        ),
        """Analyse ce document PDF:
1. Resume executif (5 bullet points)
2. Chiffres cles extraits
3. Conclusions principales
4. Points d'action recommandes"""
    ]
)

# PDF inline (petits fichiers < 20MB)
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(
            data=open("small.pdf", "rb").read(),
            mime_type="application/pdf"
        ),
        "Extrais les donnees du tableau page 3"
    ]
)

• Tableaux: Extraction structuree des lignes et colonnes
• Graphiques: Description et interpretation des visuels
• Formulaires: Detection champs et valeurs
• Multi-colonnes: Lecture dans le bon ordre
• En-tetes/pieds: Identification des sections repetitives

# Comparer deux documents
pdf1 = client.files.upload(file="contrat_v1.pdf")
pdf2 = client.files.upload(file="contrat_v2.pdf")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_uri(
            file_uri=pdf1.uri,
            mime_type="application/pdf"),
        "Document V1 ci-dessus.",
        types.Part.from_uri(
            file_uri=pdf2.uri,
            mime_type="application/pdf"),
        "Document V2 ci-dessus.",
        "Compare ces deux versions. "
        "Liste toutes les differences."
    ]
)

# Mode JSON simple
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Liste 3 langages de programmation",
    config=types.GenerateContentConfig(
        response_mime_type="application/json"
    )
)

import json
data = json.loads(response.text)
print(data)

# Schema structure avec types
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Analyse le sentiment: J'adore ce produit!",
    config=types.GenerateContentConfig(
        response_mime_type="application/json",
        response_schema={
            "type": "object",
            "properties": {
                "sentiment": {
                    "type": "string",
                    "enum": ["positif", "negatif", "neutre"]
                },
                "score": {"type": "number"},
                "keywords": {
                    "type": "array",
                    "items": {"type": "string"}
                }
            },
            "required": ["sentiment", "score"]
        }
    )
)
# {"sentiment":"positif","score":0.95,"keywords":["adore"]}

# Enum pour contraindre les valeurs
schema = {
    "type": "object",
    "properties": {
        "priority": {
            "type": "string",
            "enum": ["low", "medium", "high", "critical"]
        },
        "category": {
            "type": "string",
            "enum": ["bug", "feature", "improvement"]
        },
        "description": {"type": "string"}
    },
    "required": ["priority", "category", "description"]
}

from google.genai import types

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Quelles sont les dernieres nouveautes "
             "de Google Cloud en 2026?",
    config=types.GenerateContentConfig(
        tools=[
            types.Tool(
                google_search=types.GoogleSearch()
            )
        ]
    )
)

# Acceder aux metadonnees de grounding
candidate = response.candidates[0]
grounding = candidate.grounding_metadata

# Sources utilisees
for chunk in grounding.grounding_chunks:
    print(f"Source: {chunk.web.title}")
    print(f"URL: {chunk.web.uri}")

# Supports de grounding
for support in grounding.grounding_supports:
    print(f"Texte: {support.segment.text}")
    print(f"Indices: {support.grounding_chunk_indices}")
    print(f"Confiance: {support.confidence_scores}")

# Requete de recherche generee
print(grounding.search_entry_point.rendered_content)

# Grounding conditionnel (seuil de confiance)
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Quelle est la population de la France?",
    config=types.GenerateContentConfig(
        tools=[
            types.Tool(
                google_search=types.GoogleSearch()
            )
        ]
    )
)

• Use cases: Donnees recentes, faits verifiables, actualites
• Eviter pour: Raisonnement pur, generation creative, code
• Citations: Les sources sont automatiquement citees dans la reponse

# Creer un cache explicite
from google.genai import types

# Upload du document a cacher
doc = client.files.upload(file="codebase.zip")

cache = client.caches.create(
    model="gemini-2.5-flash",
    config=types.CreateCachedContentConfig(
        display_name="Mon codebase",
        system_instruction="Tu es un expert de ce code.",
        contents=[
            types.Content(
                role="user",
                parts=[types.Part.from_uri(
                    file_uri=doc.uri,
                    mime_type=doc.mime_type
                )]
            )
        ],
        ttl="3600s"  # 1 heure
    )
)
print(f"Cache: {cache.name}")
print(f"Tokens caches: {cache.usage_metadata}")

# Requete avec cache
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Explique la fonction main()",
    config=types.GenerateContentConfig(
        cached_content=cache.name
    )
)

# Verifier l'usage du cache
meta = response.usage_metadata
print(f"Cached: {meta.cached_content_token_count}")
print(f"Non-cached: {meta.prompt_token_count}")

# Gestion du cache
cache = client.caches.update(
    name=cache.name,
    config={"ttl": "7200s"}  # Prolonger a 2h
)
client.caches.delete(name=cache.name)  # Supprimer

• Ideal: Meme contexte long, questions multiples (RAG, chatbot documentation)
• Seuil rentabilite: 2+ requetes avec le meme prefixe > 32K tokens
• Pas ideal: Requetes uniques, contextes courts (< 2048 tokens)

• 1. Clarte: Instructions directes, verbes d'action, pas d'ambiguite
• 2. Specificite: Preciser format, longueur, style, langue, ton
• 3. Exemples: Few-shot avec 2-5 exemples representatifs
• 4. Decomposition: Diviser les taches complexes en etapes
• 5. Iteration: Tester, mesurer, affiner dans AI Studio

# Few-shot dans system_instruction
system = """Classifie les tickets de support.

EXEMPLES:
Input: "L'app crash au login" -> bug/critical
Input: "Ajouter mode sombre" -> feature/low
Input: "Page lente a charger" -> performance/medium

FORMAT: categorie/priorite"""

# Chain-of-Thought explicite
prompt = """Analyse ce probleme etape par etape:

1. Identifie le probleme principal
2. Liste les causes possibles
3. Evalue chaque cause (probabilite)
4. Propose la solution la plus probable
5. Donne un plan d'action

Probleme: [description]"""

• Structured output: Utiliser response_schema plutot que "reponds en JSON"
• Grounding: Ajouter Google Search pour les faits recents
• Thinking: Activer le thinking budget pour le raisonnement complexe
• Temperature 0: Pour les taches deterministes (extraction, classification)
• Multimodal: Combiner texte + images pour des prompts plus riches
• System instruction: Placer les regles stables ici (cacheable)

• Vague: "Fais quelque chose de bien" -> Preciser les criteres
• Trop long: Prompts > 2000 mots -> Decomposer en etapes
• Contradictions: Instructions conflictuelles -> Prioriser
• Sans format: Pas de format demande -> Reponse imprevisible
• Ignorer system: Tout dans le prompt -> Separer system/user

# MAUVAIS
"Analyse ce texte et fais-en quelque chose"

# BON
"""Analyse le texte suivant et produis:
1. Resume en 3 phrases
2. 5 mots-cles
3. Sentiment (positif/negatif/neutre)
4. Score de confiance (0-1)
Format: JSON"""

from google.genai import types

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Analyse ce contenu...",
    config=types.GenerateContentConfig(
        safety_settings=[
            types.SafetySetting(
                category="HARM_CATEGORY_HARASSMENT",
                threshold="BLOCK_ONLY_HIGH"
            ),
            types.SafetySetting(
                category="HARM_CATEGORY_HATE_SPEECH",
                threshold="BLOCK_MEDIUM_AND_ABOVE"
            ),
        ]
    )
)

# Lire les safety ratings
candidate = response.candidates[0]
for rating in candidate.safety_ratings:
    print(f"{rating.category}: {rating.probability}")
    # NEGLIGIBLE, LOW, MEDIUM, HIGH

# Gerer le blocage
if candidate.finish_reason == "SAFETY":
    print("Reponse bloquee par filtres de securite")
    for rating in candidate.safety_ratings:
        if rating.blocked:
            print(f"Bloque par: {rating.category}")

• Tailles: 1B, 4B, 12B, 27B parametres
• Licence: Open weights, usage commercial autorise
• Multimodal: Vision native (4B+)
• Contexte: 128K tokens
• Deploiement: On-device, edge, cloud, NVIDIA, TPU

# Utiliser Gemma 3 via Hugging Face
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-3-27b-it")
tokenizer = AutoTokenizer.from_pretrained(
    "google/gemma-3-27b-it")

• NotebookLM: Assistant de recherche personnel base sur vos documents
• Audio Overview: Genere des podcasts audio a partir de documents
• NotebookLM Plus: Version payante avec plus de sources et d'usage

Workspace AI (Gemini for Workspace):

• Gmail: Resume de threads, drafts, reponses
• Docs: Generation, resume, reformulation
• Sheets: Formules, analyse de donnees, graphiques
• Slides: Generation de presentations, images
• Meet: Transcription, resume, notes automatiques

• Code Assist: Assistant de coding IA integre dans les IDE
• Completions: Code inline, multi-fichier, context-aware
• Chat: Discussion sur le codebase dans l'IDE
• Customisation: Fine-tuning sur votre codebase prive

Jules:

• Agent de coding asynchrone (GitHub integration)
• Assigne des issues GitHub a Jules
• Cree des PRs automatiquement
• Review et corrections de code

• Project Astra: Agent multimodal universel de Google DeepMind
• Vision en temps reel (camera)
• Comprehension spatiale et temporelle
• Conversation naturelle continue

Project Mariner:

• Agent de navigation web autonome
• Comprend et interagit avec les pages web
• Remplit des formulaires, navigue, extrait des donnees
• Execute des workflows multi-etapes sur le web