Ollama : le guide complet pour créer des applications d’IA en local

Installer Ollama, choisir un modèle, personnaliser son comportement, le brancher à une interface graphique et développer ses propres applications (Python, LangChain, RAG, agents) : ce guide couvre tout le parcours, du premier lancement jusqu’aux usages avancés.

Comprendre Ollama

Ollama est un outil qui permet de faire tourner des grands modèles de langage (LLM) directement sur son ordinateur, sans dépendre d’un service cloud comme ChatGPT. Les données restent sur la machine, il n’y a pas d’abonnement par requête, et l’utilisateur garde un contrôle total sur le modèle utilisé.

Le principe en trois rôles

Une image simple à retenir : un LLM (le modèle) est le cerveau, Ollama est le moteur qui l’exécute sur la machine, et l’interface (terminal, application, navigateur) est simplement l’écran qui permet de discuter avec lui.

• Le modèle (le LLM) : génère la réponse. LLM signifie Large Language Model — large veut dire à la fois beaucoup de données d’entraînement et beaucoup de paramètres internes.
• Ollama : exécute ce modèle sur le PC, sans passer par un serveur distant.
• L’interface : l’endroit où l’on tape son message et lit la réponse.

Comment un LLM répond

Quand on pose une question, le modèle ne consulte aucune base de données : il calcule le mot le plus probable pour continuer la phrase, puis le mot suivant, et ainsi de suite. C’est un moteur statistique du langage, pas une recherche d’information — ce qui explique à la fois sa fluidité et ses erreurs possibles.

Local vs Cloud

Vocabulaire minimum

Installation

Ollama est disponible sur Windows, macOS et Linux. Une fois installé, il tourne en arrière-plan comme un petit serveur local (port 11434) : c’est ce service que toutes les interfaces (CLI, applications, scripts) viennent interroger.

Windows

Deux méthodes sur ollama.com : télécharger et exécuter le setup classique, ou utiliser directement la ligne PowerShell fournie sur le site (télécharge puis installe en une seule fois).

macOS et Linux

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

Vérifier l’installation

ollama --version

Choisir et télécharger un modèle

Le catalogue de modèles est consultable sur ollama.com/library : Llama 3.1/3.3 (Meta), Gemma 2/3 (Google), Mistral, Qwen, Phi (Microsoft), DeepSeek, GPT-OSS (le modèle à poids ouvert d’OpenAI, né d’un partenariat avec Ollama), et des modèles spécialisés (code, vision, embeddings).

Filtrer le catalogue

Choisir la bonne taille de modèle

Chaque famille propose plusieurs tailles (nombre de paramètres, ex. 270M, 1B, 4B, 12B, 27B pour Gemma 3). Plus un modèle est gros, plus il est capable, mais plus il demande de mémoire et de temps de calcul.

• Cartes compatibles les plus citées : NVIDIA RTX/GTX, certaines AMD, puces Apple Silicon (M1/M2/M3) côté Mac.
• Sans carte graphique compatible, Ollama utilise le CPU : ça fonctionne, mais c’est plus lent.
• Sur une machine ancienne, mieux vaut démarrer avec une petite variante (1B-4B) que de forcer un modèle 27B injouable.

Télécharger et lancer

ollama run llama3.1
ollama run gemma3:4b
ollama pull nomic-embed-text

Gérer ses modèles

L’application native et la ligne de commande

En installant Ollama, on installe aussi une petite application graphique native (accessible depuis le menu Démarrer sous Windows en tapant « Ollama »), en plus du moteur en ligne de commande. Les deux donnent accès aux mêmes modèles téléchargés.

L’application native

Interface de chat simple, façon ChatGPT, avec un menu de réglages : activer des modèles cloud et la recherche web, exposer Ollama sur le réseau local, choisir l’emplacement de stockage des modèles, régler la taille du contexte.

Pourquoi maîtriser la ligne de commande

• Contrôle total : choisir précisément le modèle, régler tous les paramètres.
• Automatisation : intégrer un modèle dans un script — l’interface graphique ne le permet généralement pas.
• Transparence : on voit exactement quel modèle tourne, quelle commande s’exécute, quel résultat est produit.

Maîtriser le mode interactif (CLI)

Une fois dans une session ollama run <modèle>, tout ce qui commence par un slash (/) est une commande interne à la session, pas un message envoyé au modèle.

Lancer un modèle sans rien taper

Taper simplement ollama (sans argument) ouvre un petit shell interactif qui propose de choisir un modèle à la souris ou avec les flèches du clavier, parmi ceux déjà installés.

Commandes de base

Raccourcis clavier utiles

Ajuster la session avec /set

Paramètres du modèle avec /set parameter

