LLM Core (Noyau IA)

LLM = réseau entraîné sur d’immenses corpus pour approximer P(next_token | contexte).

• Compréhension : parser une question, identifier objectifs/contraintes.
• Génération : rédiger, résumer, traduire, produire du code.
• Raisonnement limité : chaîner des étapes courtes sous contraintes.

Ce que le LLM n’est pas

• Pas une base de données (mémoire courte, pas d’indexation native).
• Pas un moteur de vérité (peut halluciner).
• Pas connecté au monde réel sans RAG / tools.

Terminologie utile

• Token (BPE/Unigram), logits (scores bruts), température, top-k, top-p.
• Fenêtre de contexte = tokens in + tokens out.

Tokenization

• BPE/WordPiece/Unigram : le texte est scindé en tokens.
• Les espaces et sauts de ligne sont souvent des tokens distincts.
• Budget = coût et latence : compresser l’entrée, éviter le bruit.

Ex.: "ChatGPT est puissant" → ["Chat","G","PT"," est"," puissant"]

Embeddings

• Projection de tokens/phrases/documents en vecteurs (dimension d ~ 512–4096).
• Similarité (cosine) → recherche sémantique, clustering, RAG.
• Normaliser la casse/ponctuation; conserver des métadonnées (titre, page, source).

Transformer

• QKV Self-Attention : pondère chaque token par rapport à tous les autres (coût O(n²)).
• PosEnc/RoPE/ALiBi : intègre la position/ordre.
• Cache d’attention pour streaming; fenêtre ≠ mémoire longue.

Prédiction & Décodage

# Réglages usuels
code/SQL: temperature=0.0–0.2, top_p=0.8–1.0, max_tokens=300
tech:      temperature=0.2–0.5, top_p≈0.9,      max_tokens=600
créatif:   temperature=0.7–1.0, top_p=0.9–1.0,  max_tokens=800
stop=["\nEND", ""]

Compréhension

• Analyse syntaxique/sémantique; classification; sentiments.
• Extraction d’entités/relations; normalisation; tagging PII.

Génération

• Résumé multi-docs, traduction, styles contrôlés, FAQ.
• Génération de code/tests, docs API; explication d’erreurs.

Structuration

• Sorties JSON/CSV/SQL; mapping vers schémas métiers.
• Consolidation multi-sources (map-reduce).

Raisonnement (limité)

• Chaînage guidé (step-by-step); preuve d’algorithme simple.
• Pour calcul exact/planif. profonde → outils spécialisés.

• Pas de mémoire persistante : oubli hors fenêtre (stateful à gérer côté app).
• Hallucinations : réponses plausibles mais fausses / non sourcées.
• Connaissances figées : pas d’actualité ni données privées.
• Mauvaise calibration : excès de confiance possible.
• Coûts/latence : dépend GPU/TPU; fenêtre → prix.
• Sécurité : prompt-injection, jailbreak, exfiltration PII.

Mitigations recommandées

• RAG avec citations + score de confiance + reranking.
• Mémoire (session/long-terme) + politiques TTL & consentement.
• Tools (SQL, calcul, web) sous policies et sandboxes.
• Guardrails : validation de sortie (JSON Schema), filtres sécu, modération.
• Optimisation : cache, batching, contrôle de max_tokens, prompts compacts.

Cerveau brut

Le LLM offre l’intelligence linguistique, mais dépend des autres briques pour mémoire, action et fiabilité.

Dépendances clés

• RAG : actualise et source les réponses (citations).
• Mémoire : session & long-terme (profil/intentions).
• Agents/Tools : appels API, SQL, calcul, navigation.
• Guardrails : politiques, validation schéma, modération.

Contrats & Ops

• Contrats d’entrée (role, objectif, format, contraintes).
• Contrats de sortie (JSON Schema), tests de régression.
• Observabilité : latence, coûts, erreurs/outils, taux de groundedness.

Support & FAQ augmentés

• RAG + citations + seuil de confiance + critères d’escalade.
• Détection PII, templates de réponse conformes.
• KPI : CSAT, FCR, groundedness, temps de réponse.

Assistant développeur

• Génération de tests, refactor, secure-review.
• Explication de logs/traces, requêtes SQL de diagnostic.
• KPI : bugs évités, temps gagné, taux d’adoption.

Extraction / Structuration

• Parse PDF → JSON/CSV/SQL, NER/relations.
• Contrats de sortie + validation; échantillons de QA.
• KPI : précision champs, couverture, coûts/1000 docs.

Assistant documentation interne

# Ingestion
chunks = split_all(pdfs, 1200, 150)
index  = VectorStore(); index.add([embed(c.text, meta=c.meta) for c in chunks])

# Query
ctx    = index.search(embed(q), top_k=6)          # + reranker BM25/cross-encoder
prompt = render(tpl, {"q": q, "passages": ctx, "need_citations": true,
                      "format": "JSON {answer, citations[], confidence}"})
res    = llm.generate(prompt, temperature=0.2, top_p=0.9)
assert validate_json(res, schema)

• Évaluer : answer correctness, citations valides, temps/req, coût/req.
• Fallback : “je ne sais pas” en dessous d’un seuil de confiance.

Agent SQL (lecture seule)

# Tool contract (JSON Schema)
{"name":"sql_read","parameters":{"type":"object",
 "properties":{"sql":{"type":"string"}}, "required":["sql"]}}

# Policy guardrails
{"allow":["sql_read"], "deny":["sql_write","shell.exec"],
 "norms":["read-only", "timeout:15s", "row_limit:1000"]}

# Loop (simplifié)
msg = llm.chat(messages, tools=[sql_read])
if msg.tool_call == "sql_read": data = db.read(msg.args.sql)
final = llm.chat(messages + tool_response(data))

• Whitelist de schémas (vue en lecture seule), masquage PII.
• Tests de red teaming (prompt-injection SQL, exfiltration).