Guide Complet Ollama 2026 : Exécuter les modèles Llama/Mistral en local, un outil AI respectueux de la vie privée pour les développeurs

# Méthode 1 : installation en un clic (recommandée)
curl -fsSL https://ollama.com/install.sh | sh

# Méthode 2 : via Homebrew
brew install ollama

# Vérifier l'installation
ollama --version

# Installation en un clic (inclut le service systemd)
curl -fsSL https://ollama.com/install.sh | sh

# Installation manuelle (binaire)
curl -fsSL https://ollama.com/install.sh | OLLAMA_INSTALL=1 sh

# Gestion via systemd
sudo systemctl start ollama
sudo systemctl enable ollama

# Vérification
ollama --version

# Télécharger le programme d'installation Windows
winget install Ollama.Ollama

# Ou télécharger depuis le site officiel
# https://ollama.com/download/OllamaSetup.exe

# Vérification
ollama --version

# Récupérer l'image officielle
docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

# Vérification
docker exec ollama ollama list

ollama run llama3.2

# Voir les modèles installés localement
ollama list

# Exemple de résultat :
# NAME                    ID              SIZE    MODIFIED
# llama3.2:latest         a1b2c3d4e5f6    2.0 GB  2 hours ago
# mistral:7b              f6e5d4c3b2a1    4.1 GB  1 day ago
# qwen2.5:14b             1a2b3c4d5e6f    8.9 GB  3 days ago

# Télécharger un modèle spécifique
ollama pull llama3.2
ollama pull mistral:7b
ollama pull qwen2.5:14b

# Télécharger une version spécifique
ollama pull llama3.2:3b

ollama run mistral:7b

# Supprimer un modèle individuel
ollama rm llama3.2

