Recettes pour les LLM locaux

Recette 1 : Assistant de codage personnel (8 Go de VRAM requis, minimum 10)

Hardware: 8 GB VRAM GPU (RTX 3060, 4060, or similar) Use case: Code completion and chat inside your editor Backend: Ollama + Continue or Cline

Install Ollama and pull a 7B coder model

# Install Ollama (Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Pull a coding-optimized 7B model
ollama pull qwen2.5-coder:7b

Vérifiez que le modèle répond correctement

curl http://127.0.0.1:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-coder:7b",
    "messages": [{"role": "user", "content": "Write a Python hello world"}],
    "max_tokens": 100
  }'

Installez le connecteur Tokios et enregistrez un déploiement

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Dans dashboard, créez un déploiement nommé my-coder en le reliant à l’ID de modèle amont qwen2.5-coder:7b. Générez ensuite une clé API.

Configurez enfin Continue ou Cline.

{
  "baseURL": "https://api.tokios.com/v1",
  "apiKey": "sk-tok-YOUR_KEY",
  "model": "my-coder"
}

Performance attendue : environ 40 jetons par seconde sur une carte RTX 4060. Complétion de texte rapide et édition en temps réel avec un contexte de 4K.

Recette 2 : serveur de chatbot familial (16 Go de mémoire vidéo, 15 minutes minimum).

Hardware: 16 GB VRAM GPU (RTX 4080, 4070 Ti Super, or similar) Use case: Self-hosted ChatGPT-style interface for household use Backend: Ollama + Open WebUI + Tokios

Lancez un modèle de conversation 14B via Ollama.

ollama pull qwen2.5:14b

Exécutez Open WebUI en utilisant Docker.

docker run -d \
  --name open-webui \
  -p 3000:8080 \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  -v open-webui:/app/backend/data \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Ouvrez http://localhost:3000 puis créez un compte administrateur.

Rendez le service accessible à distance grâce à Tokios.

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Enregistrez un déploiement nommé family-chat en le pointant vers qwen2.5:14b. Générez une clé API pour chaque membre de la famille ; ces clés limitées permettent de révoquer l’accès individuellement.

Performance attendue : environ 25 jetons par seconde sur une carte RTX 4080 avec un contexte de 8K. Idéal pour des échanges dialogués multiples.

Créez une clé API distincte pour chaque membre de la famille afin de pouvoir en désactiver une sans impacter les autres.

Recette 3 : point de terminaison API destiné à une équipe (48 Go de mémoire vidéo minimum, 30 minutes minimum).

Matériel : 48 Go ou plus de VRAM (A6000, 2x RTX 4090 ou A100) Cas d’utilisation : Point de terminaison de modèle partagé pour une équipe de développement Backend : vLLM et Tokios

Installez vLLM puis lancez un ID de modèle amont 70B.

pip install vllm

vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization awq \
  --gpu-memory-utilization 0.90 \
  --max-model-len 8192

vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization awq \
  --tensor-parallel-size 2 \
  --gpu-memory-utilization 0.90 \
  --max-model-len 8192

Vérifiez que le serveur répond correctement.

curl http://127.0.0.1:8000/v1/models

Installez le connecteur Tokios.

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Configurez le connecteur afin qu’il pointe vers l’ID de modèle amont http://127.0.0.1:8000/v1.

Effectuez le déploiement et créez des clés API à portée restreinte.

Enregistrez un déploiement portant le nom team-70b. Dans l’onglet Keys, créez une clé API 1 pour chaque membre de l’équipe. Définissez le périmètre d’utilisation de chaque clé selon le motif team-* afin que les collègues ne puissent accéder qu’aux déploiements partagés.

Performance attendue : environ 30 tokens par seconde en débit global grâce à la quantification AWQ. Le système gère entre 3 et 5 requêtes simultanées avec une latence acceptable.

Avec 2 GPU, le parallélisme tensoriel offre un débit de décodage supérieur au parallélisme en pipeline sur un même nœud. Consultez Parallélisme tensoriel vs pipeline.

Recette 4 : mise en place d’un pipeline de questions-réponses à partir de documents (besoin de 24 Go de mémoire vidéo, durée estimée : 45 minutes).

Hardware: 24 GB VRAM GPU (RTX 3090, 4090, or similar) Use case: Ask questions about your PDFs and documents without sending them to the cloud Backend: Ollama (embedding + chat) + custom RAG script + Tokios

Pull an embedding model and a 32B chat model

ollama pull nomic-embed-text
ollama pull qwen2.5:32b

Le modèle d’intégration (~270 mégaoctets) génère des représentations vectorielles de vos documents. Le modèle 32B répond ensuite aux questions en se basant sur ces représentations.

Construisez un pipeline RAG simple

import requests, json

EMBED_MODEL = "nomic-embed-text"
CHAT_MODEL  = "qwen2.5:32b"
OLLAMA_URL  = "http://127.0.0.1:11434"

def embed(text: str) -> list[float]:
    r = requests.post(f"{OLLAMA_URL}/api/embeddings",
                       json={"model": EMBED_MODEL, "prompt": text})
    return r.json()["embedding"]

