Agent IA avec Ollama : le tutoriel 2026

Introduction

Ollama s'est imposé comme le standard de facto pour quiconque veut faire tourner un agent IA en local — sans dépendre d'une API externe ni engager de frais d'abonnement. En 2026, la bibliothèque de modèles disponibles (Llama 3, Mistral, Qwen2, CodeLlama) et les intégrations avec les principaux frameworks (CrewAI, LangChain, LangGraph) sont matures et prêtes à l'emploi.

Dans ce tutoriel, vous allez :

• Installer Ollama sur votre machine
• Exposer une API locale compatible OpenAI
• Intégrer Ollama avec CrewAI et LangChain pour construire un agent fonctionnel

Chaque étape inclut du code prêt à copier-coller.

Installation d'Ollama

macOS et Linux

curl -fsSL https://ollama.com/install.sh | sh

Sur macOS, Homebrew fonctionne aussi :

brew install ollama

Windows

Ollama sous Windows nécessite WSL2. Ouvrez un terminal WSL2 et exécutez le même script d'installation que pour Linux.

Vérification

ollama --version

Télécharger et lancer un modèle

# Llama 3 — usage général
ollama run llama3

# Mistral — bon en français
ollama run mistral

# CodeLlama — génération et revue de code
ollama run codellama

# Qwen2 — multilingue, reasoning
ollama run qwen2

Le premier lancement télécharge le modèle. Les suivants utilisent le cache local.

Quel modèle choisir ?

Modèle	Paramètres	RAM min.	Idéal pour
llama3	8B	4 Go	Usage général
llama3:70b	70B	64 Go+	Qualité maximale
mistral	7B	4 Go	Français, tâches légères
qwen2	7B	4 Go	Multilingue, raisonnement
codellama	7B	4 Go	Code

Si vous avez un GPU NVIDIA avec CUDA, Ollama l'utilise automatiquement. Vérifiez avec :

OLLAMA_DEBUG=1 ollama run llama3

API Ollama et premiers tests

Ollama expose un serveur REST sur localhost:11434. Deux endpoints à connaître.

/api/generate — génération simple

curl http://localhost:11434/api/generate -d '{
  "model": "llama3",
  "prompt": "Explique la différence entre un agent réactif et un agent avec mémoire en 3 phrases.",
  "stream": false
}'

/api/chat — mode conversation

curl http://localhost:11434/api/chat -d '{
  "model": "llama3",
  "messages": [
    {"role": "user", "content": "Quels sont les avantages d\'Ollama ?"}
  ],
  "stream": false
}'

Python avec requests

import requests

response = requests.post("http://localhost:11434/api/chat", json={
    "model": "llama3",
    "messages": [{"role": "user", "content": "Qu'est-ce qu'un agent IA avec tools ?"}],
    "stream": False
})

print(response.json()["message"]["content"])

Lancez le serveur en arrière-plan avec ollama serve si nécessaire.

Client OpenAI-compatible

Le changement décisif : Ollama expose une API au format OpenAI. Vous pouvez rediriger n'importe quel client OpenAI-compatible vers http://localhost:11434/v1 au lieu d'OpenAI — sans changer une ligne de code métier.

Installation

pip install openai

Configuration

from openai import OpenAI

client = OpenAI(
    api_key="ollama",  # requis par le SDK, non utilisé
    base_url="http://localhost:11434/v1"
)

response = client.chat.completions.create(
    model="llama3",
    messages=[
        {"role": "system", "content": "Tu es un assistant IA expert."},
        {"role": "user", "content": "Donne-moi 3 bonnes pratiques pour utiliser Ollama."}
    ],
    temperature=0.7,
    max_tokens=512
)

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

Seul le base_url change. Le reste du code est identique à un projet utilisant l'API OpenAI.

Intégration avec CrewAI

CrewAI orchestrer des agents multi-rôles en Python. L'intégration avec Ollama prend quelques minutes.

Installation

pip install crewai crewai-tools

Agent simple avec Ollama

from crewai import Agent, Task, Crew
from langchain_openai import OpenAI as LangChainOpenAI

