Ollama

Exécutez des LLM localement avec Ollama sur les GPU Clore.ai

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

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+ pour plus de détails.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

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	-

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.

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 :

ollama serve

Vérifier que cela fonctionne

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

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

Si vous obtenez une erreur HTTP 502, attendez 30 à 60 secondes - le service est encore en cours de démarrage.

Accéder à votre service

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

# 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
}'

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.

Installation

Avec Docker (recommandé)

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

Installation manuelle

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

# 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

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

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 :

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 :

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

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 :

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 :

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

# 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

# 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
}'

Ajoutez "stream": false pour obtenir la réponse complète d’un seul coup au lieu d’un flux.

Point de terminaison compatible OpenAI

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

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

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

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

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

Réponse :

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

Afficher les détails du modèle

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

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

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

Réponse :

{"status": "success"}

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

Supprimer le modèle

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

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

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

Réponse :

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

Obtenir la version

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

Réponse :

{"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 :

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

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

CUDA_VISIBLE_DEVICES=0 ollama serve

Gestion de la mémoire

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

# 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

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

Exécution en tant que service

Systemd

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

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é

   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	24 Go	0,30–1,00 $	Modèles 13B-34B
RTX 4090	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 pour connaître les tarifs actuels.

Dépannage

Le modèle ne se charge pas

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

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

Génération lente

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

# Assurez-vous que CUDA est disponible
nvidia-smi

Connexion refusée

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

# 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 - Interface de chat élégante pour Ollama

• vLLM - Service de production à haut débit

• DeepSeek-R1 - Modèle de raisonnement

• DeepSeek-V3 - Meilleur modèle général

• Qwen2.5 - Alternative multilingue

• Text Generation WebUI - Fonctionnalités avancées