def ask(question: str, context: str) -> str:
    prompt = f"Answer based on this context:\n\n{context}\n\nQuestion: {question}"
    r = requests.post(f"{OLLAMA_URL}/v1/chat/completions",
                       json={"model": CHAT_MODEL,
                             "messages": [{"role": "user", "content": prompt}],
                             "max_tokens": 512})
    return r.json()["choices"][0]["message"]["content"]

Exposez le modèle de chat via Tokios

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Enregistrez un déploiement nommé doc-qa qui pointe vers qwen2.5:32b. Désormais, votre script RAG peut interroger le modèle via https://api.tokios.com/v1 depuis n’importe quelle machine, tandis que les embeddings restent stockés localement.

Performance attendue : environ 15 tokens par seconde pour le modèle 32B sur une carte RTX 4090. La génération des embeddings se fait quasi instantanément pour de courts passages.

Conservez le modèle d’embedding en local (il est rapide et de petite taille) et acheminez uniquement le modèle de chat via Tokios. Cela empêche l’envoi du texte des documents sur le réseau pour créer des embeddings.

Recette 5 : débit maximal sur DGX Spark (128 Go, 20 minutes)

Matériel : NVIDIA DGX Spark (128 Go de mémoire unifiée) Cas d’usage : atteindre le débit maximal avec de grands modèles MoE Backend : vLLM et Tokios

Lancez un modèle MoE 120B en précision FP8

vllm serve Qwen/Qwen3-235B-A22B-FP8 \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization fp8 \
  --gpu-memory-utilization 0.85 \
  --max-model-len 16384 \
  --trust-remote-code

La mémoire unifiée de 128 Go du DGX Spark convient aux modèles nécessitant 2 à 3 cartes graphiques grand public. Les modèles MoE tels que Qwen3-235B-A22B n’activent qu’environ 22B paramètres par token, ce qui garantit une inférence rapide malgré un nombre total de paramètres élevé.

Effectuez des vérifications et des tests de performance

curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-235B-A22B-FP8",
    "messages": [{"role": "user", "content": "Explain quantum entanglement"}],
    "max_tokens": 256
  }'

Exposez le modèle via Tokios

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Enregistrez un déploiement nommé spark-moe. Créez ensuite des clés API pour chaque client requérant un accès.

Performance attendue : environ 35 jetons par seconde sur DGX Spark avec l’ensemble de paramètres actuel. Le contexte de 16K unités tient aisément dans la mémoire unifiée.

Consultez vLLM sur DGX Spark ainsi que le réglage de la mémoire sur DGX Spark pour connaître les options de configuration détaillées.

Recette 6 : solution IA hors ligne adaptée aux ordinateurs portables (16 Go de RAM requis, durée minimale d’exécution : 5 minutes).

Matériel : tout ordinateur portable doté de 16 Go de RAM (aucune carte graphique dédiée n’est nécessaire). Cas d’utilisation : assistant IA privé fonctionnant sans connexion Internet. Backend : Ollama en mode processeur.

Installez Ollama puis téléchargez un modèle 7B quantifié.

# macOS
curl -fsSL https://ollama.com/install.sh | sh

# Or download from https://ollama.com for Windows/Linux
ollama pull qwen2.5:7b-instruct-q4_K_M

La quantification Q4_K_M maintient la taille du modèle sous la barre des 5 Go, ce qui permet son exécution sur processeur avec seulement 16 Go de RAM.

Discutez en local : aucune connexion Internet n’est requise.

ollama run qwen2.5:7b-instruct-q4_K_M

C’est tout. Le modèle s’exécute intégralement sur votre ordinateur portable. Pas d’appels réseau, pas de télémétrie, pas de clé API.

Optionnellement, exposez-le via Tokios lorsque vous disposez d’une connexion Internet.

Lorsque vous êtes en ligne et souhaitez accéder au modèle depuis un autre appareil :

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Enregistrez un déploiement portant le nom laptop-offline. Le connecteur ne se connecte qu’en présence d’un réseau ; hors ligne, le modèle continue de fonctionner localement.

Performance attendue : environ 5 jetons par seconde sur processeur (sur un ordinateur portable moderne). Cette vitesse convient pour les échanges de conversation et la rédaction, mais pas pour un accompagnement en codage en temps réel.

Si votre ordinateur portable dispose d’un processeur Apple Silicon, Ollama utilise automatiquement le Neural Engine et Metal ; on observe alors une vitesse de traitement de 20 à 30 jetons par seconde sur les puces de la série M.

Recette 7 : Routage multi-modèles (plus de 24 Go de VRAM requis, durée minimale de 30 minutes)

Hardware: 24 GB+ VRAM GPU Use case: Serve 3 models of different sizes through 1 Tokios endpoint Backend: Ollama or vLLM + Tokios with config file

Téléchargez les modèles 3 de tailles variées

ollama pull qwen2.5:3b     # fast-small: quick classification
ollama pull qwen2.5:14b    # medium: general chat
ollama pull qwen2.5:32b    # large: complex reasoning

