> 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/modeles-de-langage/ollama.md).

# Ollama

La manière la plus simple d’exécuter des LLM localement sur les GPU CLORE.AI.

{% hint style="info" %}
**Version actuelle : v0.6+** — Ce guide couvre Ollama v0.6 et versions ultérieures. Les principales nouvelles fonctionnalités incluent les sorties structurées (application d’un schéma JSON), un point de terminaison d’embeddings compatible OpenAI (`/api/embed`), et le chargement concurrent de modèles (exécuter plusieurs modèles simultanément sans permutation). Voir [Nouveautés de la v0.6+](#new-in-v06) pour plus de détails.
{% endhint %}

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Configuration requise du serveur

| Paramètre          | Minimum       | Recommandé |
| ------------------ | ------------- | ---------- |
| RAM                | 8 Go          | 16 Go+     |
| VRAM               | 6 Go          | 8 Go+      |
| Réseau             | 100 Mbps      | 500 Mbps+  |
| Temps de démarrage | \~30 secondes | -          |

{% hint style="info" %}
Ollama est léger et fonctionne sur la plupart des serveurs GPU. Pour les modèles plus grands (13B+), choisissez des serveurs avec 16 Go+ de RAM et 12 Go+ de VRAM.
{% endhint %}

## Pourquoi Ollama ?

* **Installation en une commande** - Pas de Python, pas de dépendances
* **Bibliothèque de modèles** - Téléchargez des modèles avec `ollama pull`
* **API compatible OpenAI** - Remplacement direct
* **Accélération GPU** - Détection automatique de CUDA
* **Multi-modèle** - Exécutez plusieurs modèles simultanément (v0.6+)

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
ollama/ollama
```

**Ports :**

```
22/tcp
11434/http
```

**Commande :**

```bash
ollama serve
```

### Vérifier que cela fonctionne

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes** et testez :

```bash
# Remplacez par votre véritable URL http_pub
curl https://your-http-pub.clorecloud.net/

# Réponse attendue : "Ollama est en cours d’exécution"
```

{% hint style="warning" %}
Si vous obtenez une erreur HTTP 502, attendez 30 à 60 secondes - le service est encore en cours de démarrage.
{% endhint %}

## Accéder à votre service

Lors du déploiement sur CLORE.AI, accédez à votre instance Ollama via l’ `http_pub` URL :

```bash
# Trouvez votre http_pub dans Mes commandes, puis :
curl https://your-http-pub.clorecloud.net/api/tags

# Pour les appels API, utilisez votre URL http_pub :
curl https://your-http-pub.clorecloud.net/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Bonjour !"}],
  "stream": false
}'
```

{% hint style="info" %}
Tous `localhost:11434` les exemples ci-dessous fonctionnent lorsque vous êtes connecté via SSH. Pour l’accès externe, remplacez par votre `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## Installation

### Avec Docker (recommandé)

```bash
docker run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
```

### Installation manuelle

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

Cette seule commande installe la dernière version d’Ollama, configure le service systemd et active automatiquement la détection du GPU. Fonctionne sur Ubuntu, Debian, Fedora et la plupart des distributions Linux modernes.

## Exécution des modèles

### Télécharger et exécuter

```bash
# Télécharger le modèle
ollama pull llama3.2

# Lancer une conversation interactive
ollama run llama3.2

# Exécuter avec une invite
ollama run llama3.2 "Explique l’informatique quantique"
```

### Modèles populaires

| Modèle              | Taille  | Cas d’utilisation              |
| ------------------- | ------- | ------------------------------ |
| `llama3.2`          | 3B      | Rapide, polyvalent             |
| `llama3.1`          | 8B      | Meilleure qualité              |
| `llama3.1:70b`      | 70B     | Meilleure qualité              |
| `mistral`           | 7B      | Rapide, bonne qualité          |
| `mixtral`           | 47B     | MoE, haute qualité             |
| `codellama`         | 7-34B   | Génération de code             |
| `deepseek-coder-v2` | 16B     | Le meilleur pour le code       |
| `deepseek-r1`       | 7B-671B | Modèle de raisonnement         |
| `deepseek-r1:32b`   | 32B     | Raisonnement équilibré         |
| `qwen2.5`           | 7B      | Multilingue                    |
| `qwen2.5:72b`       | 72B     | Meilleure qualité Qwen         |
| `phi4`              | 14B     | Le dernier modèle de Microsoft |
| `gemma2`            | 9B      | Modèle de Google               |

