Construire un chatbot local avec Ollama et Python en 2026

Vous allez installer Ollama v0.23.4 et construire un chatbot Python qui fonctionne entièrement en local, sans envoyer de données à des serveurs externes. Le modèle Llama 3.2 (3b) nécessite seulement 2 Go de RAM et tourne sur macOS 14+ ou Ubuntu 22.04+ sans GPU dédié. Documentation officielle ollama.com.

Ce que vous allez construire et pourquoi en 2026

Un chatbot en ligne de commande interactif qui conserve l'historique de conversation et répond localement via l'API Ollama. Le projet utilise le client Python officiel ollama v0.6.2 (pip) et le modèle llama3.2:3b. Prérequis : Python 3.8+, 8 Go RAM minimum (4 Go si vous utilisez le modèle 1b), macOS 14 Sonoma+ ou Ubuntu 22.04+, 4 Go d'espace disque pour le modèle. Temps estimé : 15 minutes sur Mac M1 / 25 minutes sur Intel.

Installation : commandes exactes à copier

# macOS et Linux — installer Ollama
curl -fsSL https://ollama.com/install.sh | sh # Vérifier l'installation
ollama --version
# Résultat attendu : ollama version 0.23.4 ou supérieur # Télécharger le modèle léger (2 Go)
ollama pull llama3.2:3b # Tester que le modèle répond
ollama run llama3.2:3b "Bonjour, présente-toi en une phrase."
# Résultat attendu : une réponse en français du modèle Llama

Erreur courante : Error: model requires 8GB VRAM → utilisez ollama pull llama3.2:1b à la place (modèle 1 Go, qualité réduite mais fonctionnel sur machines avec 4 Go RAM). Sur Windows, téléchargez OllamaSetup.exe depuis ollama.com/download et lancez l'installateur.

Configuration : les fichiers et variables à définir

# Créer le dossier du projet
mkdir chatbot-ollama && cd chatbot-ollama # Créer un environnement virtuel
python3 -m venv venv
source venv/bin/activate # Linux/macOS
# venv\Scripts\activate # Windows # Installer le client Python officiel
pip install ollama==0.6.2 # Vérifier l'installation
python -c "import ollama; print(ollama.__version__)"
# Résultat attendu : 0.6.2

Le client ollama Python se connecte par défaut à http://localhost:11434. Si Ollama tourne sur un autre port ou serveur, définissez la variable d'environnement : export OLLAMA_HOST=http://192.168.1.100:11434. Aucun fichier .env n'est requis pour un usage local.

Le code du projet : construire le chatbot interactif

# chatbot.py — Chatbot interactif avec historique de conversation
import ollama def chatbot(): """Chatbot local avec historique de conversation via Ollama.""" model = "llama3.2:3b" messages = [] print("Chatbot Ollama — tapez 'quit' pour quitter, 'reset' pour effacer l'historique") print(f"Modèle actif : {model}") print("-" * 60) while True: user_input = input("
Vous : ").strip() if not user_input: continue if user_input.lower() == "quit": print("Au revoir !") break if user_input.lower() == "reset": messages = [] print("Historique effacé.") continue messages.append({"role": "user", "content": user_input}) try: response = ollama.chat( model=model, messages=messages ) assistant_msg = response["message"]["content"] messages.append({"role": "assistant", "content": assistant_msg}) print(f"
Assistant : {assistant_msg}") print(f"[Tokens : {response.get('eval_count', '?')} générés en {round(response.get('eval_duration', 0) / 1e9, 1)}s]") except ollama.ResponseError as e: print(f"Erreur Ollama : {e.error}") if "model not found" in str(e.error).lower(): print("→ Lancez 'ollama pull llama3.2:3b' pour télécharger le modèle.") messages.pop() if __name__ == "__main__": chatbot()

Chaque ligne expliquée : ollama.chat() appelle l'endpoint POST /api/chat d'Ollama en envoyant l'historique complet messages. Le modèle reçoit le contexte de toute la conversation et génère une réponse cohérente. L'objet response contient eval_count (tokens générés) et eval_duration (temps en nanosecondes), permettant de calculer la vitesse en tokens/seconde.

Tester et valider que ça fonctionne

# Lancer le chatbot
python chatbot.py # Test 1 : question simple
# Vous : Quelle est la capitale de la France ?
# Assistant : La capitale de la France est Paris. # Test 2 : conversation avec contexte
# Vous : Qui est le président ?
# Vous : Depuis quand ?
# (le modèle se souvient du contexte de la conversation) # Test 3 : vérifier l'API directement
curl http://localhost:11434/api/tags
# Doit retourner la liste des modèles dont llama3.2:3b

Si curl: (7) Failed to connect → Ollama n'est pas lancé. Démarrez-le avec ollama serve dans un autre terminal. Si le modèle est lent, vérifiez la RAM disponible avec htop (Linux) ou Activity Monitor (macOS) — le modèle 3b consomme environ 2,5 Go en mémoire.

Déployer et utiliser en production

Pour un service persistant, créez un service systemd (Linux) :

# /etc/systemd/system/ollama-chatbot.service
[Unit]
Description=Chatbot Ollama
After=network.target ollama.service [Service]
Type=simple
User=ollama
WorkingDirectory=/opt/chatbot-ollama
ExecStart=/opt/chatbot-ollama/venv/bin/python chatbot.py
Restart=on-failure
RestartSec=5 [Install]
WantedBy=multi-user.target

Pour mettre à jour Ollama : curl -fsSL https://ollama.com/install.sh | sh (met à jour le binaire sans toucher aux modèles). Pour mettre à jour le modèle : ollama pull llama3.2:3b télécharge la dernière version du modèle. Pour ajouter le chatbot au démarrage : sudo systemctl enable ollama-chatbot.

Aller plus loin : 3 extensions concrètes

1. Interface web avec Gradio — Installez pip install gradio et ajoutez une interface web en 10 lignes :

import gradio as gr
import ollama def respond(message, history): messages = [] for h in history: messages.append({"role": "user", "content": h["user"]}) messages.append({"role": "assistant", "content": h["assistant"]}) messages.append({"role": "user", "content": message}) response = ollama.chat(model="llama3.2:3b", messages=messages) return response["message"]["content"] gr.ChatInterface(respond, title="Chatbot Local Ollama").launch()

2. Sortie structurée en JSON — Passez format="json" à ollama.chat() pour forcer le modèle à répondre en JSON valide, utile pour extraire des données structurées depuis du texte libre.

3. Tool calling (appel de fonctions) — L'API chat d'Ollama supporte le paramètre tools pour que le modèle appelle des fonctions Python prédéfinies (recherche web, calcul, accès base de données). Voir la documentation officielle pour les schémas de définition d'outils.