Gemini 2.5 – Introduction (dev web)

10 tâches à fort ROI pour un dev web

1. Scaffold Django/React (modèles, vues, routes, tests, CI).
2. CRUD + formulaires + validations réutilisables.
3. Écriture de tests (unitaires/feature) à partir de specs.
4. Migration SQL → ORM (modèles, migrations, fixtures).
5. Refactor sécurisé (diff unifié + plan de tests).
6. Parsing/Transformation (CSV/JSON/HTML) + schémas.
7. Doc technique / ADR automatisés.
8. Génération d’API clients (Python/TS) depuis OpenAPI.
9. Rédaction de jobs (cron/scheduler) et scripts d’ops.
10. Exploration d’erreurs : stack traces + patch minimal.

Patron “Scaffold Django”

RÔLE: Architecte Vertex AI
OBJECTIF: App "blog" (Model Article + Admin + ListView + CreateView + URLs + Templates)
CONTRAINTES:
- Chemins & noms exacts
- TOUTE modif existante = diff unifié
- ≤ 120 lignes par bloc (sinon STOP + "CONTINUER ?")
SORTIE: étapes + code + commandes manage.py + tests

Sortie structurée (le back applique)

from vertexai.generative_models import GenerationConfig, ResponseSchema
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(response_mime_type="application/json", response_schema=schema)

Le backend parse et applique (sécurisé + traçable + idempotent).

Limites typiques

• Hallucinations (faits inventés, code non testable).
• Contexte (fenêtre finie, dérive de conversation).
• Coût/latence (contexte verbeux, décodage long).
• Confidentialité (prompts/logs), quotas (429/5xx).

Mitigations concrètes

• Exiger preuves : tests, commandes, diff unifié, chemins exacts.
• RAG + Grounding (Vertex AI Search) avec citations requises.
• Sortie JSON validée par schema (cf. M2), refuser si invalide.
• Résumé d’état + “reset” régulier du fil (mémoire côté DB).

Fiabilité & opérations

• Retries à backoff exponentiel, idempotence côté serveur.
• Budget tokens par requête, max_output_tokens, cache de réponses stables.
• Observabilité : latence p95, tokens in/out, coût, taux “incertain”.
• RGPD : Secret Manager, masquage logs, choix de région, IAM minimal.

Patrons prêts à l’emploi

A) ONE-FILE PATCH (diff)
RÔLE: Ingénieur Python senior
OBJECTIF: Corriger la fonction X
CONTRAINTES: Donne un DIFF UNIFIÉ + tests unitaires
SORTIE: diff, nouveaux tests, commande pytest

B) MIGRATION SQL → ORM
RÔLE: DBA Django
ENTRÉE: DDL SQL + contraintes
SORTIE: models.py, migration, tests, commandes manage.py

C) BUG → REPRO + FIX
RÔLE: Dév Full-stack
ENTRÉE: trace + snippet
SORTIE: étapes de repro, cause racine, patch (diff), test

Paramètres & garde-fous

• temperature 0–0.3 (code) ; 0.7 (idéation).
• system_instruction = charte (format, ton, refus si incertain).
• Limiter à 120 lignes/bloc ; pause + validation au-delà.
• Imposer chemins de fichiers + “si modif → diff unifié”.

Sortie fortement typée (schema)

from vertexai.generative_models import GenerationConfig, ResponseSchema
schema = ResponseSchema(type="object", properties={
  "summary":{"type":"string"},
  "todos":{"type":"array","items":{"type":"string"}},
  "patch":{"type":"string","description":"Diff unifié si modif"}}, required=["todos"])
cfg = GenerationConfig(response_mime_type="application/json", response_schema=schema)

Streaming (Python)

from vertexai.generative_models import GenerativeModel
model = GenerativeModel("gemini-2.5-pro")
for chunk in model.generate_content("Explique le pattern Repository en Django.", stream=True):
    print(chunk.text or "", end="")

Function Calling (tools)

from vertexai.generative_models import GenerativeModel, Tool, FunctionDeclaration
tool = Tool(function_declarations=[FunctionDeclaration(
  name="lookup_doc",
  description="Recherche interne",
  parameters={"type":"object","properties":{"query":{"type":"string"}},"required":["query"]}
)])
model = GenerativeModel("gemini-2.5-pro")
resp = model.generate_content("Trouve la politique RGPD résumée.", tools=[tool])
# Parcours des tool_calls → exécuter lookup_doc côté back → renvoyer la réponse au modèle si nécessaire

JavaScript (génération simple)

const model = genAI.getGenerativeModel({ model: "gemini-2.5-pro" });
const { response } = await model.generateContent([{text:"Donne un exemple de route Express."}]);
console.log(response.text());

Robustesse

• Timeouts → retry + backoff exponentiel.
• Journaliser prompt, params, latence, tokens, coût.
• Limiter output (stop_sequences) pour éviter les dérives.

Référence d’architecture

Client (Web/CLI)
  → Backend (FastAPI/Django) : orchestrateur, validation, IAM
    → Gemini 2.5 (Vertex AI) : prompts + tools
    → Tools managés : code-interpreter, web, retrieval
    → RAG : Vertex AI Search & Grounding (BigQuery, GCS, sites)
    → Stores : Cloud SQL / Firestore / GCS / Matching Engine (vecteurs)
    → Observabilité : Cloud Logging, Error Reporting, Metrics

Ops

• Cloud Run/Functions, CI Cloud Build, jobs Scheduler.
• Service Accounts dédiés, rôles IAM minimaux.
• Secrets via GCP Secret Manager (clés API/DSN DB).

RAG & Grounding

1. Indexer docs/code → Data Store (Search).
2. Rechercher top-k + citations.
3. Injecter contexte au prompt + demander sources.

Qualité & métriques

• Latence p95, tokens, coût, % réponses “incertaines”.
• Jeux d’évaluation (coverage/groundedness/consistency).
• Alertes : 5xx, over-quota, dérive de coût.

Discipline projet

• 1 issue = 1 conversation, résumé d’état au début.
• Charte de sortie (JSON/diff), preuves (tests/grep).
• Revue humaine obligatoire avant merge (jamais auto-merge).

Mémoire & contexte

• Journal DB des décisions (ADR), versions, env.
• Segmenter en “chapitres” + reset régulier.

Coûts & perfs

• Choisir Pro vs Flash selon qualité/latence.
• Limiter tokens, factoriser prompts communs, cache.
• Mesurer la valeur : temps gagné, défauts évités, coût.

Risques majeurs

• Vendor lock-in → couche d’abstraction + tests cross-models.
• RGPD → anonymisation, minimisation, journalisation.