Formation LLM & IA Générative 2026
Prompt engineering · RAG · Fine-tuning LoRA · Agents

1. L’attention multi-têtes — le mécanisme central

L’attention calcule pour chaque token sa pertinence vis-à-vis de tous les autres tokens de la séquence. La formule : Attention(Q,K,V) = softmax(QKᵀ/√dₖ)V. Les heads multiples capturent différents types de relations (syntaxe, sémantique, coreference) en parallèle.

• Context window : nombre maximal de tokens que le modèle peut traiter en une fois. GPT-4 : 128k, Claude 3.5 : 200k. Au-delà, il faut chunker ou utiliser du RAG.
• KV Cache : les valeurs K et V des tokens précédents sont mises en cache — indispensable pour la génération efficace token par token.
• Positional encoding : RoPE (Rotary Position Embedding) dans les modèles modernes permet de généraliser à des longueurs de séquence non vues à l’entraînement.

2. Tokenisation — ce que le modèle voit vraiment

import tiktoken

# Tokenisation GPT-4
enc = tiktoken.encoding_for_model("gpt-4")
text = "L'IA générative transforme le développement logiciel en 2025."
tokens = enc.encode(text)
print(f"Tokens : {len(tokens)} | Texte : {len(text)} chars")
print([enc.decode([t]) for t in tokens])

# Estimer le coût avant un appel API
def estimate_cost(text, model="gpt-4o", input_price_per_1m=5.0):
    enc = tiktoken.encoding_for_model(model)
    n_tokens = len(enc.encode(text))
    cost = n_tokens / 1_000_000 * input_price_per_1m
    return {"tokens": n_tokens, "cost_usd": round(cost, 6)}

3. Temperature, top-p, top-k — contrôler la créativité

• Temperature = 0 : déterministe, toujours le token le plus probable. Recommandé pour extraction, classification, code.
• Temperature = 0.7–1.0 : créatif, varié. Recommandé pour génération de texte, brainstorming.
• Top-p (nucleus sampling) : échantillonne uniquement parmi les tokens dont la probabilité cumulée dépasse p. Top-p=0.9 est une valeur standard.
• Presence/frequency penalty : réduit les répétitions. Utile pour les générations longues.

1. Few-shot et Chain-of-Thought

from anthropic import Anthropic

client = Anthropic()

# Chain-of-Thought : forcer le raisonnement étape par étape
cot_prompt = """Analyse ce contrat et identifie les clauses risquées.
Réfléchis étape par étape :
1. Identifie les parties prenantes
2. Liste les obligations de chaque partie
3. Repère les clauses de pénalité ou de responsabilité
4. Évalue le niveau de risque global (Faible/Moyen/Élevé)

Contrat : {contract_text}"""

# Few-shot : exemples pour calibrer le format de sortie
few_shot_messages = [
    {"role": "user", "content": "Sentiment : 'Produit excellent, livraison rapide'"},
    {"role": "assistant", "content": '{"sentiment": "positif", "score": 0.95, "aspects": ["produit", "livraison"]}'},
    {"role": "user", "content": "Sentiment : 'Déçu, emballage abimé et SAV inexistant'"},
    {"role": "assistant", "content": '{"sentiment": "négatif", "score": 0.08, "aspects": ["emballage", "SAV"]}'},
    {"role": "user", "content": "Sentiment : 'Prix correct mais délais trop longs'"},
]

response = client.messages.create(
    model="claude-opus-4-6", max_tokens=200,
    messages=few_shot_messages
)

2. Structured output — JSON garanti avec Pydantic

from openai import OpenAI
from pydantic import BaseModel
from typing import Literal

client = OpenAI()

class ContractAnalysis(BaseModel):
    risk_level: Literal["faible", "moyen", "élevé"]
    risky_clauses: list[str]
    missing_protections: list[str]
    summary: str
    confidence: float

