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
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
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
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:
| Dimension | Lokales kleines Modell | Lokales großes Modell | Cloud-Modell |
|---|---|---|---|
| Zeit bis zum ersten Token | Niedrigste (Ladezeit im Millisekundenbereich) | Mittel | Beinhaltet Netzwerk-Roundtrip |
| Grenzkosten | Ungefähr Stromkosten | Strom + VRAM-Nutzung | Nutzungsbasierte Abrechnung |
| Antwortqualität | Ausreichend für einfache Aufgaben | Nahe am Flaggschiff | Flaggschiff-Klasse |
| Parallelitätsfähigkeit | Durch den lokalen Rechner begrenzt | Durch VRAM begrenzt | Beste 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