Context Engineering — Section 1 : Introduction

Livrables concrets

• Schéma JSON des prompts (sections/roles/constraints).
• Templates assemblage (Jinja/Django).
• Policy pack : RGPD, secrets, redaction, PII scrubbers.
• Playbooks : support, code copilots, analytics.
• Dashboards : coûts, latence, erreurs, health.
• Corpus indexé (chunk + embeddings cohérents).
• Repair prompts + validateurs (pydantic/jsonschema).
• Scripts d’évaluation (gold sets, LLM-as-judge groundé).

Gabarit (template Django)

{% with ctx=builder.build(user, question) %}
{{ ctx.system }}
Contexte:
- Faits: {{ ctx.facts|join:" | " }}
- Citations: {{ ctx.citations|length }} ref.
Question: {{ ctx.user }}
Contraintes: {{ ctx.constraints|join:", " }}
{% endwith %}

Glossaire minimal

• Chunking : découpage docs.
• Embeddings : vecteurs.
• Hybrid search : BM25 + vecteur.
• RRF : fusion de rangs.
• Re-ranking : rerang par cross-encoder.
• Context cache : réutilisation.
• Guarded output : validation JSON.
• KG : Knowledge Graph.

Architecture type (texte)

[Ingestion] → [Indexation] → [Retrieval Hybride] → [Compression]
         → [Assembly: system+facts+citations+constraints] → [LLM/Agents]
         → [Validation JSON + Repair] → [Logging/Telemetry] → [Feedback Loop]

Pseudo-code d’orchestration

def answer(question, user, role):
    sources = retrieve_hybrid(question, k=8, user=user)
    distilled = compress_sources(sources, target_tokens=1200)
    prompt = assemble(role=role, facts=distilled.facts,
                      citations=distilled.citations,
                      constraints=["Réponse ≤ 250 mots","Puces","+ JSON si liste"])
    raw = call_llm(prompt, temperature=0.2, tools=TOOLS)
    return validate_or_repair(raw, schema=ANSWER_SCHEMA)

Deux cas d’usage

1. Support interne : docs IT + tickets → réponses sourcées, format FAQ.
2. Copilot code : contexte repo + issues + conventions → patch minimal + tests.

5 patterns recommandés

1. Sectioned Prompt (roles/system/user/tools/constraints).
2. Facts→Claims→Citations (chaque claim référencé).
3. Task-Split : retrieve → compress → answer.
4. Memory-First : profil utilisateur + historique avant retrieval.
5. Guarded Output : validation JSON + repair.

Anti-patterns fréquents

• Coller des blobs (docs entiers non résumés).
• Absence de rôle/contraintes/format.
• Pas d’ID source ni de citations.
• Mélanger mémoire session et profil permanent.
• Pas d’observabilité/coûts.
• Ignorer PII/consentement.

Trois exemples

1. Juridique : prompts structurés + citations RGPD → fiches synthèse.
2. Support N2 : facts + runbooks + tool use (Grafana/PagerDuty).
3. Code : patch minimal + tests + chemins exacts.

{
  "system":"Assistant RGPD",
  "context":{"facts":["Art.5…","Art.32…"],"citations":[{"doc_id":"rgpd.md","loc":"§5.1"}]},
  "user":"Puis-je conserver les logs 6 mois ?",
  "constraints":["Puces","≤180 mots","Cite les articles"]
}

Gabarit (Django Template)

{{ system_block }}
Contexte:
- Faits: {{ facts|join:"; " }}
- Citations: {{ citations|length }} ref.
Question: {{ user_question }}
Contraintes: {{ constraints|join:", " }}

Validateur (pydantic)

class Answer(BaseModel):
    summary: str
    steps: list[str]
    confidence: float
    citations: list[dict]

Playbook (6 étapes)

1. Auditer vos prompts actuels, coûts, échecs typiques.
2. Définir un schéma de prompt + patrons de sortie.
3. Indexer le corpus (chunking/embeddings/KG).
4. Assembler un Context Builder (service/SDK).
5. Observer (logs/metrics/coûts) + tests automatiques.
6. Industrialiser (cache, policies, repair, guardrails).

def migrate_to_context_eng():
    audit = audit_prompts()
    schema = define_prompt_schema()
    index = build_index(corpus)
    builder = build_context_builder(schema, index)
    obs = setup_observability()
    return rollout(builder, obs)

KPI & ROI (exemple)

Risques & mitigations

• PII leak → scrubbers + masquage + RBAC.
• Hallucination → citations obligatoires + re-rank.
• Coût → compression + cache + batching.
• Drift corpus → index refresh programmé.
• Tech debt → schema versioning + tests.