/set parameter temperature <float>
/set parameter num_ctx <int>
/set parameter top_k <int>
/set parameter top_p <float>
/set parameter num_predict <int>
/set parameter seed <int>
/set parameter repeat_penalty <float>
/set parameter stop <string>

• temperature : créativité de la réponse (0 = déterministe, ~1-2 = très créatif).
• seed : fixe le point de départ du hasard — utile pour comparer des réglages toutes choses égales par ailleurs.
• num_ctx : taille de la fenêtre de contexte (en tokens).
• top_k / top_p : réglages fins de l’échantillonnage du mot suivant.
• num_predict : nombre maximal de tokens générés.
• stop : séquence qui arrête immédiatement la génération.

Afficher les informations avec /show

/show info
/show license
/show modelfile
/show parameters
/show system
/show template

Sauvegarder un modèle personnalisé avec /save

/save ne fait pas une simple sauvegarde de session : la commande crée un véritable nouveau modèle qui intègre le message système, les paramètres et le contexte de la conversation en cours. Ce modèle apparaît ensuite dans ollama list, à la même taille que le modèle de base, et il est visible depuis l’application graphique.

/set system "Tu es un assistant sarcastique."
/save mon-assistant
ollama run mon-assistant

Bien prompter au quotidien

La formule d’un bon prompt

Instruction + Sujet + Contexte + Contrainte + Format.

Les trois rôles d’un échange

• Message système : fixe le cadre général (ton, niveau de langage) — défini une fois pour toute la conversation.
• Message utilisateur : exprime la demande précise du moment.
• Contexte : informations utiles pour adapter la réponse.

Itérer pour améliorer une réponse

Il ne faut pas s’attendre à une réponse parfaite dès la première tentative : on part d’une première version, puis on demande une correction, une simplification, un changement de ton.

Limites et hallucinations

Une hallucination est une information inventée ou inexacte, présentée avec la même assurance qu’une information vraie — le modèle ne signale pas qu’il se trompe.

• Relire systématiquement dates, chiffres, noms et références.
• Pour un enjeu réel (professionnel, médical, juridique), vérifier avec des sources fiables.
• Considérer le LLM comme un assistant, pas une autorité.

Personnaliser un modèle avec le Modelfile

Le Modelfile est un fichier texte de configuration qui permet de créer, à partir d’un modèle existant, une version personnalisée : comportement par défaut, réglages fixés, prête à être réutilisée sous un nom propre.

Structure minimale

Créer un modèle personnalisé

Fichier texte sans extension, par exemple nommé model-file :

FROM gemma3:4b
SYSTEM """
Tu es un assistant pédagogique technique francophone.
Tu réponds toujours en français avec exactement cette structure :
une définition en une à deux phrases, un exemple concret, une phrase à retenir.
Ton professionnel : pas de blabla, pas d'humour, pas d'emoji.
"""
PARAMETER temperature 0.5

ollama create gemma3-formateur -f model-file
ollama run gemma3-formateur

Guider le style avec MESSAGE

MESSAGE insère des exemples d’échanges user/assistant fictifs dans le Modelfile. Un LLM fonctionne beaucoup par imitation de contexte : en lui montrant des réponses structurées d’une certaine façon, il reproduit naturellement ce modèle.

MESSAGE user "Capitale de la France ?"
MESSAGE assistant "Paris."
MESSAGE user "2 plus 2 ?"
MESSAGE assistant "4."

TEMPLATE (avancé)

SYSTEM modifie le contenu des consignes ; TEMPLATE modifie la façon dont ces consignes et la question sont injectées dans le prompt final. Plus puissant mais plus délicat — dans la grande majorité des cas, SYSTEM suffit largement.

Créer un modèle depuis un fichier GGUF

GGUF est le format utilisé pour distribuer des poids de modèles quantifiés, qu’on trouve en nombre sur Hugging Face.

1. Chercher un modèle au format GGUF sur Hugging Face.
2. Choisir la variante quantifiée (plus légère) ou complète (plus fidèle, plus lourde).
3. Télécharger le fichier .gguf.
4. Créer un Modelfile pointant vers ce fichier : FROM ./mon-modele.gguf
5. ollama create mon-modele -f model-file

Types de modèles et leurs limites réelles

Modèles texte

• Bons pour : rédiger/répondre à un mail professionnel en gardant les informations exactes fournies, corriger et reformuler.
• Faibles pour : résumer un long texte contenant des chiffres (risque de mal recalculer une somme), et la traduction (risque de contresens complet sur une expression).

Modèles vision (ex. LLaVA)

• Bons pour : décrire une image de façon générale.
• Faibles pour : compter précisément des objets, lire du texte dans une image (OCR — risque d’inventer des informations plausibles mais fausses plutôt que d’admettre ne pas savoir lire), lire un graphique avec précision.

