Intégrer Ollama avec Python : exemples d'API REST et de client Python

+ Exemples concrets utilisant des LLM de réflexion

Sommaire

Dans cet article, nous allons explorer deux façons de connecter votre application Python à Ollama : 1. Via HTTP REST API ; 2. Via la bibliothèque Python officielle d’Ollama.

Nous aborderons à la fois les appels chat et generate, puis nous discuterons de la manière d’utiliser efficacement les “modèles de réflexion”.

ollama et python

Ollama a rapidement devenu l’une des manières les plus pratiques d’exécuter des modèles de langage de grande envergure (LLMs) localement. Avec son interface simple et son support des modèles ouverts populaires comme Llama 3, Mistral, Qwen2.5, ainsi que des variantes “réflexion” comme qwen3, il est facile d’intégrer directement des capacités d’IA dans vos projets Python — sans dépendre d’API cloud externes.

🧩 Prérequis

Avant de commencer, assurez-vous d’avoir :

  • Ollama installé et en cours d’exécution localement (ollama serve)
  • Python 3.9+
  • Dépendances nécessaires :
pip install requests ollama

Vérifiez que Ollama est en cours d’exécution en exécutant :

ollama list

Vous devriez voir des modèles disponibles tels que llama3, mistral ou qwen3.

⚙️ Option 1 : Utilisation de l’API REST d’Ollama

L’API REST est idéale lorsque vous souhaitez un contrôle maximum ou lors de l’intégration avec des cadres qui gèrent déjà les requêtes HTTP.

Exemple 1 : API Chat

import requests
import json

url = "http://localhost:11434/api/chat"

payload = {
    "model": "llama3.1",
    "messages": [
        {"role": "system", "content": "Vous êtes un assistant Python."},
        {"role": "user", "content": "Écrivez une fonction qui inverse une chaîne."}
    ]
}

response = requests.post(url, json=payload, stream=True)

for line in response.iter_lines():
    if line:
        data = json.loads(line)
        print(data.get("message", {}).get("content", ""), end="")

👉 L’API REST d’Ollama transmet les réponses ligne par ligne (similaire à l’API de streaming d’OpenAI). Vous pouvez accumuler le contenu ou l’afficher en temps réel pour les chatbots ou les outils CLI.

Exemple 2 : API Generate

Si vous n’avez pas besoin de contexte de chat ou de rôles, utilisez le point de terminaison plus simple /api/generate :

import requests

url = "http://localhost:11434/api/generate"
payload = {
    "model": "llama3.1",
    "prompt": "Expliquez la récursivité en une phrase."
}

response = requests.post(url, json=payload, stream=True)
for line in response.iter_lines():
    if line:
        print(line.decode("utf-8"))

Ce point de terminaison est idéal pour les tâches de génération de texte en une seule étape — résumés, extraits de code, etc.

🐍 Option 2 : Utilisation de la bibliothèque Python d’Ollama

La bibliothèque Python d’Ollama offre une interface plus propre aux développeurs qui préfèrent rester entièrement en Python.

Exemple 1 : API Chat

import ollama

response = ollama.chat(
    model="llama3.1",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant de code."},
        {"role": "user", "content": "Générez un script Python qui liste tous les fichiers d'un répertoire."}
    ]
)

print(response['message']['content'])

Cela renvoie le message final sous forme de dictionnaire. Si vous souhaitez un streaming, vous pouvez itérer sur le flux de chat :

stream = ollama.chat(
    model="llama3.1",
    messages=[
        {"role": "user", "content": "Écrivez un haïku sur la récursivité."}
    ],
    stream=True
)

for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

Exemple 2 : API Generate

import ollama

output = ollama.generate(
    model="llama3.1",
    prompt="Résumez le concept des décorateurs en Python."
)

print(output['response'])

Ou faites un streaming du résultat :

stream = ollama.generate(
    model="llama3.1",
    prompt="Listez trois avantages d'utiliser Python pour les projets d'IA.",
    stream=True
)

for chunk in stream:
    print(chunk['response'], end='', flush=True)

🧠 Travail avec les modèles “Thinking”

Ollama prend en charge les “modèles de réflexion” tels que qwen3, conçus pour afficher leurs étapes de raisonnement intermédiaires. Ces modèles produisent une sortie structurée, souvent dans un format comme :

</think>

Étapes de raisonnement ici.

Cela les rend utiles pour :

  • Déboguer le raisonnement du modèle
  • Recherche sur l’interprétabilité
  • Construire des outils qui séparent la pensée de la sortie

Exemple : Utilisation d’un modèle de réflexion

import ollama

response = ollama.chat(
    model="qwen3",
    messages=[
        {"role": "user", "content": "Quelle est la capitale de l'Australie ?"}
    ]
)

content = response['message']['content']

# Extraction optionnelle de la partie "thinking"
import re
thinking = re.findall(r"</think>

  Étapes de raisonnement ici...

Quand utiliser les modèles de réflexion

Cas d’utilisation Modèle recommandé Pourquoi
Interprétabilité / Débogage qwen3 Afficher les traces de raisonnement
Applications sensibles à la performance qwen3 mode non-réfléchissant Plus rapide, moins verbeux
Éducatif / Explicatif qwen3 Affiche la logique étape par étape

✅ Résumé

Tâche API REST Client Python
Génération de texte simple /api/generate ollama.generate()
Chat conversationnel /api/chat ollama.chat()
Support de streaming Oui Oui
Fonctionne avec les modèles de réflexion Oui Oui

Ollama’s design local-first le rend idéal pour les applications d’IA sécurisées, hors ligne ou sensibles à la confidentialité. Que vous construisez un chatbot interactif ou un service d’enrichissement de données en arrière-plan, vous pouvez intégrer les LLMs de manière fluide dans votre flux de travail Python — avec un contrôle total sur les modèles, la latence et les données.

Liens utiles