# Structured output GPT-4o — JSON garanti, aucun parsing manuel
completion = client.beta.chat.completions.parse(
    model="gpt-4o-2024-08-06",
    messages=[
        {"role": "system", "content": "Tu es un expert juridique. Analyse le contrat."},
        {"role": "user", "content": contract_text}
    ],
    response_format=ContractAnalysis,
)
result = completion.choices[0].message.parsed
print(f"Risque : {result.risk_level} | Confiance : {result.confidence:.0%}")

3. Prompt caching — réduire les coûts de 90%

# Anthropic prompt caching — le system prompt long est mis en cache
# Coût cache hit : 0.10$/M tokens vs 3$/M tokens (économie 97%)
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": long_knowledge_base,  # 100k tokens de documentation
        "cache_control": {"type": "ephemeral"}  # mis en cache 5 minutes
    }],
    messages=[{"role": "user", "content": user_question}]
)
# Vérifier le cache hit
print(response.usage.cache_read_input_tokens)  # tokens lus depuis cache

1. Quand fine-tuner vs RAG vs prompt engineering ?

2. LoRA — Low-Rank Adaptation

LoRA gèle les poids originaux du modèle et entraîne uniquement de petites matrices de rang bas injectées dans les couches d’attention. Paramètres entraînés : ~0.1% du modèle original. Mémoire GPU : réduite de 10×.

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer

# Chargement avec quantisation 4-bit (QLoRA)
from transformers import BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3-8B-Instruct",
    quantization_config=bnb_config,
    device_map="auto"
)

# Configuration LoRA
lora_config = LoraConfig(
    r=16,                        # rang des matrices LoRA
    lora_alpha=32,               # scaling factor
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM,
)

peft_model = get_peft_model(model, lora_config)
peft_model.print_trainable_parameters()
# trainable params: 6,815,744 || all params: 8,037,224,448 || trainable%: 0.085

3. Préparation du dataset de fine-tuning

from datasets import Dataset

# Format Alpaca — instruction + input + output
def format_alpaca(example):
    if example['input']:
        text = f"""### Instruction:\n{example['instruction']}\n\n### Input:\n{example['input']}\n\n### Response:\n{example['output']}</s>"""
    else:
        text = f"""### Instruction:\n{example['instruction']}\n\n### Response:\n{example['output']}</s>"""
    return {"text": text}

# Règle d’or : minimum 500 exemples de qualité vaut mieux que 50k exemples bruités
dataset = Dataset.from_list(training_examples)
dataset = dataset.map(format_alpaca)
train_test = dataset.train_test_split(test_size=0.1, seed=42)

1. Chunking — le paramètre le plus critique du RAG

La qualité du chunking détermine 80% de la qualité du RAG. Un chunk trop petit perd le contexte ; trop grand noie le signal. La stratégie optimale dépend du type de document.

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader

# Chunking sémantique avec overlap
splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,          # ~200 tokens, optimal pour retrieval
    chunk_overlap=150,       # overlap pour éviter de couper les idées
    separators=["\n\n", "\n", ".", " ", ""],
    length_function=len
)

loader = PyPDFLoader("documentation.pdf")
pages = loader.load()
chunks = splitter.split_documents(pages)

# Enrichir les métadonnées pour le filtrage
for i, chunk in enumerate(chunks):
    chunk.metadata['chunk_id'] = i
    chunk.metadata['source_page'] = chunk.metadata.get('page', 0)
    chunk.metadata['word_count'] = len(chunk.page_content.split())

2. Embeddings et vector store avec ChromaDB

from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

# text-embedding-3-small : 1536 dims, 0.02$/M tokens
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Indexation dans ChromaDB (persité sur disque)
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db",
    collection_name="documentation"
)

# Recherche hybride : similarité cosinus + filtre métadonnées
retriever = vectorstore.as_retriever(
    search_type="mmr",             # Maximal Marginal Relevance — diversité
    search_kwargs={
        "k": 6,                     # top-6 chunks
        "fetch_k": 20,              # candidats avant MMR
        "lambda_mult": 0.7,         # 0=diversité max, 1=similarité pure
    }
)

3. Pipeline RAG complet avec LCEL

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