Modèles code (ex. DeepSeek-Coder-V2, Qwen2.5-Coder)

• Bons pour : générer du SQL ou du Python à partir d’un énoncé précis, expliquer un code complexe, diagnostiquer correctement la cause d’une erreur.

Modèles embeddings

Convertissent un texte en vecteur numérique pour la recherche sémantique — brique indispensable du RAG. Le modèle nomic-embed-text (léger, ~274 Mo) est une référence courante.

Modèles tool calling

Certains modèles (Llama 3.1, Qwen2.5…) savent identifier qu’ils doivent appeler un outil externe et avec quels paramètres — c’est la base des agents.

Au-delà de l’application native et de la ligne de commande, plusieurs outils tiers se branchent sur le serveur local d’Ollama pour offrir une expérience plus riche.

Open WebUI

L’interface la plus complète : chat façon ChatGPT, historique, gestion multi-utilisateurs, upload de documents et de pages web pour discuter avec leur contenu (RAG intégré sans code), thèmes, mode vocal, et prise en charge d’outils/agents.

Installation sous Windows (via Docker Desktop)

L’installation directe via pip pose souvent des problèmes de dépendances — la méthode recommandée passe par Docker Desktop, qui a besoin de WSL2 (le sous-système Linux de Windows) pour fonctionner.

1. Activer deux fonctionnalités Windows : « Sous-système Windows pour Linux » et « Plateforme de machine virtuelle », puis redémarrer.
2. Dans PowerShell : wsl --status, puis si besoin wsl --install --no-distribution et wsl --update.
3. Installer Docker Desktop, le lancer, vérifier qu’un conteneur tourne bien.
4. Lancer le conteneur Open WebUI, vérifier avec docker ps.
5. Ouvrir http://localhost:3000, créer le compte administrateur (le premier compte créé).

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

Fonctionnalités notables

• Réglages > Connexions : ajouter une clé API OpenAI pour aussi accéder aux modèles ChatGPT depuis la même interface.
• Réglages > Modèles : télécharger, supprimer ou créer un modèle personnalisé depuis un formulaire graphique — équivalent visuel du Modelfile.
• Espace de travail > Prompts : créer des modèles de prompt réutilisables avec variables, déclenchables par une commande slash dans le chat.
• Dans le chat, taper # permet de référencer un document importé ou une page web pour poser une question basée sur son contenu — RAG instantané sans code.

Msty

Client de bureau (Windows/Mac/Linux/mobile) qui se connecte à Ollama via son endpoint local (http://localhost:11434) : espaces de travail façon « projets », gestion de prompts, gestionnaire de pièces jointes, base de connaissances (RAG). Fonctionnalité notable : les « divisions » permettent d’afficher deux modèles côte à côte et de comparer leurs réponses à la même question en temps réel. Version gratuite complète pour l’usage local.

VS Code + extension Continue

L’extension Continue transforme Ollama en assistant de code intégré à l’éditeur — équivalent local et gratuit de Copilot.

1. Installer l’extension « Continue – Open Source AI Code Agent » depuis le panneau Extensions de VS Code.
2. Choisir le provider « Local » (Ollama est détecté automatiquement s’il tourne).
3. Télécharger 3 modèles : un modèle de chat (ex. llama3.1:8b), un modèle d’autocomplétion, et un modèle d’embedding (RAG sur le code).
4. Cliquer sur Connect une fois les indicateurs au vert.

AnythingLLM — assistant documentaire (RAG sans code)

Application dédiée au RAG clé en main : on y importe des documents (PDF, texte, site web), l’outil gère automatiquement le découpage, la vectorisation et la recherche, puis connecte le tout à un modèle Ollama pour répondre aux questions en se basant uniquement sur les documents fournis.

1. Installer AnythingLLM et le connecter à Ollama comme fournisseur de LLM (et à un modèle d’embedding, ex. nomic-embed-text).
2. Créer un espace de travail dédié.
3. Importer les documents de référence.
4. Poser des questions dans le chat : l’outil retrouve automatiquement les passages pertinents et les transmet au modèle.

C’est l’option la plus rapide pour un premier assistant documentaire personnel, sans écrire de code.

Utiliser Ollama avec Python

python -m venv .venv
source .venv/bin/activate      # macOS/Linux
pip install ollama openai langchain langchain-ollama langchain-community chromadb

La librairie officielle ollama

Deux façons d’obtenir une réponse : generate (simple complétion, sans rôles) et chat (gère une liste de messages avec les rôles system/user/assistant).

import ollama

response = ollama.chat(
    model="llama3.1",
    messages=[
        {"role": "system", "content": "Tu es un assistant concis."},
        {"role": "user", "content": "Explique la RAM en une phrase."},
    ],
)
print(response["message"]["content"])

Piloter Ollama comme en ligne de commande :

ollama.pull("llama3.1")
ollama.create(model="jarvis", from_="llama3.1", system="Tu es Jarvis.")
ollama.delete("jarvis")

Compatibilité avec l’API OpenAI

Ollama expose une API compatible avec le format OpenAI : tout code déjà écrit pour l’API OpenAI peut pointer vers Ollama en local en changeant simplement l’URL de base.

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # valeur arbitraire, non vérifiée
)

