Six capacités des modèles Ollama en pratique
La sortie en streaming, le mode réflexion, la sortie structurée, la compréhension visuelle, les embeddings vectoriels, l'appel d'outils, ainsi que la recherche web, forment le panorama complet des capacités des modèles d'Ollama.
Ce chapitre utilise la bibliothèque Python officielle pour mettre en pratique chaque capacité une par une ; tous les exemples peuvent être exécutés directement.
Tout d'abord, nous devons installer le SDK Python d'Ollama.
Vous pouvez l'installer avec pip :
pip install ollama
Assurez-vous que Python 3.x est installé dans votre environnement, et que votre réseau peut accéder au service Ollama local.
Avant d'utiliser le SDK Python, assurez-vous que le service Ollama local est en cours d'exécution.
Vous pouvez le démarrer à l'aide de l'outil en ligne de commande :
ollama serve
Une fois le service local en cours d'exécution, le SDK Python communiquera avec lui pour effectuer l'inférence de modèle et d'autres tâches.
Capacité 1 : Sortie en streaming
Le streaming fait apparaître la réponse mot par mot sur l'interface ; c'est la base de l'expérience de l'application de chat.
Dans le SDK, définissez stream sur True, puis parcourez chaque chunk :
Exemple
# Activer le streaming, recevoir les réponses chunk par chunk
stream = chat(
model='qwen3.5',
messages=[{'role': 'user', 'content': 'Présentez Python Tutorial en trois phrases'}],
stream=True,
)
# Afficher chunk par chunk tout en concaténant le contenu complet
content = ''
for chunk in stream:
print(chunk.message.content, end='', flush=True)
content += chunk.message.content
# Le contenu concaténé peut être utilisé pour sauvegarder l'historique ou archiver vers le stockage
Point clé : chaque chunk de streaming n'est qu'un « fragment » ; vous devez accumuler vous-même le contenu complet côté client. Lorsque vous ajouterez plus tard la réponse de ce tour à l'historique de conversation, utilisez le texte complet concaténé.
Capacité 2 : Mode de réflexion
Les modèles de raisonnement produisent d'abord un processus de réflexion avant de donner la réponse. Dans le SDK, cela est contrôlé via le paramètre think, et la réflexion et le texte du corps appartiennent à deux champs distincts.
Exemple
response = chat(
model='qwen3.5',
messages=[{'role': 'user', 'content': 'Quel est le plus grand, 9.9 ou 9.11 ?'}],
think=True,
stream=False,
)
# Le processus de réflexion et la réponse finale appartiennent à deux champs distincts
print('Thinking:', response.message.thinking)
print('Answer:', response.message.content)
Dans les scénarios de streaming, la réflexion et le contenu apparaissent alternativement dans les chunks ; utilisez une machine à états pour changer de zone de rendu :
Exemple
stream = chat(
model='qwen3.5',
messages=[{'role': 'user', 'content': 'Combien font 17 fois 23 ?'}],
think=True,
stream=True,
)
in_thinking = False
for chunk in stream:
if chunk.message.thinking:
if not in_thinking:
in_thinking = True
print('[Réflexion]', end='', flush=True)
print(chunk.message.thinking, end='', flush=True)
elif chunk.message.content:
if in_thinking:
in_thinking = False
print('\n'[Réponse]', end='', flush=True)
print(chunk.message.content, end='', flush=True)
Suggestion d'implémentation d'interface utilisateur : afficher la réflexion comme une zone grise repliable, afficher le contenu comme texte principal ; la série gpt-oss n'accepte que trois niveaux d'effort de réflexion — low / medium / high — passer une valeur booléenne est invalide.
Capacité 3 : Sortie structurée
La sortie structurée permet au modèle de renvoyer des données qui se conforment strictement à un JSON Schema ; combinée à la validation Pydantic, c'est la manière standard pour les programmes de consommer la sortie du modèle.
Exemple
from pydantic import BaseModel
# Définir la structure de données attendue avec Pydantic
class Site(BaseModel):
name: str
category: str
free: bool
response = chat(
model='qwen3.5',
messages=[{'role': 'user', 'content': 'Présentez le tutoriel Python'}],
format=Site.model_json_schema(),
)
# Le contenu renvoyé est une chaîne JSON conforme au schéma ; validez-la et analysez-la directement
site = Site.model_validate_json(response.message.content)
print(site.name, site.category, site.free)
Ce schéma est la pierre angulaire de toutes les applications d'extraction de données : l'extraction de champs à partir de CV, la récupération d'informations clés à partir de tickets, et l'extraction d'informations à partir d'images (combinée aux capacités de vision) l'utilisent toutes.
Deux conseils de stabilité : réglez la température dans les options à 0 ; décrivez aussi la signification des champs dans le prompt, ce qui fournit une double contrainte avec le schéma.
Capacité 4 : Compréhension visuelle
Les modèles multimodaux (tels que qwen3.5) peuvent accepter des images. Le SDK prend en charge le passage direct de chemins de fichiers, ce qui est bien plus pratique que l'encodage base64 dans l'API REST.
Exemple
response = chat(
model='qwen3.5',
messages=[{
'role': 'user',
'content': 'Quelle page est cette capture d'écran ? Listez les principales fonctionnalités.',
'images': ['screenshot.png'],
}],
)
print(response.message.content)
La combinaison de la vision avec une sortie structurée permet "image-to-data" :
Exemple
from pydantic import BaseModel
# Définir la structure cible à extraire de l'image
class Receipt(BaseModel):
merchant: str
total: float
date: str
response = chat(
model='qwen3.5',
messages=[{
'role': 'user',
'content': 'Extrayez le commerçant, le montant et la date de cette photo de reçu',
'images': ['receipt.jpg'],
}],
format=Receipt.model_json_schema(),
options={'temperature': 0},
)
print(Receipt.model_validate_json(response.message.content))
Capacité 5 : Embeddings vectoriels
L'interface embed produit des vecteurs de texte par lots ; combinée à la similarité cosinus, elle peut implémenter une recherche sémantique minimale viable.
Exemple
# Générer des vecteurs de documents par lots
docs = [
'Python est un langage interprété',
'JavaScript s'exécute principalement dans le navigateur',
'EXAMPLE propose des tutoriels de programmation gratuits',
]
result = ollama.embed(model='embeddinggemma', input=docs)
vectors = result['embeddings']
print(len(vectors), len(vectors[0])) # 3 vecteurs et leurs dimensions
# Calculer la similarité cosinus entre le vecteur de requête et les vecteurs de documents pour trier et récupérer les résultats
query = ollama.embed(model='embeddinggemma', input='Est-ce que apprendre Python est difficile ?')
L'indexation et l'interrogation doivent utiliser le même modèle d'embedding ; sinon les espaces vectoriels sont incohérents et les résultats de récupération n'ont pas de sens. L'implémentation complète de la base de connaissances est couverte dans le chapitre du projet RAG.
Capacité 6 : Appel d'outils
L'appel d'outils apprend au modèle à « appeler à l'aide » : lorsqu'il détermine que des informations externes sont nécessaires, il renvoie tool_calls ; le programme exécute les fonctions réelles, et après que les résultats ont été renvoyés, le modèle résume et répond.
Regardez d'abord la séquence complète de la boucle de l'Agent pour comprendre comment les messages circulent entre les quatre parties :
Le SDK Python permet de passer des fonctions directement en tant qu'outils ; la signature de la fonction et la docstring sont automatiquement analysées dans un schéma :
Exemple
# Fonction d'outil locale : la docstring devient la description de l'outil que le modèle voit
def get_weather(city: str) -> str:
"""Interroger la température actuelle de la ville spécifiée
Arguments :
city: nom de la ville
Retourne :
Description de la température actuelle
"""
temperatures = {"Beijing": "22°C", "Shanghai": "26°C", "New York": "18°C"}
return temperatures.get(city, "Ville inconnue")
messages = [{'role': 'user', 'content': 'Quelle est la température à New York maintenant ?'}]
# Boucle d'agent : itérer jusqu'à ce que le modèle ne demande plus d'outils
while True:
response = chat(
model='qwen3.5',
messages=messages,
tools=[get_weather],
)
# Ajouter le message du modèle (y compris tool_calls) à l'historique
messages.append(response.message)
if not response.message.tool_calls:
# Plus aucune demande d'outil ; afficher la réponse finale
print(response.message.content)
break
# Contient des demandes d'outils : les exécuter et renvoyer les résultats avec le rôle tool
for call in response.message.tool_calls:
result = get_weather(**call.function.arguments)
messages.append({
'role': 'tool',
'tool_name': call.function.name,
'content': result,
})
Trois points d'ingénierie : premièrement, chaque response.message doit être ajouté tel quel à messages, et les résultats d'outils sont renvoyés avec le rôle tool ; deuxièmement, avec des appels d'outils parallèles, le modèle peut renvoyer plusieurs tool_calls à la fois — exécutez-les et ajoutez-les un par un ; troisièmement, dans de vrais projets, les résultats d'outils peuvent être très longs, alors veillez à les tronquer pour protéger la fenêtre de contexte.
Capacité 7 : Recherche Web
Ollama fournit officiellement deux interfaces web, web_search et web_fetch, qui peuvent être montées comme outils pour que le modèle réponde à de nouvelles informations au-delà de ses données d'entraînement.
Exemple
# Monter l'accès web comme outil
available_tools = {'web_search': web_search, 'web_fetch': web_fetch}
messages = [{'role': 'user', 'content': "Quelles nouvelles fonctionnalités Ollama propose-t-il récemment ?"}]
while True:
response = chat(
model='qwen3.5',
messages=messages,
tools=[web_search, web_fetch],
think=True,
)
messages.append(response.message)
if not response.message.tool_calls:
print(response.message.content)
break
for call in response.message.tool_calls:
func = available_tools.get(call.function.name)
if func:
# Les résultats d'outils peuvent être très longs ; tronquez pour protéger le contexte
result = str(func(**call.function.arguments))
messages.append({
'role': 'tool',
'tool_name': call.function.name,
'content': result[:2000],
})
Autres extensionsLes interfaces web nécessitent la création d’une clé API sur ollama.com ; les résultats de recherche peuvent facilement représenter des milliers de jetons, c’est pourquoi la recommandation officielle est de définir le contexte à 32K ou plus pour de tels scénarios d’Agent. Il existe également une implémentation prête à l’emploi de serveur MCP qui peut s’intégrer à des outils comme Cline et Codex ; voir le chapitre sur l’écosystème pour les détails d’intégration.