Ollama Multi-Modell-Zusammenarbeit und Agenten-Workflow

Ein einzelnes Modell muss nicht alles erledigen: Lassen Sie kleine Modelle das Routing übernehmen, spezialisierte Modelle die Aufgaben und verbundene Modelle die Informationssuche. Verwenden Sie strukturierte Ausgabe als Scheduling-Protokoll, um schnelle und kosteneffiziente intelligente Anwendungen zu kombinieren.

Dieses Kapitel implementiert ein Multi-Modell-Routing-System und erweitert es zu einem Agent-Workflow mit Internetzugriffsfähigkeit.


Architektur-Design: Routing kleiner Modelle + Expertenausführung

Die Kernidee ist Arbeitsteilung: Die Bestimmung dessen, "was der Benutzer tun möchte", ist einfach und kann vom kleinsten Modell übernommen werden; die eigentlichen Aufgaben werden dann an die geeigneten spezialisierten Modelle weitergegeben.

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

Dieses Design hat drei Vorteile: Das Routing kleiner Modelle dauert nur einige zehn Millisekunden, sodass große Modelle keine Anfragen mit geringem Wert mehr bearbeiten; die Parameter jedes Expertenmodells können nach Bedarf unabhängig angepasst werden; neue Aufgabentypen erfordern nur das Hinzufügen eines Zweigs, ohne bestehende Ketten zu beeinflussen.


Implementierung 1: Strukturierte Ausgabe für Intent-Routing

Der Schlüssel zum Routing besteht darin, Klassifizierungsergebnisse "maschinenlesbar" zu machen; strukturierte Ausgabe dient hier als Scheduling-Protokoll.

Beispiel

# Dateipfad: router.py
from ollama import chat
from pydantic import BaseModel, Field

# Strukturierte Definition der Routing-Ergebnisse
class Route(BaseModel):
    category: str = Field(description=Fragekategorie: Chat / Programmierung / Suche)
    reason: str = Field(description=Klassifizierungsgrundlage in einem Satz)

def classify(question: str) -> Route:
    response = chat(
        model='qwen3.5:4b',          # Ein kleines Modell reicht für das Routing aus
        messages=[{'role': 'user', 'content': question}],
        format=Route.model_json_schema(),
        options={'temperature': 0},   # Klassifizierung muss stabil sein
    )
    return Route.model_validate_json(response.message.content)

# Schneller Selbsttest
for q in ['Wie dedupliziert man eine Python-Liste?', 'Welche KI-Nachrichten gibt es heute?', 'Erzähl einen Witz']:
    r = classify(q)
    print(r.category, '|', r.reason)
$ python router.py
coding | 询问 Python 列表去重的编程方法
search | 询问当天的最新新闻,需要联网
chat   | 闲聊类请求,直接回答即可

Implementierung 2: Drei Experten-Prozessoren

Eine Prozessorfunktion pro Pfad, mit einer einheitlichen Signatur für einfaches Dispatching.

Beispiel

# An router.py anhängen
from ollama import chat, web_search, web_fetch

def handle_chat(question):
    """Tägliche Q&A: direkt vom kleinen Modell beantwortet"""
    r = chat(model='qwen3.5:4b',
             messages=[{'role': 'user', 'content': question}])
    return r.message.content

def handle_coding(question):
    """Programmieraufgaben: an ein dediziertes Code-Modell übergeben"""
    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):
    """Web-bezogene Aufgaben: Agenten-Schleife eines kleinen Modells + Suchwerkzeug"""
    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)
            # Tool-Ergebnisse kürzen, um das Kontextfenster zu schützen
            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)

Der Router selbst generiert keine Antworten, daher ist sein Halluzinationsrisiko auf "Fehlklassifikation" beschränkt; die Kosten einer Fehlklassifikation sind nur eine zusätzliche Korrektur und verunreinigen die endgültige Antwort nicht.


Implementierung 3: Lokale und Cloud-Hybrid-Orchestrierung

Jeder Pfad kann eine "Cloud-Upgrade-Stufe" haben: Für Aufgaben, die lokale Modelle nicht bewältigen können, ändern Sie einfach den Modellnamen in derselben Codestruktur.

Beispiel

# An router.py anhängen
def ask_with_fallback(question, force_cloud=False):
    """Planung mit Cloud-Fallback: zuerst lokal, komplexe Aufgaben werden in die Cloud hochgestuft"""
    route = classify(question).category

    if force_cloud or route == 'coding':
        # Schwere Aufgaben wie Coding gehen direkt an Cloud-Flaggschiff-Spezifikationen
        model = 'qwen3.5:cloud'
    else:
        model = 'qwen3.5:4b'

    print(f'[Route -> {route}] Verwende Modell {model}')
    r = chat(model=model,
             messages=[{'role': 'user', 'content': question}])
    return r.message.content

Beachten Sie einen Fähigkeitsunterschied: Cloud-Modelle unterstützen noch keine strukturierte Ausgabe, daher muss der Router von einem lokalen Modell verarbeitet werden, was perfekt zum Design "kleines Modell für das Routing" passt.


Umfassende Bewertung von Kosten und Latenz

Der Kosten-Nutzen-Vorteil einer Multi-Modell-Strategie muss gleichzeitig anhand von drei Dimensionen berechnet werden:

DimensionLokales kleines ModellLokales großes ModellCloud-Modell
Zeit bis zum ersten TokenNiedrigste (Ladezeit im Millisekundenbereich)MittelBeinhaltet Netzwerk-Roundtrip
GrenzkostenUngefähr StromkostenStrom + VRAM-NutzungNutzungsbasierte Abrechnung
AntwortqualitätAusreichend für einfache AufgabenNahe am FlaggschiffFlaggschiff-Klasse
ParallelitätsfähigkeitDurch den lokalen Rechner begrenztDurch VRAM begrenztBeste Elastizität

Dies ergibt eine praktische Basisstrategie: lokale kleine Modelle als Grundlage für Routing und leichte Aufgaben verwenden; qualitätskritische Aufgaben lokalen großen Modellen zuweisen; Aufgaben mit hoher Last oder übermäßiger Größe in die Cloud verlagern; die Modellnamen aller drei Kategorien werden über die Konfigurationsdatei verwaltet und können jederzeit anhand von Abkündigungen oder Hardwareänderungen angepasst werden.

Andere Erweiterungen