> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/comparaisons/llm-serving-comparison.md).

# Mise en service des LLM : Ollama vs vLLM vs TGI

Comparez vLLM, SGLang, Ollama, TGI et LocalAI pour la mise en service des LLM

Choisissez la solution de service LLM adaptée à vos besoins sur CLORE.AI.

{% hint style="success" %}
Toutes les options disponibles sur [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**Mise à jour 2025 :** SGLang s’est imposé comme un framework de premier plan, souvent **surpassant vLLM** en débit et en TTFT dans les benchmarks. vLLM v0.7 et SGLang v0.4 sont tous deux recommandés pour les charges de production.
{% endhint %}

## Guide de décision rapide

{% hint style="warning" %}
**Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

| Cas d’utilisation                     | Meilleur choix         | Pourquoi                                               |
| ------------------------------------- | ---------------------- | ------------------------------------------------------ |
| Tests rapides et chat                 | **Ollama**             | Configuration la plus simple, démarrage le plus rapide |
| API de production (débit maximal)     | **SGLang** ou **vLLM** | Le débit le plus élevé en 2025                         |
| Modèles de raisonnement (DeepSeek-R1) | **SGLang**             | Meilleur support pour les chaînes de raisonnement      |
| Intégration HuggingFace               | **TGI**                | Prise en charge native de HF                           |
| Développement local                   | **Ollama**             | Fonctionne partout                                     |
| Forte concurrence                     | **SGLang** ou **vLLM** | Lotissement continu                                    |
| Multi-modal (TTS, STT, embeddings)    | **LocalAI**            | Solution tout-en-un                                    |
| Applications en streaming             | **vLLM** ou **SGLang** | Les deux sont excellents                               |

## Comparaison des temps de démarrage

| Solution | Démarrage typique | Remarques                      |
| -------- | ----------------- | ------------------------------ |
| Ollama   | 30 à 60 secondes  | Le plus rapide, léger          |
| SGLang   | 3 à 8 minutes     | Télécharge le modèle depuis HF |
| vLLM     | 5 à 15 minutes    | Télécharge le modèle depuis HF |
| TGI      | 3 à 10 minutes    | Télécharge le modèle depuis HF |
| LocalAI  | 5 à 10 minutes    | Précharge plusieurs modèles    |

{% hint style="info" %}
Les erreurs HTTP 502 pendant le démarrage sont normales - le service est encore en cours d’initialisation.
{% endhint %}

***

## Comparaison générale

| Fonctionnalité                  | Ollama                | vLLM              | SGLang                    | TGI                   | LocalAI               |
| ------------------------------- | --------------------- | ----------------- | ------------------------- | --------------------- | --------------------- |
| **Facilité de configuration**   | ⭐⭐⭐⭐⭐                 | ⭐⭐⭐               | ⭐⭐⭐                       | ⭐⭐⭐                   | ⭐⭐⭐⭐                  |
| **Performances**                | ⭐⭐⭐                   | ⭐⭐⭐⭐⭐             | ⭐⭐⭐⭐⭐                     | ⭐⭐⭐⭐                  | ⭐⭐⭐                   |
| **Prise en charge des modèles** | ⭐⭐⭐⭐                  | ⭐⭐⭐⭐⭐             | ⭐⭐⭐⭐⭐                     | ⭐⭐⭐⭐                  | ⭐⭐⭐⭐                  |
| **Compatibilité API**           | Personnalisé + OpenAI | OpenAI            | OpenAI                    | Personnalisé + OpenAI | OpenAI                |
| **Multi-GPU**                   | Limité                | Excellente        | Excellente                | Bon                   | Limité                |
| **Efficacité mémoire**          | Bon                   | Excellente        | Excellente                | Très bonne            | Bon                   |
| **Multi-modal**                 | Vision uniquement     | Vision uniquement | Vision uniquement         | Non                   | TTS, STT, intégration |
| **Temps de démarrage**          | 30 s                  | 5 à 15 min        | 3 à 8 min                 | 3 à 10 min            | 5 à 10 min            |
| **Modèles de raisonnement**     | Limité                | Bon               | Excellente                | Bon                   | Limité                |
| **Idéal pour**                  | Développement         | Production        | Production + Raisonnement | Écosystème HF         | Multi-modal           |

***

## Benchmarks 2025 : DeepSeek-R1-32B

### TTFT, TPOT et débit (A100 80 Go, batch=32, entrée=512, sortie=512)

| Framework       | TTFT (ms) | TPOT (ms/tok) | Débit (tok/s) | Remarques                            |
| --------------- | --------- | ------------- | ------------- | ------------------------------------ |
| **SGLang v0.4** | **180**   | **14**        | **2,850**     | Meilleur global en 2025              |
| **vLLM v0.7**   | 240       | 17            | 2,400         | Excellent, proche de SGLang          |
| llama.cpp       | 420       | 28            | 1,100         | CPU+GPU, quantifié                   |
| Ollama          | 510       | 35            | 820           | Priorité à la facilité d’utilisation |

> **TTFT** = Temps jusqu’au premier token (latence). **TPOT** = Temps par token de sortie. Plus bas est meilleur pour les deux.

### Comparaison du débit (RTX 4090, Llama 3.1 8B, 10 utilisateurs concurrents)

| Framework   | Jetons/s | Utilisateurs concurrents | Remarques                       |
| ----------- | -------- | ------------------------ | ------------------------------- |
| SGLang v0.4 | 920      | 20-30                    | Mise en cache d’attention Radix |
| vLLM v0.7   | 870      | 20-30                    | PagedAttention                  |
| TGI         | 550      | 10-20                    |                                 |
| Ollama      | 160\*    | —                        | Séquentiel par défaut           |

\*Ollama traite les requêtes séquentiellement par défaut

***

## SGLang

### Aperçu

SGLang (Structured Generation Language) est un framework de service LLM à haut débit développé par des chercheurs de l’UC Berkeley et de LMSYS. Dans les benchmarks 2025, il égale souvent ou dépasse vLLM — surtout pour les modèles de raisonnement comme DeepSeek-R1.

### Avantages

* ✅ Souvent le meilleur en TTFT et en débit dans les benchmarks 2025
* ✅ Attention Radix pour une réutilisation efficace du KV-cache
* ✅ Excellent support des modèles de raisonnement (DeepSeek-R1, QwQ)
* ✅ API compatible OpenAI
* ✅ Lotissement continu et cache de préfixe
* ✅ Prise en charge du décodage spéculatif
* ✅ Parallélisme tensoriel multi-GPU

### Inconvénients

* ❌ Écosystème plus récent, moins de ressources communautaires que vLLM
* ❌ Configuration plus complexe qu’Ollama
* ❌ Linux uniquement

### Démarrage rapide

```bash
pip install sglang[all]

# Servir un modèle
python -m sglang.launch_server \\
    --model-path meta-llama/Llama-3.1-8B-Instruct \\
    --host 0.0.0.0 \
    --port 8000
```

### DeepSeek-R1 avec SGLang

```bash
python -m sglang.launch_server \\
    --model-path deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \\
    --host 0.0.0.0 \
    --port 8000 \\
    --tp 2 \
    --reasoning-parser deepseek-r1
```

### Utilisation de l’API

```python
from openai import OpenAI

client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')

response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'user', 'content': 'Explique l’intrication quantique'}
    ],
    temperature=0.7,
    max_tokens=512
)
print(response.choices[0].message.content)
```

### Multi-GPU

```bash
# 2 GPU (parallélisme tensoriel)
python -m sglang.launch_server \\
    --model-path meta-llama/Llama-3.1-70B-Instruct \\
    --host 0.0.0.0 \
    --port 8000 \\
    --tp 2
```

### Idéal pour

* 🎯 API de production avec un large support communautaire
* 🎯 Modèles de raisonnement (DeepSeek-R1, QwQ, style o1)
* 🎯 Applications à faible latence (TTFT)
* 🎯 Charges de travail riches en préfixes (forte réutilisation du KV-cache)

***

## Ollama

### Aperçu

Ollama est la façon la plus simple d’exécuter des LLM localement. Parfait pour le développement, les tests et l’usage personnel.

### Avantages

* ✅ Installation et exécution en une seule commande
* ✅ Bibliothèque de modèles intégrée
* ✅ Excellente expérience CLI
* ✅ Fonctionne sur Mac, Linux, Windows
* ✅ Quantification automatique
* ✅ Faible consommation de ressources

### Inconvénients

* ❌ Débit inférieur aux alternatives
* ❌ Prise en charge limitée du multi-GPU
* ❌ Moins prêt pour la production
* ❌ Moins d’options d’optimisation

### Démarrage rapide

```bash
# Installation
curl -fsSL https://ollama.com/install.sh | sh

# Exécuter n’importe quel modèle
ollama run llama3.2
ollama run mistral
ollama run codellama

# Servir l’API
ollama serve
```

### Utilisation de l’API

```python
import requests

# Générer
response = requests.post('http://localhost:11434/api/generate', json={
    'model': 'llama3.2',
    'prompt': 'Explique l’informatique quantique',
    'stream': False
})
print(response.json()['response'])

# Chat
response = requests.post('http://localhost:11434/api/chat', json={
    'model': 'llama3.2',
    'messages': [
        {'role': 'user', 'content': 'Bonjour !'}
    ]
})
```

### Compatibilité OpenAI

```python
from openai import OpenAI

client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')

response = client.chat.completions.create(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Bonjour !'}]
)
```

### Performances

| Modèle        | GPU        | Jetons/s |
| ------------- | ---------- | -------- |
| Llama 3.2 3B  | RTX 3060   | 45-55    |
| Llama 3.1 8B  | RTX 3090   | 35-45    |
| Llama 3.1 70B | A100 40 Go | 15-20    |

### Idéal pour

* 🎯 Prototypage rapide
* 🎯 Assistant IA personnel
* 🎯 Apprentissage et expérimentation
* 🎯 Déploiements simples

***

## vLLM

### Aperçu

vLLM est un moteur d’inférence LLM à haut débit, éprouvé en production. La v0.7 (2025) apporte de meilleures performances, une meilleure prise en charge de la quantification et de nouvelles options de décodage spéculatif.

### Avantages

* ✅ Débit le plus élevé (lotissement continu + PagedAttention)
* ✅ PagedAttention pour une gestion efficace de la mémoire
* ✅ Excellente prise en charge multi-GPU
* ✅ API compatible OpenAI
* ✅ Prêt pour la production, grande communauté
* ✅ Prend en charge de nombreux formats de quantification (AWQ, GPTQ, FP8)
* ✅ Décodage spéculatif dans la v0.7

### Inconvénients

* ❌ Configuration plus complexe
* ❌ Plus grande consommation mémoire au démarrage
* ❌ Linux uniquement (pas de support natif Windows/Mac)
* ❌ Nécessite davantage de configuration

### Démarrage rapide

```bash
pip install vllm

# Servir le modèle (vLLM v0.7)
python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.1-8B-Instruct \\
    --host 0.0.0.0 \
    --port 8000
```

### Déploiement Docker

```bash
docker run --gpus all -p 8000:8000 \
    vllm/vllm-openai:v0.7.0 \\
    --model meta-llama/Llama-3.1-8B-Instruct
```

### Utilisation de l’API

```python
from openai import OpenAI

client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')

# Complétion de chat
response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'system', 'content': 'Vous êtes utile.'},
        {'role': 'user', 'content': 'Écris un haïku sur le codage'}
    ],
    temperature=0.7,
    max_tokens=100
)

# Diffusion en continu
stream = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[{'role': 'user', 'content': 'Raconte-moi une histoire'}],
    stream=True
)
for chunk in stream:
    print(chunk.choices[0].delta.content, end='')
```

### Multi-GPU

```bash
# 2 GPU
python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.1-70B-Instruct \\
    --tensor-parallel-size 2

# 4 GPU
python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.1-70B-Instruct \\
    --tensor-parallel-size 4
```

### Performances

| Modèle        | GPU        | Jetons/s | Utilisateurs concurrents |
| ------------- | ---------- | -------- | ------------------------ |
| Llama 3.1 8B  | RTX 3090   | 80-100   | 10-20                    |
| Llama 3.1 8B  | RTX 4090   | 120-150  | 20-30                    |
| Llama 3.1 70B | A100 40 Go | 25-35    | 5-10                     |
| Llama 3.1 70B | 2x A100    | 50-70    | 15-25                    |

### Idéal pour

* 🎯 API de production avec une grande communauté
* 🎯 Applications à fort trafic
* 🎯 Services de chat multi-utilisateurs
* 🎯 Besoin de débit maximal

***

## Text Generation Inference (TGI)

### Aperçu

Le serveur de production de HuggingFace, étroitement intégré à l’écosystème HF.

### Avantages

* ✅ Intégration native HuggingFace
* ✅ Idéal pour les modèles HF
* ✅ Bonne prise en charge multi-GPU
* ✅ Fonctions de sécurité intégrées
* ✅ Métriques Prometheus
* ✅ Bien documenté

### Inconvénients

* ❌ Débit légèrement inférieur à vLLM/SGLang
* ❌ Plus gourmand en ressources
* ❌ Configuration complexe
* ❌ Temps de démarrage plus longs

### Démarrage rapide

```bash
# Docker (recommandé)
docker run --gpus all -p 8080:80 \\
    ghcr.io/huggingface/text-generation-inference:latest \\
    --model-id meta-llama/Llama-3.1-8B-Instruct

# Avec un jeton HF pour les modèles soumis à accès restreint
docker run --gpus all -p 8080:80 \\
    -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \\
    ghcr.io/huggingface/text-generation-inference:latest \\
    --model-id meta-llama/Llama-3.1-8B-Instruct
```

### Performances

| Modèle        | GPU        | Jetons/s | Utilisateurs concurrents |
| ------------- | ---------- | -------- | ------------------------ |
| Llama 3.1 8B  | RTX 3090   | 60-80    | 8-15                     |
| Llama 3.1 8B  | RTX 4090   | 90-120   | 15-25                    |
| Llama 3.1 70B | A100 40 Go | 20-30    | 3-8                      |

### Idéal pour

* 🎯 Utilisateurs de modèles HuggingFace
* 🎯 Environnements de recherche
* 🎯 Besoin de fonctions de sécurité intégrées
* 🎯 Besoins de supervision Prometheus

***

## LocalAI

### Aperçu

LocalAI est une API compatible OpenAI qui prend en charge plusieurs modalités : LLM, TTS, STT, embeddings et génération d’images.

### Avantages

* ✅ Prise en charge multi-modale (LLM, TTS, STT, embeddings)
* ✅ Remplacement OpenAI prêt à l’emploi
* ✅ Modèles préconstruits disponibles
* ✅ Prend en charge les modèles GGUF
* ✅ Prise en charge du reranking
* ✅ Documentation Swagger UI

### Inconvénients

* ❌ Temps de démarrage plus long (5 à 10 minutes)
* ❌ Débit LLM inférieur à vLLM/SGLang
* ❌ La génération d’images peut rencontrer des problèmes CUDA
* ❌ Plus complexe pour un usage LLM pur

### Démarrage rapide

```bash
docker run --gpus all -p 8080:8080 localai/localai:master-aio-gpu-nvidia-cuda-12
```

### Utilisation de l’API

```python
from openai import OpenAI

client = OpenAI(base_url='http://localhost:8080/v1', api_key='dummy')

# Chat
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': 'Bonjour !'}]
)

# TTS
audio = client.audio.speech.create(model='tts-1', input='Bonjour le monde', voice='alloy')

# STT
transcript = client.audio.transcriptions.create(model='whisper-1', file=open('audio.mp3', 'rb'))

# Embeddings
embeddings = client.embeddings.create(model='text-embedding-ada-002', input='Bonjour le monde')
```

### Idéal pour

* 🎯 Besoin de plusieurs modalités (TTS, STT, LLM)
* 🎯 Voulez-vous la compatibilité avec l’API OpenAI
* 🎯 Exécution de modèles GGUF
* 🎯 Flux de travail de reranking de documents

***

## Comparaison des performances (2025)

### Débit (tokens/seconde) — utilisateur unique

| Modèle                     | Ollama | vLLM v0.7 | SGLang v0.4 | TGI |
| -------------------------- | ------ | --------- | ----------- | --- |
| Llama 3.1 8B (RTX 3090)    | 40     | 90        | 100         | 70  |
| Llama 3.1 8B (RTX 4090)    | 65     | 140       | 160         | 110 |
| Llama 3.1 70B (A100 40 Go) | 18     | 30        | 35          | 25  |

### Débit — plusieurs utilisateurs (10 en parallèle)

| Modèle                     | Ollama | vLLM v0.7 | SGLang v0.4 | TGI |
| -------------------------- | ------ | --------- | ----------- | --- |
| Llama 3.1 8B (RTX 4090)    | 150\*  | 800       | 920         | 500 |
| Llama 3.1 70B (A100 40 Go) | 50\*   | 200       | 240         | 150 |

\*Ollama traite les requêtes de manière séquentielle par défaut

### Utilisation mémoire

| Modèle             | Ollama | vLLM v0.7 | SGLang v0.4 | TGI   |
| ------------------ | ------ | --------- | ----------- | ----- |
| Llama 3.1 8B       | 5 Go   | 6 Go      | 6 Go        | 7 Go  |
| Llama 3.1 70B (Q4) | 38 Go  | 40 Go     | 39 Go       | 42 Go |

### Temps jusqu’au premier token (TTFT) — DeepSeek-R1-32B

| Framework   | TTFT (A100 80 Go) | TPOT (ms/tok) |
| ----------- | ----------------- | ------------- |
| SGLang v0.4 | **180 ms**        | **14 ms**     |
| vLLM v0.7   | 240 ms            | 17 ms         |
| llama.cpp   | 420 ms            | 28 ms         |
| Ollama      | 510 ms            | 35 ms         |

***

## Comparaison des fonctionnalités

| Fonctionnalité          | Ollama  | vLLM v0.7      | SGLang v0.4    | TGI               | LocalAI    |
| ----------------------- | ------- | -------------- | -------------- | ----------------- | ---------- |
| API OpenAI              | ✅       | ✅              | ✅              | ✅                 | ✅          |
| Flux continu            | ✅       | ✅              | ✅              | ✅                 | ✅          |
| Lotissement             | Basique | Continu        | Continu        | Dynamique         | Basique    |
| Multi-GPU               | Limité  | Excellente     | Excellente     | Bon               | Limité     |
| Quantification          | GGUF    | AWQ, GPTQ, FP8 | AWQ, GPTQ, FP8 | bitsandbytes, AWQ | GGUF       |
| LoRA                    | ✅       | ✅              | ✅              | ✅                 | ✅          |
| Décodage spéculatif     | ❌       | ✅              | ✅              | ✅                 | ❌          |
| Cache de préfixe        | ❌       | ✅              | ✅ (Radix)      | ✅                 | ❌          |
| Modèles de raisonnement | Limité  | Bon            | Excellente     | Bon               | Limité     |
| Métriques               | Basique | Prometheus     | Prometheus     | Prometheus        | Prometheus |
| Appel de fonction       | ✅       | ✅              | ✅              | ✅                 | ✅          |
| Modèles de vision       | ✅       | ✅              | ✅              | ✅                 | Limité     |
| TTS                     | ❌       | ❌              | ❌              | ❌                 | ✅          |
| STT                     | ❌       | ❌              | ❌              | ❌                 | ✅          |
| Embeddings              | ✅       | Limité         | Limité         | Limité            | ✅          |

***

## Quand utiliser quoi

### Utiliser Ollama quand :

* Vous voulez commencer en 5 minutes
* Vous faites du prototypage ou de l’apprentissage
* Vous avez besoin d’un assistant IA personnel
* Vous êtes sur Mac ou Windows
* La simplicité compte plus que la vitesse

### Utiliser SGLang quand :

* Vous avez besoin de la **latence absolue la plus faible** (TTFT)
* Vous servez des **modèles de raisonnement** (DeepSeek-R1, QwQ, style o1)
* Vous avez des charges de travail avec un fort **partage de préfixe** (RAG, prompts système)
* Vous avez besoin d’un débit de premier plan dans les benchmarks 2025
* Vous voulez des optimisations de pointe (attention Radix)

### Utiliser vLLM quand :

* Vous avez besoin du débit maximal avec un **framework mature, bien pris en charge** framework
* Vous servez de nombreux utilisateurs à grande échelle
* Vous avez besoin d’une fiabilité de production avec une grande communauté
* Vous voulez un remplacement direct d’OpenAI
* Vous avez des configurations multi-GPU
* Vous avez besoin d’une large prise en charge des formats de modèles (AWQ, GPTQ, FP8)

### Utiliser TGI quand :

* Vous êtes dans l’écosystème HuggingFace
* Vous avez besoin de fonctions de sécurité intégrées
* Vous voulez des métriques Prometheus détaillées
* Vous devez servir directement des modèles HF
* Vous êtes dans un environnement de recherche

### Utiliser LocalAI quand :

* Vous avez besoin de TTS et STT en plus du LLM
* Vous voulez des embeddings pour le RAG
* Vous avez besoin du reranking de documents
* Vous voulez une solution unique tout-en-un
* Vous créez des applications avec la voix

***

## Guide de migration

### D’Ollama vers SGLang

```python
# Ollama
client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')
response = client.chat.completions.create(model='llama3.2', ...)

# SGLang - changez simplement l’URL et le nom du modèle
client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')
response = client.chat.completions.create(model='meta-llama/Llama-3.2-3B-Instruct', ...)
```

### De vLLM vers SGLang

Les deux prennent en charge l’API OpenAI - changez simplement l’URL du point de terminaison. Les API sont entièrement compatibles.

```bash
# vLLM
python -m vllm.entrypoints.openai.api_server --model ... --port 8000

# SGLang (équivalent)
python -m sglang.launch_server --model-path ... --port 8000
```

***

## Recommandations par GPU

| GPU            | Utilisateur unique | Multi-utilisateur | Modèles de raisonnement |
| -------------- | ------------------ | ----------------- | ----------------------- |
| RTX 3060 12 Go | Ollama             | Ollama            | Ollama                  |
| RTX 3090 24 Go | Ollama             | vLLM              | SGLang                  |
| RTX 4090 24 Go | SGLang/vLLM        | SGLang/vLLM       | SGLang                  |
| A100 40Go+     | SGLang             | SGLang            | SGLang                  |

***

## Étapes suivantes

* [Guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) - Configuration la plus simple
* [Guide vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) - Débit le plus élevé
* [Guide LocalAI](/guides/guides_v2-fr/modeles-de-langage/localai-openai-compatible.md) - Prise en charge multimodale
* [Guide DeepSeek-R1](/guides/guides_v2-fr/modeles-de-langage/deepseek-r1.md) - Modèles de raisonnement
* [Configuration multi-GPU](/guides/guides_v2-fr/avance/multi-gpu-setup.md) - Passer à des modèles plus grands
* [Intégration API](/guides/guides_v2-fr/avance/api-integration.md) - Créer des applications


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/comparaisons/llm-serving-comparison.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.