### Variantes de modèles

```bash
# Variantes de quantification
ollama pull llama3.1:8b-instruct-q4_K_M   # 4 bits (plus petit, plus rapide)
ollama pull llama3.1:8b-instruct-q8_0     # 8 bits (meilleure qualité)
ollama pull llama3.1:8b-instruct-fp16     # Précision complète

# Variantes de taille
ollama pull llama3.1:8b    # 8 milliards de paramètres
ollama pull llama3.1:70b   # 70 milliards de paramètres

# Nouveaux modèles (ère v0.6+)
ollama pull deepseek-r1:7b      # Raisonnement, économique
ollama pull deepseek-r1:14b     # Raisonnement, efficace
ollama pull deepseek-r1:32b     # Raisonnement, équilibré
ollama pull deepseek-r1:70b     # Raisonnement, haute qualité
ollama pull qwen2.5:72b         # Plus grand Qwen, qualité maximale
ollama pull phi4                # Microsoft Phi-4 14B
```

## Nouveautés de la v0.6+

Ollama v0.6 a introduit plusieurs fonctionnalités majeures pour les charges de travail de production :

### Sorties structurées (schéma JSON)

Force les réponses du modèle à correspondre à un schéma JSON spécifique. Utile pour créer des applications nécessitant une sortie fiable et analysable :

```bash
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Parle-moi du Canada."}],
  "format": {
    "type": "object",
    "properties": {
      "name": {"type": "string"},
      "capital": {"type": "string"},
      "population": {"type": "integer"},
      "languages": {
        "type": "array",
        "items": {"type": "string"}
      }
    },
    "required": ["name", "capital", "population", "languages"]
  },
  "stream": false
}'
```

Exemple Python avec sorties structurées :

```python
from openai import OpenAI
import json

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

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Liste 3 langages de programmation avec leurs principaux cas d’utilisation"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "languages",
            "schema": {
                "type": "object",
                "properties": {
                    "languages": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "use_case": {"type": "string"},
                                "popularity_rank": {"type": "integer"}
                            }
                        }
                    }
                }
            }
        }
    }
)

data = json.loads(response.choices[0].message.content)
print(data)
```

### Point de terminaison d’embeddings compatible OpenAI (`/api/embed`)

Nouveauté de la v0.6+ : le `/api/embed` point de terminaison est entièrement compatible OpenAI et prend en charge les entrées par lots :

```bash
# Embedding d’un seul texte
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Hello world"
}'

# Embeddings par lot (nouveau en v0.6)
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["Premier document", "Deuxième document", "Troisième document"]
}'
```

Le client OpenAI fonctionne directement avec `/v1/embeddings`:

```python
from openai import OpenAI
import numpy as np

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

# Téléchargez d’abord le modèle d’embedding : ollama pull nomic-embed-text
response = client.embeddings.create(
    model="nomic-embed-text",
    input=["Hello world", "Goodbye world"]
)

emb1 = np.array(response.data[0].embedding)
emb2 = np.array(response.data[1].embedding)

# Similarité cosinus
similarity = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print(f"Similarité : {similarity:.4f}")
```

Modèles d’embedding populaires :

```bash
ollama pull nomic-embed-text      # 137M, rapide, bonne qualité
ollama pull mxbai-embed-large     # 335M, qualité supérieure
ollama pull all-minilm            # 23M, le plus rapide
```

### Chargement concurrent de modèles

Avant la v0.6, Ollama déchargeait un modèle pour en charger un autre. La v0.6+ prend en charge l’exécution simultanée de plusieurs modèles, limitée uniquement par la VRAM disponible :

```bash
# Charger deux modèles en même temps
ollama run llama3.2 &
ollama run deepseek-r1:7b &

# Vérifier ce qui est en cours d’exécution
curl http://localhost:11434/api/ps
```

Configurer la concurrence :