response = client.chat.completions.create(
    model="llama3.1",
    messages=[{"role": "user", "content": "Bonjour !"}],
)
print(response.choices[0].message.content)

Ollama avec LangChain

LangChain simplifie la construction d’applications autour des LLM : remplacer facilement le modèle utilisé, et ajouter facilement des fonctionnalités avancées (mémoire, RAG, agents).

Le schéma LCEL : template → modèle → parseur

from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama
from langchain_core.output_parsers import StrOutputParser

chat_template = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant utile qui donne une definition en une ligne."),
    ("human", "{word} est le mot."),
])

llm = ChatOllama(model="llama3.1")
chain = chat_template | llm | StrOutputParser()

reponse = chain.invoke({"word": "sesquipedalien"})
print(reponse)

Construire une application RAG

RAG (Retrieval-Augmented Generation) consiste à donner au modèle, au moment de répondre, des extraits de documents pertinents plutôt que de compter uniquement sur ses connaissances internes.

Le pipeline RAG en 5 étapes

1. Charger le document avec un loader adapté.
2. Découper le document en chunks, avec un léger chevauchement entre chunks consécutifs.
3. Convertir chaque chunk en embedding (vecteur numérique).
4. Stocker ces embeddings dans une base vectorielle (ex. Chroma).
5. Au moment de la question : convertir la question en embedding, retrouver les chunks les plus proches, transmettre chunks + question au modèle.

from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_ollama import OllamaEmbeddings, ChatOllama
from langchain_chroma import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

raw_documents = TextLoader("mon_document.txt").load()
splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
documents = splitter.split_documents(raw_documents)

embeddings = OllamaEmbeddings(model="nomic-embed-text")
db = Chroma.from_documents(documents, embedding=embeddings)
retriever = db.as_retriever()

prompt = ChatPromptTemplate.from_template(
    "Reponds a la question en te basant uniquement sur le contexte suivant.\n\n"
    "Contexte : {context}\n\nQuestion : {question}"
)

def format_docs(docs):
    return "\n\n".join(d.page_content for d in docs)

model = ChatOllama(model="llama3.1")

chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)

reponse = chain.invoke("Qu'est-ce que le text embedding ?")
print(reponse)

Pour un premier assistant documentaire sans écrire de pipeline Python, AnythingLLM ou le RAG intégré d’Open WebUI (raccourci #) reproduisent ce même principe via une interface graphique.

Outils (tools) et agents

Un agent est un modèle à qui l’on donne accès à des outils externes et la capacité de décider lui-même quel outil utiliser, quand, et avec quels paramètres, avant de formuler sa réponse finale.

1. L’utilisateur pose une question.
2. Le modèle décide s’il doit appeler un outil, et lequel.
3. L’outil est exécuté et son résultat est renvoyé au modèle.
4. Le modèle formule la réponse finale.

from langchain_community.tools import DuckDuckGoSearchRun
from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama

search = DuckDuckGoSearchRun(name="search")
wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
tools = [search, wikipedia]

prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant utile. Utilise DuckDuckGo ou Wikipedia si necessaire."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

llm = ChatOllama(model="llama3.1")
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

resultat = agent_executor.invoke({"input": "Comment utilise-t-on Ollama en local ?"})
print(resultat["output"])

Aller plus loin

Nouveautés récentes (2025)

• Ollama Turbo : un service d’inférence cloud pour les modèles trop gros pour tourner localement, avec la même interface.
• Secure Minions : un modèle local peut collaborer avec un modèle cloud de façon chiffrée de bout en bout.
• Support GPU AMD en préversion, en plus de NVIDIA et Apple Silicon.
• Catalogue élargi à plus de 100 modèles pré-entraînés.

Points de vigilance

• Dimensionnement matériel : RAM/VRAM conditionnent la taille des modèles utilisables confortablement.
• Confidentialité : dès qu’on branche des outils ou une interface multi-utilisateurs, vérifier ce qui part à l’extérieur.
• Fiabilité selon la taille du modèle : les limites vues plus haut sont plus marquées sur les petits modèles.
• Garder un contrôle humain sur les réponses utilisées dans un contexte sensible.

Ressources

• ollama.com/library — catalogue de modèles
• ollama.com/docs — API et Modelfile
• python.langchain.com — documentation LangChain
• openwebui.com, useanything.com (AnythingLLM)