Créez une configuration de connecteur multi-routage

Créez tokios-connector.json :

{
  "Routes": [
    { "Deployment": "fast-small", "Upstream": "local-ollama" },
    { "Deployment": "medium",     "Upstream": "local-ollama" },
    { "Deployment": "large",      "Upstream": "local-ollama" }
  ],
  "Upstreams": {
    "local-ollama": {
      "BaseUrl": "http://127.0.0.1:11434/v1"
    }
  }
}

Enregistrez tous les déploiements 3 dans le tableau de bord

Dans l’onglet Models, procédez à l’enregistrement suivant :

Nom du déploiement	ID de modèle amont
`fast-small`	`qwen2.5:3b`
`medium`	`qwen2.5:14b`
`large`	`qwen2.5:32b`

Effectuez le routage en indiquant le champ modèle

from openai import OpenAI

client = OpenAI(
    base_url="https://api.tokios.com/v1",
    api_key="sk-tok-YOUR_KEY",
)

# Fast classification
client.chat.completions.create(
    model="fast-small",
    messages=[{"role": "user", "content": "Is this email spam? ..."}],
)

# Complex reasoning
client.chat.completions.create(
    model="large",
    messages=[{"role": "user", "content": "Analyze this contract clause..."}],
)

Performance attendue : Le modèle 3B répond en moins de 1 seconde. Le modèle 32B met quant à lui entre 2 et 3 secondes pour générer le premier jeton, mais produit un résultat de meilleure qualité. Il suffit d’utiliser le même point de terminaison, la même clé API et de modifier le champ model.

Par défaut, Ollama conserve uniquement 1 modèle en mémoire VRAM à la fois et effectue des échanges sur demande. Si vous souhaitez charger tous les 3 modèles simultanément, lancez plusieurs backends ou utilisez vLLM avec des adaptateurs LoRA. Consultez Le routage des modèles.

Recette 8 : Évaluer les performances de votre configuration (sur tout type de matériel, minimum 10).

Matériel : Toute carte graphique ou processeur capable d’exécuter un modèle local. Cas d’usage : Comparer le débit et la latence entre différents modèles, niveaux de quantification ou types de matériel. Backend : Tout backend compatible + Tokios.

Démarrez votre serveur de modèles.

Utilisez n’importe quel backend — Ollama, vLLM, llama.cpp ou LM Studio. Vérifiez qu’il répond bien sur son endpoint /v1.

Lancez un test de débit.

# Simple throughput test with curl and timing
for i in 1 2 3 4 5; do
  time curl -s http://127.0.0.1:11434/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
      "model": "qwen2.5:7b",
      "messages": [{"role": "user", "content": "Write a 200-word essay about recursion"}],
      "max_tokens": 256,
      "stream": false
    }' | python3 -c "
import sys, json
r = json.load(sys.stdin)
u = r['usage']
print(f\"Tokens: {u['completion_tokens']}, Time: check wall clock\")
"
done

Effectuez le test via Tokios afin de mesurer la latence globale.

# Same test through the Tokios endpoint
time curl -s https://api.tokios.com/v1/chat/completions \
  -H "Authorization: Bearer sk-tok-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "my-deployment",
    "messages": [{"role": "user", "content": "Write a 200-word essay about recursion"}],
    "max_tokens": 256,
    "stream": false
  }' | python3 -c "
import sys, json
r = json.load(sys.stdin)
u = r['usage']
print(f\"Tokens: {u['completion_tokens']}\")
"

Comparez les différents niveaux de quantification.

Téléchargez le même modèle avec divers niveaux de quantification puis testez chacun d’eux.

ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:7b-instruct-q5_K_M
ollama pull qwen2.5:7b-instruct-q8_0

Envoyez le même prompt à chaque version et comparez le nombre de tokens générés par seconde. Le format Q5_K_M offre généralement le meilleur compromis qualité/vitesse à 7B.

Résultats attendus : Le tunnel ajoute entre 50 et 150 millisecondes de latence par requête (soit 1 pour un aller-retour vers le gateway Tokios). Le débit en mode streaming reste quasi identique à celui obtenu en local, car le tunnel ne met pas en cache les flux SSE.

Pour un test plus structuré, consultez Évaluer votre déploiement.

Études de cas

Exemples concrets de déploiement fournis par des équipes et des particuliers utilisant des modèles locaux.

Sélection d’un modèle local

Choisissez le modèle ainsi que le niveau de quantification adaptés à votre matériel et à votre flux de travail.

Routage des modèles

Enregistrez plusieurs déploiements et alternez entre les modèles en modifiant simplement le champ ID de modèle amont.

Démarrage rapide

Mettez en place en un rien de temps un connecteur fonctionnel, un déploiement et une clé API.

Premiers pas

Modèles

Concepts

Référence

Recettes pour les LLM locaux

Prochaines étapes

Études de cas

Sélection d’un modèle local

Routage des modèles

Démarrage rapide

​Prochaines étapes

Études de cas

Sélection d’un modèle local

Routage des modèles

Démarrage rapide

Prochaines étapes