```bash
# Autoriser jusqu’à 4 modèles chargés simultanément
OLLAMA_MAX_LOADED_MODELS=4 ollama serve

# Chaque exécution dans un processus séparé (meilleure isolation)
OLLAMA_NUM_PARALLEL=2 ollama serve
```

C’est particulièrement utile pour :

* Les tests A/B de différents modèles
* Les modèles spécialisés pour différentes tâches (codage + chat)
* Garder en mémoire VRAM les modèles fréquemment utilisés

## Utilisation de l’API

### Complétion de chat

```bash
# Via http_pub (accès externe) :
curl https://your-http-pub.clorecloud.net/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Bonjour !"}],
  "stream": false
}'

# Via tunnel SSH (localhost) :
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Bonjour !"}],
  "stream": false
}'
```

{% hint style="info" %}
Ajoutez `"stream": false` pour obtenir la réponse complète d’un seul coup au lieu d’un flux.
{% endhint %}

### Point de terminaison compatible OpenAI

```python
from openai import OpenAI

# Pour l’accès externe, utilisez votre URL http_pub :
client = OpenAI(
    base_url="https://your-http-pub.clorecloud.net/v1",
    api_key="ollama"  # n’importe quelle chaîne fonctionne
)

# Ou via tunnel SSH :
# client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "user", "content": "Qu’est-ce que l’apprentissage automatique ?"}
    ]
)

print(response.choices[0].message.content)
```

### Flux

```python
stream = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Écris un poème"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")
```

### Embeddings

```bash
# Point de terminaison hérité (fonctionne toujours)
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "Hello world"
}'

# Nouveau point de terminaison v0.6+ (prise en charge par lots, compatible OpenAI)
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["Hello world", "Another text"]
}'
```

### Génération de texte (hors chat)

```bash
curl https://your-http-pub.clorecloud.net/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Le sens de la vie est",
  "stream": false
}'
```

## Référence complète de l’API

Tous les points de terminaison fonctionnent avec à la fois `http://localhost:11434` (via SSH) et `https://your-http-pub.clorecloud.net` (externe).

### Gestion des modèles

| Point de terminaison | Méthode | Description                                          |
| -------------------- | ------- | ---------------------------------------------------- |
| `/api/tags`          | GET     | Lister tous les modèles téléchargés                  |
| `/api/show`          | POST    | Obtenir les détails du modèle                        |
| `/api/pull`          | POST    | Télécharger un modèle                                |
| `/api/delete`        | DELETE  | Supprimer un modèle                                  |
| `/api/ps`            | GET     | Lister les modèles actuellement en cours d’exécution |
| `/api/version`       | GET     | Obtenir la version d’Ollama                          |

#### Lister les modèles

```bash
curl https://your-http-pub.clorecloud.net/api/tags
```

Réponse :

```json
{
  "models": [
    {"name": "llama3.2:latest", "size": 2019393189, "digest": "...", "modified_at": "..."}
  ]
}
```

#### Afficher les détails du modèle

```bash
curl https://your-http-pub.clorecloud.net/api/show -d '{"name": "llama3.2"}'
```

#### Télécharger un modèle via l’API

```bash
curl https://your-http-pub.clorecloud.net/api/pull -d '{
  "name": "mistral:7b",
  "stream": false
}'
```

Réponse :

```json
{"status": "success"}
```

{% hint style="warning" %}
Le téléchargement des grands modèles peut prendre plusieurs minutes. Pour les modèles très volumineux (30 Go+), envisagez d’utiliser SSH et la CLI : `ollama pull model-name`
{% endhint %}

#### Supprimer le modèle

```bash
curl -X DELETE https://your-http-pub.clorecloud.net/api/delete -d '{"name": "mistral:7b"}'
```

#### Lister les modèles en cours d’exécution

```bash
curl https://your-http-pub.clorecloud.net/api/ps
```

Réponse :

```json
{
  "models": [
    {"name": "llama3.2:latest", "size": 2019393189, "expires_at": "2025-01-25T12:00:00Z"}
  ]
}
```

#### Obtenir la version

```bash
curl https://your-http-pub.clorecloud.net/api/version
```

Réponse :

```json
{"version": "0.6.8"}
```

### Points de terminaison d’inférence