# Ollama comme LLM
llm = LangChainOpenAI(
    openai_api_base="http://localhost:11434/v1",
    openai_api_key="ollama",
    model_name="llama3",
    temperature=0.7
)

# Agent analyste
analyste = Agent(
    role="Analyste SEO",
    goal="Rédiger une analyse de mots-clés pertinente",
    backstory="Expert SEO avec 10 ans d'expérience.",
    llm=llm,
    verbose=True
)

# Tâche
tache = Task(
    description="Analyse les mots-clés pour un article sur les agents IA locaux.",
    agent=analyste,
    expected_output="Une liste de 10 mots-clés avec volume et difficulté."
)

# Orchestration
crew = Crew(agents=[analyste], tasks=[tache])
resultat = crew.kickoff()

print(resultat)

La clé : LangChainOpenAI pointant vers http://localhost:11434/v1. CrewAI utilise LangChain en interne — l'intégration est transparente.

Ajouter des tools

from crewai import Agent
from crewai_tools import SerpAPITool, WikipediaTool

recherche_tool = SerpAPITool(api_key="VOTRE_CLE_SERPAPI")
wikipedia_tool = WikipediaTool()

chercheur = Agent(
    role="Chercheur IA",
    goal="Rassembler des informations fiables",
    backstory="Spécialiste de la veille techno.",
    llm=llm,
    tools=[recherche_tool, wikipedia_tool],
    verbose=True
)

Note : le function calling natif n'est disponible que sur certains modèles (notamment llama3). Vérifiez sur ollama.com/docs.

Intégration avec LangChain

LangChain offre une abstraction plus fine. ChatOllama est conçu pour Ollama.

Installation

pip install langchain langchain-community

Chat basique

from langchain_community.chat_models import ChatOllama
from langchain_core.messages import HumanMessage, SystemMessage

llm = ChatOllama(
    model="llama3",
    temperature=0.7,
    base_url="http://localhost:11434"
)

messages = [
    SystemMessage(content="Tu es un assistant DevOps expert."),
    HumanMessage(content="Comment configurer un agent qui surveille des logs ?")
]

response = llm.invoke(messages)
print(response.content)

Chain avec output parser

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate

prompt = PromptTemplate.from_template(
    "Explique {sujet} en {nombre} phrases maximum."
)

chain = prompt | llm | StrOutputParser()
result = chain.invoke({"sujet": "les agents IA avec mémoire", "nombre": 3})
print(result)

LangChain permet de chaîner composants (prompt → model → parser) de manière déclarative — facile à tester et refactorer.

Ajouter des tools à votre agent

Un agent sans tools est limité à la génération de texte. Les tools étendent ses capacités : recherche web, appels HTTP, exécution de code, lecture de fichiers.

Function calling (modèles supportés)

from langchain_core.utils.function_calling import convert_to_openai_function

llm_with_functions = llm.bind(
    functions=[convert_to_openai_function(...)]
)

Recherche web avec LangChain

from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.agents import initialize_agent, AgentType

search = TavilySearchResults(api_key="VOTRE_CLE_TAVILY")

agent = initialize_agent(
    tools=[search],
    llm=llm,
    agent=AgentType.CHAT_CONVERSATIONAL,
    verbose=True
)

agent.run("Recherche les dernières nouvelles sur Ollama en 2026")

Outils fichiers

from langchain_community.tools.file_management import ReadFileTool, WriteFileTool

file_tools = [ReadFileTool(), WriteFileTool()]

agent = initialize_agent(
    tools=file_tools,
    llm=llm,
    agent=AgentType.CHAT_CONVERSATIONAL,
    verbose=True
)

agent.run("Lis le fichier config.yaml et extrais les paramètres")

Comparatif : Ollama vs API cloud

Critère	Ollama local	OpenAI / Anthropic
Coût	Gratuit (matériel only)	Payant par token
Confidentialité	✅ 100% local	⚠️ Données transitent
Qualité	Variable (modèle-dependent)	État de l'art
Latence	~100–500ms (hardware)	<200ms (optimisé)
Offline	✅ Possible	❌ Connexion requise
Setup	Nécessite configuration	Prêt à l'emploi