prompt = ChatPromptTemplate.from_template("""
Tu es un assistant expert. Réponds uniquement à partir des documents fournis.
Si la réponse n’est pas dans les documents, dis-le explicitement.

Contexte :
{context}

Question : {question}
""")

def format_docs(docs):
    return "\n\n---\n\n".join(
        f"[Source: {d.metadata.get('source', 'inconnu')}, p.{d.metadata.get('source_page','')}]\n{d.page_content}"
        for d in docs
    )

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | ChatOpenAI(model="gpt-4o-mini", temperature=0)
    | StrOutputParser()
)
answer = rag_chain.invoke("Quelles sont les conditions de garantie ?")

1. Streaming avec FastAPI — réponses en temps réel

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from anthropic import Anthropic
import asyncio

app = FastAPI()
client = Anthropic()

@app.get("/chat/stream")
async def chat_stream(question: str):
    async def generate():
        with client.messages.stream(
            model="claude-opus-4-6",
            max_tokens=1024,
            messages=[{"role": "user", "content": question}]
        ) as stream:
            for text in stream.text_stream:
                yield f"data: {text}\n\n"
                await asyncio.sleep(0)
            yield "data: [DONE]\n\n"

    return StreamingResponse(generate(), media_type="text/event-stream")

2. Fallback multi-provider et retry exponentiel

import asyncio, logging
from openai import AsyncOpenAI, RateLimitError, APIError

providers = [
    {"client": AsyncOpenAI(), "model": "gpt-4o-mini"},
    {"client": AsyncOpenAI(base_url="https://api.together.xyz/v1"),
     "model": "meta-llama/Llama-3-8b-chat-hf"},
]

async def llm_with_fallback(messages, max_retries=3):
    for provider in providers:
        for attempt in range(max_retries):
            try:
                resp = await provider["client"].chat.completions.create(
                    model=provider["model"], messages=messages
                )
                return resp.choices[0].message.content
            except RateLimitError:
                wait = 2 ** attempt
                logging.warning(f"Rate limit, attente {wait}s...")
                await asyncio.sleep(wait)
            except APIError as e:
                logging.error(f"API error provider {provider['model']}: {e}")
                break
    raise RuntimeError("Tous les providers ont échoué")

1. Tool use avec l’API Anthropic

from anthropic import Anthropic
import json, requests

client = Anthropic()

# Définition des outils disponibles pour l’agent
tools = [
    {
        "name": "search_web",
        "description": "Recherche des informations actuelles sur le web",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Requête de recherche"}
            },
            "required": ["query"]
        }
    },
    {
        "name": "execute_python",
        "description": "Exécute du code Python et retourne le résultat",
        "input_schema": {
            "type": "object",
            "properties": {
                "code": {"type": "string", "description": "Code Python à exécuter"}
            },
            "required": ["code"]
        }
    }
]

def run_agent(user_message, max_iterations=10):
    """Boucle ReAct : Reason → Act → Observe → répéter"""
    messages = [{"role": "user", "content": user_message}]

    for _ in range(max_iterations):
        response = client.messages.create(
            model="claude-opus-4-6", max_tokens=4096,
            tools=tools, messages=messages
        )

        if response.stop_reason == "end_turn":
            return response.content[0].text

        # Exécuter les outils demandés
        messages.append({"role": "assistant", "content": response.content})
        tool_results = []

        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": str(result)
                })
        messages.append({"role": "user", "content": tool_results})

2. Évaluation des réponses — détecter les hallucinations

# Faithfulness check — la réponse est-elle supportée par le contexte ?
def check_faithfulness(context: str, answer: str, client) -> dict:
    prompt = f"""Évalue si cette réponse est factuellement supportée par le contexte.

Contexte : {context}

Réponse à évaluer : {answer}

Réponds en JSON : {{"faithful": true/false, "score": 0-1, "unsupported_claims": [...]}}"""

    result = client.messages.create(
        model="claude-opus-4-6", max_tokens=500,
        messages=[{"role": "user", "content": prompt}]
    )
    return json.loads(result.content[0].text)