| Point de terminaison   | Méthode | Description                                                |
| ---------------------- | ------- | ---------------------------------------------------------- |
| `/api/generate`        | POST    | Complétion de texte                                        |
| `/api/chat`            | POST    | Complétion de chat                                         |
| `/api/embeddings`      | POST    | Générer des embeddings (hérité)                            |
| `/api/embed`           | POST    | Générer des embeddings v0.6+ (par lots, compatible OpenAI) |
| `/v1/chat/completions` | POST    | Chat compatible OpenAI                                     |
| `/v1/embeddings`       | POST    | Embeddings compatibles OpenAI                              |

### Création de modèles personnalisés

Créez des modèles personnalisés avec des prompts système spécifiques via l’API :

```bash
curl https://your-http-pub.clorecloud.net/api/create -d '{
  "name": "my-assistant",
  "modelfile": "FROM llama3.2\nSYSTEM You are a helpful coding assistant."
}'
```

## Configuration GPU

### Vérifier l’utilisation du GPU

```bash
# Dans le conteneur ou le serveur
nvidia-smi

# Ollama affiche le GPU dans les journaux
ollama run llama3.2 --verbose
```

### Multi-GPU

Ollama utilise automatiquement les GPU disponibles. Pour un GPU spécifique :

```bash
CUDA_VISIBLE_DEVICES=0 ollama serve
```

### Gestion de la mémoire

```bash
# Définir la limite de mémoire GPU
OLLAMA_GPU_MEMORY=8GiB ollama serve

# Garder le modèle chargé
OLLAMA_KEEP_ALIVE=24h ollama serve

# Autoriser les modèles concurrents (v0.6+)
OLLAMA_MAX_LOADED_MODELS=3 ollama serve
```

## Modèles personnalisés (Modelfile)

Créez des modèles personnalisés avec des prompts système :

```dockerfile
# Modelfile
FROM llama3.2

SYSTEM Vous êtes un assistant de codage utile. Fournissez toujours des exemples de code.

PARAMETER temperature 0.7
PARAMETER top_p 0.9
```

```bash
ollama create coding-assistant -f Modelfile
ollama run coding-assistant
```

## Exécution en tant que service

### Systemd

```ini
# /etc/systemd/system/ollama.service
[Unit]
Description=Service Ollama
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/ollama serve
Restart=always
Environment="OLLAMA_HOST=0.0.0.0"

[Install]
WantedBy=multi-user.target
```

```bash
systemctl enable ollama
systemctl start ollama
```

## Conseils de performance

1. **Utilisez une quantification appropriée**
   * Q4\_K\_M pour la vitesse
   * Q8\_0 pour la qualité
   * fp16 pour une qualité maximale
2. **Adaptez le modèle à la VRAM**
   * 8 Go : modèles 7B (Q4)
   * 16 Go : modèles 13B ou 7B (Q8)
   * 24 Go : modèles 34B (Q4)
   * 48 Go+ : modèles 70B
3. **Garder le modèle chargé**

   ```bash
   OLLAMA_KEEP_ALIVE=1h ollama serve
   ```
4. **Un SSD rapide améliore les performances**
   * Le chargement du modèle et le cache KV bénéficient d’un stockage rapide
   * Les serveurs avec SSD NVMe peuvent atteindre des performances 2 à 3 fois meilleures

## Benchmarks

### Vitesse de génération (jetons/s)

| Modèle               | RTX 3060 | RTX 3090 | RTX 4090 | A100 40 Go |
| -------------------- | -------- | -------- | -------- | ---------- |
| Llama 3.2 3B (Q4)    | 120      | 160      | 200      | 220        |
| Llama 3.1 8B (Q4)    | 60       | 100      | 130      | 150        |
| Llama 3.1 8B (Q8)    | 45       | 80       | 110      | 130        |
| Mistral 7B (Q4)      | 70       | 110      | 140      | 160        |
| Mixtral 8x7B (Q4)    | -        | 35       | 55       | 75         |
| Llama 3.1 70B (Q4)   | -        | -        | 18       | 35         |
| DeepSeek-R1 7B (Q4)  | 65       | 105      | 135      | 155        |
| DeepSeek-R1 32B (Q4) | -        | -        | 22       | 42         |
| Qwen2.5 72B (Q4)     | -        | -        | 15       | 30         |
| Phi-4 14B (Q4)       | -        | 50       | 75       | 90         |

