Gemini 2.5 Pro – Limites & Défis (et comment les contourner)

Gemini 2.5 est probabiliste : il peut produire un code “plausible mais faux”, oublier le début d’un long fil, ou coûter cher si le contexte est verbeux. Il faut contraindre la sortie, réduire/structurer le contexte et industrialiser les appels API.

🧷 Hallucinations & incohérences — Parades

• Sortie typée : response_mime_type="application/json" + response_schema ; refuser la réponse si invalide.
• Preuves exigées : chemins de fichiers, diff unifié si modif, signatures exactes, commandes de vérif (tests/grep).
• RAG/Grounding Vertex AI Search : citer les passages/URLs injectés (sources obligatoires).
• Température 0–0.3 pour code/SQL, stop_sequences pour couper net.

🧮 Contexte & tokens — Parades

• Utiliser un STATE PACK < 250–400 mots (stack/versions, fichiers autorisés, étape demandée, bornes).
• Découper en étapes courtes (voir “Contexte & Sessions”) ; resets réguliers.
• Factoriser prompts communs + cache des réponses stables.

🔁 Quotas/erreurs — robustesse

import time, random
def call_with_backoff(fn, *a, **kw):
    backoff=0.8
    for i in range(6):
        try: return fn(*a, **kw)
        except Exception as e:
            if "429" not in str(e) and "5" not in str(e): raise
            time.sleep((2**i)*backoff + random.random()*0.3)
    raise RuntimeError("API unavailable after retries")

🧩 Config Vertex (JSON strict)

from vertexai.generative_models import GenerativeModel, GenerationConfig, ResponseSchema
model = GenerativeModel("gemini-2.5-pro")
schema = ResponseSchema(type="object", properties={
  "files":{"type":"array","items":{"type":"object","properties":{
    "path":{"type":"string"}, "action":{"type":"string","enum":["create","patch"]},
    "content":{"type":"string"}}}},
  "commands":{"type":"array","items":{"type":"string"}}
}, required=["files"])
cfg = GenerationConfig(temperature=0.2, top_p=0.9, max_output_tokens=800,
                       response_mime_type="application/json", response_schema=schema)

🧱 Prompt anti-hallucinations

"Avant le code :
- Cite les fichiers exacts touchés (+ diff si modif).
- Donne 2 alternatives et justifie le choix.
- Liste les commandes de vérif (pytest, manage.py, grep...)."

Sur la durée, le contexte “flotte”. On perd la cohérence de nommage, les décisions se contredisent et la dette augmente. Il faut des rituels et une traçabilité.

📦 STATE PACK (rappel systématique)

PROJET : <nom> — Stack & versions (Python 3.12, Django 5…)
CONTRAINTES : bloc par fichier / JSON (schema), chemins autorisés
DERNIÈRE ÉTAPE VALIDÉE : <…>
ÉTAPE DEMANDÉE : <une seule>
BORNES : ≤ 120 lignes cumulées ➜ STOP & question

🔁 Itérations courtes & resets

• Une issue = une conversation ; “plan 3–5 étapes” puis OK étape 1 seule.
• Soft reset (même fil) si dérive ; Hard reset (nouveau fil) à chaque pivot majeur.
• ADR (decision record) par choix structurant ; PR template (DoD/tests/risques).

📊 Observabilité & coûts

• Journaliser : latence p95, tokens in/out, coût/feature, % réponses “incertaines”.
• Alertes quotas/erreurs ; budgets mensuels par environnement.

🧱 Prompt “cadre d’itération”

"Propose un plan 3–5 étapes pour <objectif>.
Attends mon OK puis livre seulement l’étape 1 (≤ 60 lignes).
Bloc par fichier, tests. Si plus long ➜ STOP et propose un split."

Réduire l’exposition : minimisation, contrôles techniques, documentation. Dans Vertex AI, exploite IAM et régions.

🔒 RGPD & confidentialité

• Pas de secrets/PII en clair dans les prompts. Utiliser placeholders/chiffrement ; Secret Manager pour les clefs.
• Choisir la région (conformité), journaliser anonymisé avec rétention limitée.
• DPIA/registre : décrire traitements, bases légales, finalités ; DPA fournisseur.

© Copyright / licences

• Éviter les copiés/collés d’œuvres identifiables ; préférer les patterns/guides.
• Traçabilité : prompts, sources RAG, décisions (ADR) ; respecter les notices/licences.

🔗 Vendor lock-in & risques d’API

• Abstraction par adaptateur (interface modèle) pour switche r rapidement.
• Timeouts, retry/backoff, circuit breaker, cache ; idempotence serveur.
• Suivi des coûts par feature + garde-fous budgétaires.

🧱 Prompt “sécurité & conformité”

"Avant la réponse :
- Indique si PII/secrets seraient nécessaires et propose un masquage.
- Liste 2 risques licence/RGPD + mesures.
- Donne la région recommandée et les logs à activer."

L’IA assiste ; la revue humaine reste obligatoire. En prod, même hygiène : tests, CI/CD, sécurité, observabilité.

👀 Revue (checklist)

• PEP8/linters ; noms/chemins ; diff minimal ; commentaires de tête si logique non triviale.
• Tests présents (succès/erreur/edge) et passants ; commandes d’exécution fournies.
• Pas de secrets/PII dans code/prompts ; logs sobres.

🛡️ Sécurité LLM

• Prompt-injection (RAG) : sanitation du contexte, allow-list d’outils, refus si source non fiable.
• Scopes IAM minimaux ; sandbox d’exécution si “code-interpreter”.
• Limites : stop_sequences, temps CPU, taille sortie.

⚙️ CI/CD minimal (ex.)

- lint & format (ruff/eslint) 
- tests (pytest / vitest-rtl)
- build (collectstatic, npm build)
- artefacts (coverage, dist)

📊 Métriques à suivre

• Latence p95, tokens in/out, coût unitaire, taux d’erreurs/quotas.
• Taux de réponses “incertaines” et nb de resets nécessaire.

🧱 Prompt “pair-programmer responsable”

"Agis comme reviewer strict :
- Donne 3 risques/alternatives, choisis et justifie.
- Fournis les commandes de vérif + sortie attendue.
- Si modif → DIFF UNIFIÉ + tests."