Choisissez Ollama si :

• Projet hobby ou apprentissage (coût zéro)
• Confidentialité des données (médical, juridique)
• Environnement offline ou réseau restreint

Choisissez une API cloud si :

• Modèles de pointe requis (reasoning advanced)
• Production avec SLA garantis
• Hardware limité

En pratique, beaucoup adoptent une approche hybride : Ollama pour le dev local, cloud pour la production.

Performances : RAM, GPU et quantification

La question qui détermine tout : votre machine peut-elle faire tourner le modèle à une vitesse utilisable ? Deux facteurs dominent.

La RAM (ou la VRAM). Un modèle doit tenir en mémoire pour s'exécuter. La règle approximative : il faut environ la taille du fichier du modèle quantifié en RAM disponible. Un llama3 8B en quantification q4 pèse ~4,7 Go ; comptez donc 8 Go de RAM libre pour être confortable. Un modèle 70B en q4 réclame ~40 Go.

Le GPU. C'est lui qui fait la différence entre « lent mais utilisable » et « fluide ». Sur CPU seul, un 8B génère quelques tokens par seconde ; sur un GPU NVIDIA récent, on dépasse facilement 40–60 tokens/s. Ollama détecte et utilise automatiquement un GPU NVIDIA (CUDA), AMD (ROCm) ou le moteur Metal des Mac Apple Silicon.

Configuration	Modèle réaliste	Ressenti
Laptop 8 Go RAM, CPU	llama3 8B q4, mistral 7B	Lent (quelques tokens/s) mais fonctionnel
Mac M1/M2/M3 16 Go	jusqu'à 13B	Fluide grâce à Metal et la mémoire unifiée
GPU 12–16 Go VRAM	8B–13B	Rapide
GPU 24 Go+ ou multi-GPU	70B quantifié	Qualité maximale, débit correct

La quantification est le levier clé : elle réduit la précision des poids (de 16 bits à 4 ou 5 bits) pour diviser l'empreinte mémoire, au prix d'une légère perte de qualité. Choisissez le tag adapté :

# Variantes quantifiées du même modèle
ollama run llama3:8b-instruct-q4_0   # léger, le plus rapide
ollama run llama3:8b-instruct-q5_1   # bon compromis qualité/RAM
ollama run llama3:8b-instruct-q8_0   # qualité quasi pleine, plus lourd

Pour mesurer le débit réel sur votre matériel, ajoutez --verbose :

ollama run llama3 --verbose
# Affiche eval rate (tokens/s), durée de chargement et d'évaluation

Limites à connaître

Ollama est excellent, mais ce n'est pas une solution miracle. Gardez ces limites en tête avant de bâtir un agent en local :

• Qualité inférieure aux modèles de pointe. Un 8B local reste loin d'un GPT-4o ou d'un Claude sur le raisonnement complexe, le code difficile et les longues chaînes d'agents. Les erreurs s'accumulent dans les workflows multi-étapes.
• Function calling partiel. Tous les modèles ne savent pas appeler des outils nativement, et même quand c'est supporté, la fiabilité est inférieure aux API cloud. Prévoyez des garde-fous (validation des sorties, parsing robuste).
• Fenêtre de contexte limitée. Par défaut, Ollama tronque le contexte (souvent 2048 ou 4096 tokens selon le modèle) ; il faut l'augmenter explicitement (num_ctx), ce qui consomme davantage de RAM.
• Débit borné par votre matériel. Pas de scaling élastique : un seul GPU sert une poignée de requêtes simultanées. Pour servir du trafic réel, il faut dimensionner la machine ou répartir sur plusieurs.
• Mises à jour manuelles. Aucun modèle ne se met à jour tout seul ; vous gérez les versions avec ollama pull.

Exemple concret : agent SEO avec Ollama + CrewAI

Contexte : produire un article optimisé SEO sur les agents IA. L'agent doit trouver les mots-clés, structurer le plan, rédiger un résumé.

from crewai import Agent, Task, Crew
from crewai_tools import SerpAPITool
from langchain_openai import OpenAI as LangChainOpenAI