*Benchmarks mis à jour en janvier 2026. Les vitesses réelles peuvent varier selon la configuration du serveur.*

### Temps jusqu’au premier jeton (ms)

| Modèle | RTX 3090 | RTX 4090 | A100 |
| ------ | -------- | -------- | ---- |
| 3B     | 50       | 35       | 25   |
| 7-8B   | 120      | 80       | 60   |
| 13B    | 250      | 150      | 100  |
| 34B    | 600      | 350      | 200  |
| 70B    | -        | 1200     | 500  |

### Longueur de contexte vs VRAM (Q4)

| Modèle | ctx 2K | ctx 4K | ctx 8K | ctx 16K |
| ------ | ------ | ------ | ------ | ------- |
| 7B     | 5 Go   | 6 Go   | 8 Go   | 12 Go   |
| 13B    | 8 Go   | 10 Go  | 14 Go  | 22 Go   |
| 34B    | 20 Go  | 24 Go  | 32 Go  | 48 Go   |
| 70B    | 40 Go  | 48 Go  | 64 Go  | 96 Go   |

## Exigences GPU

| Modèle | VRAM Q4 | VRAM Q8 |
| ------ | ------- | ------- |
| 3B     | 3 Go    | 5 Go    |
| 7-8B   | 5 Go    | 9 Go    |
| 13B    | 8 Go    | 15 Go   |
| 34B    | 20 Go   | 38 Go   |
| 70B    | 40 Go   | 75 Go   |

## Estimation des coûts

Tarifs typiques de la place de marché CLORE.AI :

| GPU                                                                                                | VRAM  | Prix/jour   | Convient pour       |
| -------------------------------------------------------------------------------------------------- | ----- | ----------- | ------------------- |
| [RTX 3090](https://clore.ai/rent-3090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=ollama) | 24 Go | 0,30–1,00 $ | Modèles 13B-34B     |
| [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=ollama) | 24 Go | 0,50–2,00 $ | Modèles 34B, rapide |
| RTX 4070                                                                                           | 12 Go | 0,20–0,50 $ | Modèles 7B          |
| A100 80 Go                                                                                         | 80 Go | 1,50–3,00 $ | Modèles 70B         |

*Prix en USD/jour. Les tarifs varient selon le fournisseur — consultez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour connaître les tarifs actuels.*

## Dépannage

### Le modèle ne se charge pas

```bash
# Vérifiez la mémoire disponible
nvidia-smi

# Essayez une quantification plus petite
ollama pull llama3.1:8b-q4_0
```

### Génération lente

```bash
# Vérifiez si le GPU est utilisé
ollama run llama3.2 --verbose

# Assurez-vous que CUDA est disponible
nvidia-smi
```

### Connexion refusée

```bash
# Assurez-vous que le serveur est en cours d'exécution
ollama serve

# Vérifiez s'il est lié à toutes les interfaces
OLLAMA_HOST=0.0.0.0 ollama serve
```

### HTTP 502 sur l'URL http\_pub

Cela signifie que le service est encore en cours de démarrage. Attendez 30 à 60 secondes puis réessayez :

```bash
# Vérifiez si le service est prêt
curl https://your-http-pub.clorecloud.net/

# Attendu : « Ollama est en cours d'exécution »
# Si 502 : attendez et réessayez
```

## Étapes suivantes

* [Ouvrir WebUI](/guides/guides_v2-fr/modeles-de-langage/open-webui.md) - Interface de chat élégante pour Ollama
* [vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) - Service de production à haut débit
* [DeepSeek-R1](/guides/guides_v2-fr/modeles-de-langage/deepseek-r1.md) - Modèle de raisonnement
* [DeepSeek-V3](/guides/guides_v2-fr/modeles-de-langage/deepseek-v3.md) - Meilleur modèle général
* [Qwen2.5](/guides/guides_v2-fr/modeles-de-langage/qwen25.md) - Alternative multilingue
* [Text Generation WebUI](/guides/guides_v2-fr/modeles-de-langage/text-generation-webui.md) - Fonctionnalités avancées


---

# 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/ollama.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.