# Voir l'espace occupé par chaque modèle
du -sh ~/.ollama/models/*

FROM llama3.2:3b

# Définir le prompt système
SYSTEM """
Tu es un développeur Python professionnel.
Dans tes réponses :
1. Donne toujours un exemple de code fonctionnel en priorité
2. Explique la logique clé du code
3. Signale les pièges potentiels et les points d'optimisation
"""

# Ajuster les paramètres de génération
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

# Créer le modèle
ollama create my-python-assistant -f Modelfile

# Exécuter le modèle personnalisé
ollama run my-python-assistant

# Génération de texte (non streamé)
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Écris un tri à bulles en Python",
  "stream": false
}'

# Format Chat (conversation multi-tours)
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "system", "content": "Tu es un expert en code"},
    {"role": "user", "content": "Explique async/await"}
  ],
  "stream": false
}'

# Endpoint compatible OpenAI /v1/chat/completions
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ollama" \
  -d '{
    "model": "llama3.2",
    "messages": [{"role": "user", "content": "Bonjour"}]
  }'

# Installation
# pip install ollama

import ollama

# Génération simple
response = ollama.generate(
    model='llama3.2',
    prompt='Explique l\'informatique quantique en une phrase'
)
print(response['response'])

# Format Chat
response = ollama.chat(
    model='llama3.2',
    messages=[
        {'role': 'system', 'content': 'Tu es un expert en revue de code'},
        {'role': 'user', 'content': 'Qu\'y a-t-il de problématique dans ce code ?\n\nfor i in range(len(arr)):\n    if arr[i] == x: return i'}
    ]
)
print(response['message']['content'])

# Sortie streamée
stream = ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Écris un poème sur la programmation'}],
    stream=True
)
for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

from openai import OpenAI

# Pointer vers l'endpoint local d'Ollama
client = OpenAI(
    base_url='http://localhost:11434/v1',
    api_key='ollama'  # N'importe quelle valeur fonctionne
)

response = client.chat.completions.create(
    model='llama3.2',
    messages=[
        {'role': 'user', 'content': 'Explique ce qu\'est le RAG'}
    ]
)
print(response.choices[0].message.content)

// npm install ollama
import { Ollama } from 'ollama';

const ollama = new Ollama();

// Génération simple
const response = await ollama.generate({
  model: 'llama3.2',
  prompt: 'Qu\'est-ce que Docker ?',
});
console.log(response.response);

// Format Chat
const chat = await ollama.chat({
  model: 'llama3.2',
  messages: [
    { role: 'user', content: 'Recommande 5 ressources pour apprendre Rust' }
  ],
});
console.log(chat.message.content);

import ollama
import sys

def review_code(code: str, language: str = "Python"):
    """Revue de code locale"""
    response = ollama.chat(
        model='llama3.2',
        messages=[
            {'role': 'system', 'content': f'''Tu es un expert senior en revue de code {language}.
Analyse le code selon ces critères :
1. Style du code (PEP 8 / bonnes pratiques)
2. Bugs potentiels et cas limites
3. Problèmes de performance
4. Vulnérabilités de sécurité
5. Suggestions d'amélioration

Format de sortie :
- Niveau du problème : 🔴 Critique / 🟡 Avertissement / 🟢 Suggestion
- Description du problème
- Exemple de correction'''},
            {'role': 'user', 'content': f'Revoie ce code :\n\n```{language}\n{code}\n```'}
        ]
    )
    return response['message']['content']

if __name__ == '__main__':
    # Lire le code depuis un fichier
    with open(sys.argv[1], 'r') as f:
        code = f.read()
    print(review_code(code))

python review.py mon_script.py

# pip install ollama chromadb sentence-transformers

import ollama
import chromadb
from chromadb.utils import embedding_functions

# Initialiser le client Chroma
chroma_client = chromadb.Client()

# Utiliser un modèle d'embedding local
embed_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"
)

collection = chroma_client.get_or_create_collection(
    name="knowledge_base",
    embedding_function=embed_fn
)

# Ajouter un document
def add_document(text: str, metadata: dict = None):
    collection.add(
        documents=[text],
        metadatas=[metadata or {}],
        ids=[f"doc_{collection.count()}"]
    )

# Rechercher des documents pertinents
def retrieve(query: str, n_results: int = 3):
    results = collection.query(
        query_texts=[query],
        n_results=n_results
    )
    return results['documents'][0]

# Générer une réponse
def rag_answer(question: str) -> str:
    # 1. Récupérer les documents pertinents
    context_docs = retrieve(question)
    context = "\n\n".join(context_docs)

    # 2. Appeler Ollama pour générer la réponse
    response = ollama.chat(
        model='llama3.2',
        messages=[
            {'role': 'system', 'content': f'Réponds à la question en utilisant le contexte suivant :\n\n{context}'},
            {'role': 'user', 'content': question}
        ]
    )
    return response['message']['content']

# Exemple d'utilisation
add_document("Ollama prend en charge les modèles open source Llama, Mistral, Qwen, etc.")
add_document("Ollama propose une API REST compatible OpenAI")
print(rag_answer("Quels modèles Ollama prend-il en charge ?"))

import ollama
import json

def extract_entities(text: str) -> dict:
    """Extraire des entités d'un texte"""
    response = ollama.chat(
        model='llama3.2',
        messages=[{
            'role': 'user',
            'content': f'''Extrais les entités du texte suivant et retourne-les au format JSON :
{text}

Format attendu :
{{
  "personnes": [],
  "organisations": [],
  "lieux": [],
  "dates": [],
  "événements": []
}}'''
        }]
    )
    try:
        return json.loads(response['message']['content'])
    except json.JSONDecodeError:
        return {}

# Traitement en masse
texts = [
    "Le PDG d'Apple, Tim Cook, s'est rendu à Beijing en juin 2026",
    "OpenAI a annoncé GPT-5 à San Francisco"
]

for text in texts:
    entities = extract_entities(text)
    print(json.dumps(entities, ensure_ascii=False, indent=2))