composant Ollama

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

La façon 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 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+ pour les détails.

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

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

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.

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 :

ollama serve

Vérifiez que cela fonctionne

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

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

# Réponse attendue : "Ollama is running"

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

Accéder à votre service

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

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.

Installation

Utilisation de 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 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

# 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

Rapide, usage général

llama3.1

Meilleure qualité

llama3.1:70b

70B

Meilleure qualité

mistral

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

Multilingue

qwen2.5:72b

72B

Meilleure qualité Qwen

phi4

14B

Dernier modèle de Microsoft

gemma2

Modèle de Google

Variantes de modèle

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

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 :

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 :

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

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 :

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 :

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

# 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

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

Ajoutez "stream": false pour obtenir la réponse complète en une seule fois au lieu du streaming.

Endpoint compatible OpenAI

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

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

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

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

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

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

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

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 :

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

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 You are a helpful coding assistant. Always provide code examples.

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

Utilisez une quantification adaptée
- Q4_K_M pour la vitesse
- Q8_0 pour la qualité
- fp16 pour la qualité maximale
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
Garder le modèle chargé
```
OLLAMA_KEEP_ALIVE=1h ollama serve
```
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)

100

130

150

Llama 3.1 8B (Q8)

110

130

Mistral 7B (Q4)

110

140

160

Mixtral 8x7B (Q4)

Llama 3.1 70B (Q4)

DeepSeek-R1 7B (Q4)

105

135

155

DeepSeek-R1 32B (Q4)

Qwen2.5 72B (Q4)

Phi-4 14B (Q4)

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

7-8B

120

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

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

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 pour les tarifs actuels.

Dépannage

Le modèle ne se charge pas

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

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

Génération lente

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

# S'assurer que CUDA est disponible
nvidia-smi

Connexion refusée

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

# 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 - Belle interface de chat 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 - Fonctions avancées

PrécédentAperçu SuivantOuvrir WebUI

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagExigences du serveur

hashtagPourquoi Ollama ?

hashtagDéploiement rapide sur CLORE.AI

hashtagVérifiez que cela fonctionne

hashtagAccéder à votre service

hashtagInstallation

hashtagUtilisation de Docker (Recommandé)

hashtagInstallation manuelle

hashtagExécution de modèles

hashtagTélécharger et exécuter

hashtagModèles populaires

hashtagVariantes de modèle

hashtagNouveautés de la v0.6+

hashtagSorties structurées (Schéma JSON)

hashtagEndpoint d'embeddings compatible OpenAI (/api/embed)

hashtagChargement concurrent de modèles

hashtagUtilisation de l'API

hashtagComplétion de chat

hashtagEndpoint compatible OpenAI

hashtagStreaming

hashtagEmbeddings

hashtagGénération de texte (Non-Chat)

hashtagRéférence complète de l'API

hashtagGestion des modèles

hashtagLister les modèles

hashtagAfficher les détails du modèle

hashtagTélécharger un modèle via l'API

hashtagSupprimer un modèle

hashtagLister les modèles en cours d'exécution

hashtagObtenir la version

hashtagEndpoints d'inférence

hashtagCréation de modèles personnalisés

hashtagConfiguration GPU

hashtagVérifier l'utilisation du GPU

hashtagMulti-GPU

hashtagGestion de la mémoire

hashtagModèles personnalisés (Modelfile)

hashtagExécution en tant que service

hashtagSystemd

hashtagConseils de performance

hashtagBenchmarks

hashtagVitesse de génération (tokens/sec)

hashtagTemps jusqu'au premier token (ms)

hashtagLongueur de contexte vs VRAM (Q4)

hashtagExigences GPU

hashtagEstimation des coûts

hashtagDépannage

hashtagLe modèle ne se charge pas

hashtagGénération lente

hashtagConnexion refusée

hashtagHTTP 502 sur l'URL http_pub

hashtagProchaines étapes

Exigences du serveur

Pourquoi Ollama ?

Déploiement rapide sur CLORE.AI

Vérifiez que cela fonctionne

Accéder à votre service

Installation

Utilisation de Docker (Recommandé)

Installation manuelle

Exécution de modèles

Télécharger et exécuter

Modèles populaires

Variantes de modèle

Nouveautés de la v0.6+

Sorties structurées (Schéma JSON)

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

Chargement concurrent de modèles

Utilisation de l'API

Complétion de chat

Endpoint compatible OpenAI

Streaming

Embeddings

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

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

Gestion des modèles

Lister les modèles

Afficher les détails du modèle

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

Supprimer un modèle

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

Obtenir la version

Endpoints d'inférence

Création de modèles personnalisés

Configuration GPU

Vérifier l'utilisation du GPU

Multi-GPU

Gestion de la mémoire

Modèles personnalisés (Modelfile)

Exécution en tant que service

Systemd

Conseils de performance

Benchmarks

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

Temps jusqu'au premier token (ms)

Longueur de contexte vs VRAM (Q4)

Exigences GPU

Estimation des coûts

Dépannage

Le modèle ne se charge pas

Génération lente

Connexion refusée

HTTP 502 sur l'URL http_pub

Prochaines étapes