Mistral – 🔌 Intégrations & API

Comparatif rapide

vLLM – OpenAI-compatible

python -m vllm.entrypoints.openai.api_server \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --tensor-parallel-size 2 --max-model-len 32768 \
  --gpu-memory-utilization 0.92

# Appel client (Python)
from openai import OpenAI
client = OpenAI(base_url="http://HOST:PORT/v1", api_key="dummy")
client.chat.completions.create(model="mistral", messages=[{"role":"user","content":"Bonjour"}])

Bonnes pratiques

• Activer paged KV cache, adapter max_model_len.
• Quantization prudente (8-bit) + canary FP16.
• Profiler : tokens/s, VRAM, latence p95/p99, OOM tardifs.

REST (FastAPI – streaming SSE)

@app.post("/v1/chat/completions")
async def chat(req: ChatReq):
    async with sse_response() as stream:
        async for token in llm.stream(req):
            await stream.send({"delta": token})
    return {"finish_reason":"stop"}

gRPC (proto – extrait)

service LLM {
  rpc ChatStream(ChatReq) returns (stream ChatChunk);
}
message ChatReq { repeated Message messages = 1; string model = 2; }
message ChatChunk { string delta = 1; bool end = 2; }

Conteneurs

# Dockerfile (extrait)
FROM nvidia/cuda:12.2.0-runtime
RUN pip install vllm fastapi uvicorn
CMD ["python","-m","vllm.entrypoints.openai.api_server","--model","mistralai/Mistral-7B-Instruct"]

K8s (extraits)

# Deployment
spec:
  template:
    spec:
      containers:
        - name: vllm
          image: registry/vllm:latest
          resources: {limits: {nvidia.com/gpu: 1}}
---
# HPA (QPS/tokens/s métrique custom)

Sécurité & quotas

• Auth Bearer + rate-limit (clé/par org).
• CORS restrictif, request/response size limits.
• Quota par modèle, “max_new_tokens” et “frequency penalty”.

LangChain (ex.)

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA

llm = ChatOpenAI(base_url="http://HOST:PORT/v1", api_key="x", model="mistral")
emb = OpenAIEmbeddings(base_url="http://HOST:PORT/v1", api_key="x", model="mistral-embed")
vs = FAISS.from_texts(texts, emb)
qa = RetrievalQA.from_chain_type(llm=llm, retriever=vs.as_retriever(k=5))
qa({"query":"Quelles sont les étapes du pipeline ?"})

LlamaIndex (ex.)

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI
docs = SimpleDirectoryReader("docs").load_data()
index = VectorStoreIndex.from_documents(docs, embed_model="openai")
resp = index.as_query_engine(llm=OpenAI(base_url="http://HOST:PORT/v1", api_key="x")).query("...")

Bonnes pratiques RAG

• Split 500–1500 tok, overlap 10–20 %, titres informatifs.
• Re-rank (BM25/bi-encoder) avant prompt.
• Afficher citations (URL, date) + groundedness.

Prompt RAG (JSON schema)

<policy>Réponds uniquement si justifié par les PASSAGES.</policy>
<format>{"answer":"...","citations":[{"url":"...","title":"..."}]}</format>

Anti-patterns

• Pas de normalisation d’URL/dates → citations incohérentes.
• Top-k trop élevé → bruit & coûts ↑.
• Absence de cache embeddings/index (coûts récurrents).

Déclarer une fonction

{
 "type":"function","function":{
  "name":"search_news",
  "description":"Recherche d'articles",
  "parameters":{
    "type":"object","properties":{"q":{"type":"string"}}, "required":["q"]
}}}

Cycle d’appel

1. LLM propose tool_call + arguments JSON.
2. Orchestrateur exécute dans une sandbox (allow-list, timeouts).
3. Résultat renvoyé comme message tool au LLM (réponse finale).

Sécurité

• Allow-list stricte des outils + scopes limités.
• Quota & timeouts par outil ; pas d’accès réseau brut.
• Audit des appels (inputs/outputs hashés).

Exécution (pseudo FastAPI)

if tool_call:
  if tool_call.name not in ALLOW: refuse()
  result = run_in_sandbox(tool_call.name, tool_call.args)
  messages += [{"role":"tool","name":tool_call.name,"content":serialize(result)}]
  return llm(messages)

Anti-patterns

• Outils non idempotents → effets indésirables.
• Fuite de secrets dans arguments/tools.
• Absence de validations JSON Schema côté serveur.

Logs & PII

• Hash/masquer PII, TTL configurable.
• Redact prompts/contexte sensibles.
• Accès restreint (RBAC) & audit.

Budgets

cost ≈ (tok_in + tok_out) × prix_tok + stockage + egress
alerte si coût/jour > budget × (1+δ)

Cache & idempotence

# Clé = hash(model, params, prompt, ctx_ids)
resp = cache.get(key) or compute_and_set(key, ttl=300)

• ETag côté client pour réutilisation.
• Cache embeddings pour RAG.

A/B & canary

router:
  v1: 90%  → modèle A (référence)
  v2: 10%  → modèle B (nouvelle version)

• Tracker : win-rate, régressions (golden set online).

SLO/SLA

CD (extrait)

- build: docker image
- test: CI (golden set, red-team)
- deploy: canary 10%
- observe: p95, refus, coûts
- promote: 100% si OK

Anti-patterns

• Routage statique → aucun rollback instantané.
• Pas de quotas → abus multi-tenant.
• Logs non nettoyés → risques PII & coût stockage.