Context Engineering — Section 2 : Sources de Contexte

Panier de sources (avec usages typiques)

• Docs internes (PDF/DOCX/MD) — politiques, procédures, guides → réponses sourcées.
• SQL/NoSQL — référentiels produits, SLA, KPI → tableaux, calculs et contraintes.
• APIs — prix, stocks, météo, incidents → enrichissement just-in-time.
• Logs/metrics/traces — diagnostic incidents, post-mortems → agents SRE.
• Knowledge Graphs — entités/relations → explication & raisonnement.
• Emails/Tickets — contexte client, historique → support/CSAT.

     [DOCS]──┐
     [SQL ]──┼─► Normalisation → Chunking → Embeddings → Index hybride
     [APIs]──┤
     [LOGS]──┤
     [ KG ]──┘

ETL/ELT : étapes et responsabilités

[Connecteur] → [Extraction] → [Nettoyage/PII] → [Normalisation] → [Split/Chunk]
            → [Enrichissement métadonnées] → [Persistance blob + index]

• Extraction : S3/SharePoint/GDrive, Postgres/Snowflake, Confluence/Jira, REST/GraphQL.
• Nettoyage/PII : masquage e-mails/téléphone/clefs, filtres secrets (regex+NER).
• Normalisation : HTML→Markdown, encodage UTF-8, suppression entêtes/pieds.
• Chunking : 512–1200 tokens, overlap 10–20%, par titres si MD/HTML.
• Enrichissement : auteur, version, langue, produit, tenant, droits d’accès.
• Persistance : blob store + index vectoriel & lexical + catalogue des métadonnées.

Lexical + Vectoriel + Re-ranking (hybride)

• Lexical (BM25) : mots-clés, références, numéros d’articles/erreurs.
• Vectoriel (embeddings) : sémantique, paraphrases, synonymes.
• Fusion : RRF (reciprocal rank fusion) puis re-ranking (cross-encoder) sur top-50→top-10.

Stratégies de retrieval

• Multi-query : variantes “déf/étapes/examples/caveats”.
• Filtres : récence, tenant, langue, rôle, produit/version, zone.
• Boost : titres/H1, sections “Procédure” ou “Résumé”, champs tags.
• Cache : re-use de fenêtres et d’assemblages de contexte.

Query → BM25 (top50) ┐
                      ├─► RRF ─► Re-rank (cross-encoder) ─► Top-k context
Embeddings (top50) ──┘

Schéma minimal recommandé

{
  "doc_id": "kb-2025-00142",
  "source": "confluence",
  "title": "Procédure d'escalade N2",
  "lang": "fr",
  "version": "v2025.3",
  "effective_date": "2025-08-01",
  "tenant": "acme-eu",
  "tags": ["SRE","incident","N2"],
  "access": ["role:sre","dept:ops"],
  "permalink": "https://kb/acme/kb-2025-00142",
  "hash": "sha256:…"
}

Métriques et tests

• Freshness (âge moyen), Coverage (répartition par tags/produits), Completeness (métadonnées obligatoires).
• Retrieval@k sur jeux “gold” (questions → passages attendus), faithfulness avec citations.
• Tableau de bord coûts (tokens in/out, latence p50/p95, cache hit-rate).

Contrôles essentiels

• PII scrubbers à l’ingestion (regex + NER) + journalisation masquée.
• RBAC jusqu’au retrieval (filtres par rôle/tenant/équipe).
• Chiffrement au repos (KMS) & en transit (TLS).
• Rétention différenciée : corpus, prompts, traces, mémoires.
• Lineage : qui a vu quoi, quand (auditable).

Connecteurs de base (lecture seule)

• Fichiers : S3, Azure Blob, GCS, SMB/SharePoint.
• Wikis : Confluence, Notion, GitBook, MediaWiki.
• Code : GitHub/GitLab/Bitbucket (blobs + AST pour résumés).
• Tickets : Jira, ServiceNow, Zendesk.
• Emails : IMAP, Gmail API.
• Bases : Postgres, MySQL, MSSQL, BigQuery, Snowflake.
• Logs : OpenSearch, Loki, Datadog, Elastic.
• KG : Neo4j, Neptune, RDF/SPARQL.
• APIs : REST/GraphQL (schémas, throttling, cache TTL).

Python — Contrat DocumentItem & chunking

from dataclasses import dataclass
from typing import Dict, List

@dataclass
class DocumentItem:
    doc_id: str
    content: str
    metadata: Dict[str, str]

def chunk(text: str, max_tokens=900, overlap=120) -> List[str]:
    # pseudo: coupe par tokens ou par titres si Markdown/HTML
    return split_by_headings_or_tokens(text, max_tokens, overlap)

Python — Recherche hybride (RRF + re-ranking)

def hybrid_search(q: str, k=8):
    bm = bm25_search(q, top=50)
    ve = vector_search(q, top=50)
    fused = rrf_fusion([bm, ve])
    reranked = cross_encoder_rerank(q, fused)
    return reranked[:k]

SQL — Vue matérialisée (lexical)

CREATE MATERIALIZED VIEW kb_docs AS
SELECT
  doc_id,
  title,
  to_tsvector('french', coalesce(title,'') || ' ' || coalesce(content,'')) AS tsv,
  metadata->>'lang'      AS lang,
  metadata->>'tenant'    AS tenant,
  metadata->>'version'   AS version,
  metadata->>'permalink' AS permalink
FROM raw_docs;

Contrat “DocumentItem” (JSON Schema)

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "DocumentItem",
  "type": "object",
  "required": ["doc_id","content","metadata"],
  "properties": {
    "doc_id": {"type":"string"},
    "content": {"type":"string"},
    "metadata": {
      "type":"object",
      "required": ["source","lang","permalink"],
      "properties": {
        "source":{"type":"string"},
        "title":{"type":"string"},
        "lang":{"type":"string"},
        "tenant":{"type":"string"},
        "version":{"type":"string"},
        "tags":{"type":"array","items":{"type":"string"}},
        "access":{"type":"array","items":{"type":"string"}},
        "permalink":{"type":"string"}
      }
    }
  }
}

Bascule vers un pipeline de contexte (6 étapes)

1. Cartographier les sources, propriétaires, DPO, droits et versions.
2. Établir le contrat DocumentItem + schéma des métadonnées.
3. Construire l’ingestion (PII scrub, chunking, normalisation, catalogue).
4. Indexer en hybride (BM25+vecteur) + re-ranking + filtres RBAC.
5. Observer (retrieval@k, freshness, coût, cache) + tests gold.
6. Industrialiser (policies, retention, lineage, budgets tokens).