Mistral – 🧰 Outils & Intégrations

vLLM, SGLang, Ollama, Hugging Face, API OpenAI-compat & Tool Calling. Modales ultra-densifiées : schémas, tableaux comparatifs, snippets prêts à l’emploi, checklists Dev/Ops & sécurité.

Interop rapide Throughput & p95 Policies & sandbox

Démarrage (serveur)

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

Client (Python)

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

Bonnes pratiques

Adapter max_model_len & quotas max_new_tokens.
Activer logs latence p50/p95, tokens/s, OOM tardifs.
Canary FP16 vs INT8/4 (qualité vs coût).

Throughput ≈ (batch_effectif × tok_out) / latence_step — surveiller p95/p99

Concept

Plan d’exécution expressif (DSL) : prompts paramétrés, boucles, outils.
Scheduling avancé : batch fusion, préemption, streaming.
Compatible OpenAI-compat pour intégrations existantes.

Script (extrait pseudo-DSL)

task "summarize" {
  input: doc
  step llm: chat(model:"mistral", sys:"JSON only", 
                 user:"Résume : ", max_new_tokens:256)
  output: llm.answer
}

Ops

Exporter métriques tok/s, latence & erreurs par étape.
Limiter la taille des buffers & timeouts par step.
Valider schémas JSON à chaque sortie.

Client → SGLang Scheduler → Exécuteurs GPU → Stream → Validations/Policies

Commandes essentielles

ollama pull mistral
ollama run mistral "Explique RoPE en 3 points."

Modelfile

FROM mistral:latest
PARAMETER temperature 0.3
SYSTEM "Réponds en JSON strict."
TEMPLATE "\n"

Cas d’usage

Edge/air-gap, POC rapides, démonstrations offline.
Quantization INT8/4 pour VRAM limitée (qualité à valider).
Proxy local vers API OpenAI-compat existantes.

Desktop → Ollama Runtime → GPU/CPU local → Réponse

Chargement modèle

from transformers import AutoTokenizer, AutoModelForCausalLM
tok = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct")
mdl = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct", device_map="auto")

PEFT/LoRA (extrait)

from peft import LoraConfig, get_peft_model
cfg = LoraConfig(r=64, lora_alpha=16, target_modules=["q_proj","v_proj"])
mdl = get_peft_model(mdl, cfg)

Bonnes pratiques

Versionner adapters & prompts (tags sémantiques).
Évaluations in-domain + red-team avant partage public.
Spaces pour démos reproductibles (manifest).

Hub ←→ (poids, adapters, datasets, cards) ←→ CI (tests, metrics, red-team)

REST (FastAPI – SSE)

@app.post("/v1/chat/completions")
async def chat(req: ChatReq):
    async with sse_response() as stream:
        async for tok in llm.stream(req):
            await stream.send({"delta": tok})
    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; }

Sécurité & quotas

Auth Bearer, CORS restrictif, size limits.
Rate limit par clé & org, quotas tokens & req/jour.
Journalisation anonymisée (PII masquée).

Métriques (Prometheus)

llm_latency_seconds_bucket{model="mistral",le="0.5"} 42
llm_tokens_total{type="out"} 123456
llm_cost_per_1k_tok{env="prod"} 0.0042

Anti-patterns

Endpoints sans streaming → p95↑.
Pas de max_new_tokens → coûts imprévisibles.
Logs bruts contenant des PII.

Gateway → Router → Runtimes (vLLM/SGLang) → Observability → Storage

Déclaration (JSON)

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

Cycle d’appel

LLM propose tool_call + args JSON.
Orchestrateur exécute en sandbox (allow-list, quotas, timeouts).
Résultat renvoyé comme message tool → réponse finale.

Bonnes pratiques

Valider JSON Schema côté serveur (Pydantic).
Tracer inputs/outputs hashés, erreurs & retries.
Isoler secrets via variables d’environnement (jamais dans prompts).

Exécution (pseudo)

if tool_call and tool_call.name in ALLOW:
  res = run_in_sandbox(tool_call.name, tool_call.args, timeout=3)
  messages += [{"role":"tool","name":tool_call.name,"content":serialize(res)}]
  return llm(messages, stop=["\nEND_JSON"])

Anti-patterns

Outils non idempotents sans garde-fous.
Accès réseau brut non restreint.
Absence de registres d’audit par outil.

Tip : séparer policies (YAML) des prompts — facilite l’audit et le durcissement sans retoucher le modèle.

Mistral – 🧰 Outils & Intégrations

vLLM

SGLang

Ollama

Hugging Face

API (REST/gRPC)

Tool Calling