# Ollama

La façon 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 nouvelles fonctionnalités clés incluent des sorties structurées (application d'un schéma JSON), un endpoint d'embeddings compatible OpenAI (`/api/embed`), et le chargement concurrent de modèles (exécutez plusieurs modèles simultanément sans échange). Voir [Nouveautés de la v0.6+](#new-in-v06) pour les 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 %}

## Exigences du serveur

| Paramètre          | Minimum       | Recommandé |
| ------------------ | ------------- | ---------- |
| RAM                | 8 Go          | 16 Go+     |
| VRAM               | 6 Go          | 8 Go+      |
| Réseau             | 100Mbps       | 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 volumineux (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** - Remplaçant direct
* **Accélération GPU** - Détection CUDA automatique
* **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érifiez que cela fonctionne

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

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

# Réponse attendue : "Ollama is running"
```

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

## Accéder à votre service

Lorsqu'il est déployé sur CLORE.AI, accédez à votre instance Ollama via le `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": "Hello!"}],
  "stream": false
}'
```

{% hint style="info" %}
Tous `localhost:11434` les exemples ci-dessous fonctionnent lorsqu'ils sont connectés via SSH. Pour un accès externe, remplacez par votre `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## Installation

### Utilisation de 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 commande unique installe la dernière version d'Ollama, configure le service systemd et configure automatiquement la détection GPU. Fonctionne sur Ubuntu, Debian, Fedora et la plupart des distributions Linux modernes.

## Exécution de modèles

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

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

# Exécuter un chat interactif
ollama run llama3.2

# Exécuter avec un prompt
ollama run llama3.2 "Explain quantum computing"
```

### Modèles populaires

| Modèle              | Taille  | Cas d'utilisation           |
| ------------------- | ------- | --------------------------- |
| `llama3.2`          | 3B      | Rapide, usage général       |
| `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     | 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     | Dernier modèle de Microsoft |
| `gemma2`            | 9B      | Modèle de Google            |

### Variantes de modèle

```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é supérieure
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 production :

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

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

```bash
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Tell me about 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": "List 3 programming languages with their main use cases"}],
    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)
```

### Endpoint d'embeddings compatible OpenAI (`/api/embed`)

Nouveauté de la v0.6+ : le `/api/embed` endpoint est pleinement compatible OpenAI et prend en charge les entrées par lot :

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

# Embeddings en lot (nouveau en v0.6)
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["First document", "Second document", "Third 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")

# Récupérez 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"Similarity: {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 v0.6, Ollama déchargeait un modèle pour en charger un autre. La v0.6+ prend en charge l'exécution de plusieurs modèles simultanément, 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 tourne
curl http://localhost:11434/api/ps
```

Configurer la concurrence :

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

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

Ceci est particulièrement utile pour :

* Tests A/B de différents modè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": "Hello!"}],
  "stream": false
}'

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

{% hint style="info" %}
Ajoutez `"stream": false` pour obtenir la réponse complète en une seule fois au lieu du streaming.
{% endhint %}

### Endpoint compatible OpenAI

```python
from openai import OpenAI

# Pour un 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 un 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": "What is machine learning?"}
    ]
)

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

### Streaming

```python
stream = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)

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

### Embeddings

```bash
# Endpoint legacy (fonctionne toujours)
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "Hello world"
}'

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

### Génération de texte (Non-Chat)

```bash
curl https://your-http-pub.clorecloud.net/api/generate -d '{
  "model": "llama3.2",
  "prompt": "The meaning of life is",
  "stream": false
}'
```

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

Tous les endpoints fonctionnent à la fois avec `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" %}
Les grands modèles peuvent prendre plusieurs minutes à télécharger. Pour les très grands modèles (30 Go+), envisagez d'utiliser SSH et l'interface CLI : `ollama pull model-name`
{% endhint %}

#### Supprimer un 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"}
```

### Endpoints 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 (legacy)                       |
| `/api/embed`           | POST    | Générer des embeddings v0.6+ (lot, 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 sur le serveur
nvidia-smi

# Ollama affiche le GPU dans les logs
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 You are a helpful coding assistant. Always provide code examples.

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 adaptée**
   * Q4\_K\_M pour la vitesse
   * Q8\_0 pour la qualité
   * fp16 pour la qualité maximale
2. **Adaptez le modèle à la VRAM**
   * 8GB : modèles 7B (Q4)
   * 16GB : modèles 13B ou 7B (Q8)
   * 24GB : modèles 34B (Q4)
   * 48GB+ : 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 supérieures

## Benchmarks

### Vitesse de génération (tokens/sec)

| Modèle               | RTX 3060 | RTX 3090 | RTX 4090 | A100 40GB |
| -------------------- | -------- | -------- | -------- | --------- |
| 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 token (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 | Contexte 2K | Contexte 4K | Contexte 8K | Contexte 16K |
| ------ | ----------- | ----------- | ----------- | ------------ |
| 7B     | 5Go         | 6 Go        | 8 Go        | 12Go         |
| 13B    | 8 Go        | 10Go        | 14GB        | 22Go         |
| 34B    | 20Go        | 24 Go       | 32Go        | 48Go         |
| 70B    | 40Go        | 48Go        | 64Go        | 96GB         |

## Exigences GPU

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

## Estimation des coûts

Tarifs typiques du marketplace CLORE.AI :

| GPU      | VRAM  | Prix/jour   | Convient pour       |
| -------- | ----- | ----------- | ------------------- |
| RTX 3060 | 12Go  | 0,15–0,30 $ | modèles 7B          |
| RTX 3090 | 24 Go | 0,30–1,00 $ | Modèles 13B-34B     |
| RTX 4090 | 24 Go | 0,50–2,00 $ | Modèles 34B, rapide |
| A100     | 40Go  | 1,50–3,00 $ | Modèles 70B         |

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

## Dépannage

### Le modèle ne se charge pas

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

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

### Génération lente

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

# S'assurer que CUDA est disponible
nvidia-smi
```

### Connexion refusée

```bash
# Assurez-vous que le serveur fonctionne
ollama serve

# Vérifiez s'il se lie à 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 et réessayez :

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

# Attendu : "Ollama is running"
# Si 502 : attendez et réessayez
```

## Prochaines étapes

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