llm = LangChainOpenAI(
    openai_api_base="http://localhost:11434/v1",
    openai_api_key="ollama",
    model_name="llama3",
    temperature=0.5
)

recherche = SerpAPITool(api_key="VOTRE_CLE")

# Agent 1 — Recherche de mots-clés
kw_agent = Agent(
    role="Spécialiste keyword research",
    goal="Identifier 10 mots-clés avec volume et intention",
    backstory="Expert SEO maîtrisant GSC et SEMrush.",
    llm=llm,
    tools=[recherche],
    verbose=True
)

# Agent 2 — Planification éditoriale
plannificateur = Agent(
    role="Planificateur éditorial",
    goal="Créer un plan d'article optimisé SEO en 5 sections",
    backstory="Rédacteur senior, +200 articles rankés.",
    llm=llm,
    verbose=True
)

# Tâches
tache_kw = Task(
    description="Recherche 10 mots-clés pour : 'agent IA local avec Ollama'",
    agent=kw_agent,
    expected_output="Tableau : mot-clé | volume | intention | difficulté"
)

tache_plan = Task(
    description="À partir des mots-clés, créer un plan H2/H3 optimisé",
    agent=plannificateur,
    expected_output="Plan markdown, 5 sections H2 + sous-parties H3"
)

crew = Crew(agents=[kw_agent, plannificateur], tasks=[tache_kw, tache_plan])
resultat = crew.kickoff()

print(resultat)

Résultat : un tableau de mots-clés + un plan structuré — le tout en local, sans API externe.

Bonnes pratiques

Gestion des ressources. Les modèles 7B fonctionnent sur un laptop 8 Go RAM. Les modèles 70B nécessitent un GPU 24 Go+. Surveillez la RAM avec htop et ajustez la quantification (q4_0, q5_1, q8_0) pour réduire l'empreinte.

Sécurité réseau. Par défaut, Ollama écoute sur localhost uniquement. Pour exposer l'API sur un réseau, utilisez un reverse proxy (nginx, Caddy) avec TLS et authentification. Ne jamais exposer 0.0.0.0 en production.

Température et max_tokens. Temperature 0.7 pour le créatif. Descendez à 0.1–0.3 pour du déterministe (extraction, classification). Définissez toujours max_tokens pour éviter les réponses infinies.

Mettre à jour les modèles. Pas de mise à jour automatique. Utilisez ollama pull <modèle> périodiquement. Checkez ollama.com/library pour les nouvelles versions.

Débogage. Face à un comportement inattendu, testez d'abord le prompt directement avec curl ou ollama run <modèle> en mode interactif. Beaucoup de problèmes viennent de l'encodage Python, pas du modèle.

Questions fréquentes

Qu'est-ce qu'un agent IA avec Ollama ?

Un agent IA avec Ollama est un système où un LLM exécuté localement est enrichi de tools (recherche web, appels HTTP, fichiers) et d'une logique de décision pour accomplir des tâches complexes de manière autonome.

Ollama est-il gratuit ?

Oui. Ollama est open-source et gratuit. Seul le matériel (RAM, GPU, stockage) représente un coût. Aucun frais par token.

Quel modèle Ollama choisir ?

Pour un usage général : llama3 8B ou mistral 7B (meilleur rapport performance/coût). Pour du code : codellama. Pour du raisonnement complexe : qwen2 ou llama3:70b.

Ollama supporte-t-il le function calling ?

Oui, mais uniquement sur certains modèles (versions récentes de llama3 et mistral). Pour les autres, LangChain et CrewAI permettent d'implémenter le function calling via des prompts structurés.

Comment intégrer Ollama avec CrewAI ?

Installez crewai et langchain-openai, puis configurez le LLM avec base_url="http://localhost:11434/v1". CrewAI utilise LangChain en interne — l'intégration est transparente.

Articles liés

• Agent IA local — guide complet pour bien démarrer
• CrewAI — orchestrer plusieurs agents
• LangGraph — workflows d'agents complexes
• Outils agents IA — panorama des outils disponibles
• Frameworks agents IA — vue globale de l'écosystème