Collaboration multi-modèles et flux de travail d'agents avec Ollama

Un seul modèle n'a pas à tout faire : laissez les petits modèles gérer le routage, les modèles spécialisés gérer les tâches, et les modèles connectés rechercher des informations. Utilisez la sortie structurée comme protocole d'ordonnancement pour combiner des applications intelligentes rapides et économiques.

Ce chapitre implémente un système de routage multi-modèles et le transforme en workflow d'Agent avec capacité d'accès à Internet.


Conception de l'architecture : routage par petit modèle + exécution experte

L'idée centrale est la division du travail : déterminer « ce que l'utilisateur veut faire » est simple et peut être géré par le plus petit modèle ; les tâches réelles sont ensuite transmises aux modèles spécialisés appropriés.

多模型路由架构:路由器分类,三个专家模型执行

Cette conception présente trois avantages : le routage par petit modèle ne prend que quelques dizaines de millisecondes, donc les grands modèles ne traitent plus les requêtes à faible valeur ; les paramètres de chaque modèle expert peuvent être ajustés indépendamment selon les besoins ; les nouveaux types de tâches nécessitent seulement l'ajout d'une branche sans affecter les chaînes existantes.


Implémentation 1 : sortie structurée pour le routage d'intention

La clé du routage est de rendre les résultats de classification « lisibles par machine » ; la sortie structurée sert ici de protocole d'ordonnancement.

Exemple

# Chemin du fichier : router.py
from ollama import chat
from pydantic import BaseModel, Field

# Définition structurée des résultats de routage
class Route(BaseModel):
    category: str = Field(description=Catégorie de la question : chat / coding / search)
    reason: str = Field(description=Base de classification en une phrase)

def classify(question: str) -> Route:
    response = chat(
        model='qwen3.5:4b',          # Un petit modèle suffit pour le routage
        messages=[{'role': 'user', 'content': question}],
        format=Route.model_json_schema(),
        options={'temperature': 0},   # La classification doit être stable
    )
    return Route.model_validate_json(response.message.content)

# Auto-test rapide
for q in ['Comment dédupliquer une liste Python ?', 'Quelles actualités IA y a-t-il aujourd'hui ?', 'Raconte une blague']:
    r = classify(q)
    print(r.category, '|', r.reason)
$ python router.py
coding | 询问 Python 列表去重的编程方法
search | 询问当天的最新新闻,需要联网
chat   | 闲聊类请求,直接回答即可

Implémentation 2 : Trois processeurs experts

Une fonction de traitement par chemin, avec une signature unifiée pour faciliter la répartition.

Exemple

# Ajouter à router.py
from ollama import chat, web_search, web_fetch

def handle_chat(question):
    """Q&R quotidiennes : répondues directement par le petit modèle"""
    r = chat(model='qwen3.5:4b',
             messages=[{'role': 'user', 'content': question}])
    return r.message.content

def handle_coding(question):
    """Tâches de programmation : confiées à un modèle de code dédié"""
    r = chat(model='example-coder',
             messages=[{'role': 'user', 'content': question}],
             options={'temperature': 0.2, 'num_ctx': 65536})
    return r.message.content

def handle_search(question):
    """Tâches liées au Web : boucle d'agent de petit modèle + outil de recherche"""
    tools = {'web_search': web_search, 'web_fetch': web_fetch}
    messages = [{'role': 'user', 'content': question}]
    while True:
        r = chat(model='qwen3.5:4b', messages=messages,
                 tools=[web_search, web_fetch])
        messages.append(r.message)
        if not r.message.tool_calls:
            return r.message.content
        for call in r.message.tool_calls:
            func = tools.get(call.function.name)
            # Tronquer les résultats des outils pour protéger la fenêtre de contexte
            result = str(func(**call.function.arguments))[:2000]
            messages.append({'role': 'tool',
                             'tool_name': call.function.name,
                             'content': result})

HANDLERS = {'chat': handle_chat,
            'coding': handle_coding,
            'search': handle_search}

def ask(question):
    route = classify(question)
    print(f'[Route -> {route.category}] {route.reason}')
    return HANDLERS[route.category](question)

Le routeur lui-même ne génère pas de réponses, donc son risque d'hallucination est limité à une « mauvaise classification » ; le coût d'une mauvaise classification n'est qu'une correction supplémentaire et ne pollue pas la réponse finale.


Implémentation 3 : Orchestration hybride locale et cloud

Chaque chemin peut avoir un « palier de mise à niveau cloud » : pour les tâches que les modèles locaux ne peuvent pas gérer, il suffit de changer le nom du modèle dans la même structure de code.

Exemple

# Ajouter à router.py
def ask_with_fallback(question, force_cloud=False):
    """Planification avec repli vers le cloud : local d'abord, les tâches complexes sont transférées vers le cloud"""
    route = classify(question).category

    if force_cloud or route == 'coding':
        # Les tâches lourdes telles que le codage passent directement aux spécifications phares du cloud
        model = 'qwen3.5:cloud'
    else:
        model = 'qwen3.5:4b'

    print(f'[Route -> {route}] Utilisation du modèle {model}')
    r = chat(model=model,
             messages=[{'role': 'user', 'content': question}])
    return r.message.content

Notez une différence de capacité : les modèles cloud ne prennent pas encore en charge la sortie structurée, donc le routeur doit être géré par un modèle local, ce qui correspond parfaitement à la conception « petit modèle pour le routage ».


Évaluation complète des coûts et de la latence

Le rapport coût-bénéfice d'une stratégie multi-modèles doit être calculé simultanément selon trois dimensions :

DimensionPetit modèle localGrand modèle localModèle cloud
Temps jusqu'au premier tokenLe plus faible (chargement en millisecondes)MoyenneInclut un aller-retour réseau
Coût marginalEnviron le coût de l'électricitéÉlectricité + utilisation de la VRAMFacturé à l'usage
Qualité des réponsesSuffisant pour des tâches simplesProche du haut de gammeNiveau haut de gamme
Capacité de concurrenceLimité par la machine localeLimité par la VRAMMeilleure élasticité

Cela donne une stratégie de base pratique : utiliser des petits modèles locaux comme fondation pour le routage et les tâches légères ; confier les tâches sensibles à la qualité à des modèles locaux de grande taille ; basculer les tâches à forte charge ou surdimensionnées vers le cloud ; les noms de modèles des trois catégories passent par le fichier de configuration et peuvent être ajustés à tout moment en fonction des annonces de retrait ou des changements matériels.

Autres extensions