Ollama: Sechs Modellfähigkeiten in der Praxis

Streaming-Ausgabe, Denkmodus, strukturierte Ausgabe, visuelles Verständnis, Vektor-Embeddings, Tool-Aufruf, plus Websuche, bilden die vollständige Landschaft der Modellfähigkeiten von Ollama.

Dieses Kapitel verwendet die offizielle Python-Bibliothek, um jede Fähigkeit einzeln zu üben; alle Beispiele können direkt ausgeführt werden.

Zuerst müssen wir das Ollama Python SDK installieren.

Sie können es mit pip installieren:

pip install ollama

Stelle sicher, dass Python 3.x in deiner Umgebung installiert ist und dass dein Netzwerk auf den lokalen Ollama-Dienst zugreifen kann.

Bevor du das Python SDK verwendest, stelle sicher, dass der lokale Ollama-Dienst läuft.

Du kannst ihn mit dem Kommandozeilen-Tool starten:

ollama serve

Sobald der lokale Dienst läuft, kommuniziert das Python SDK mit ihm, um Modellinferenz und andere Aufgaben auszuführen.


Funktion 1: Streaming-Ausgabe

Streaming lässt die Antwort Wort für Wort in der Oberfläche erscheinen; es ist die Grundlage für das Nutzererlebnis von Chat-Anwendungen.

Setze im SDK stream auf True und iteriere dann über jeden Chunk:

Beispiel

from ollama import chat

# Streaming aktivieren, Antworten Chunk für Chunk empfangen
stream = chat(
    model='qwen3.5',
    messages=[{'role': 'user', 'content': 'Stelle das Python-Tutorial in drei Sätzen vor'}],
    stream=True,
)

# Chunk für Chunk ausgeben und dabei den vollständigen Inhalt zusammenfügen
content = ''
for chunk in stream:
    print(chunk.message.content, end='', flush=True)
    content += chunk.message.content

# Der zusammengefügte Inhalt kann verwendet werden, um den Verlauf zu speichern oder im Speicher zu archivieren

Wichtiger Punkt: Jeder Streaming-Chunk ist nur ein "Fragment"; du musst den vollständigen Inhalt selbst auf der Client-Seite ansammeln. Wenn du die Antwort dieser Runde später zum Gesprächsverlauf hinzufügst, verwende den zusammengefügten vollständigen Text.


Funktion 2: Denkmodus

Reasoning-Modelle geben zuerst einen Denkprozess aus, bevor sie die Antwort liefern. Im SDK wird dies über den Parameter think gesteuert, und der Denkprozess und der Haupttext gehören zu zwei getrennten Feldern.

Beispiel

from ollama import chat

response = chat(
    model='qwen3.5',
    messages=[{'role': 'user', 'content': 'Was ist größer, 9.9 oder 9.11?'}],
    think=True,
    stream=False,
)

# Der Denkprozess und die endgültige Antwort gehören zu zwei getrennten Feldern
print('Denken:', response.message.thinking)
print('Antwort:', response.message.content)

In Streaming-Szenarien erscheinen Denken und Inhalt abwechselnd in Chunks; verwende eine Zustandsmaschine, um die Rendering-Bereiche umzuschalten:

Beispiel

from ollama import chat

stream = chat(
    model='qwen3.5',
    messages=[{'role': 'user', 'content': 'Was ist 17 mal 23?'}],
    think=True,
    stream=True,
)

in_thinking = False
for chunk in stream:
    if chunk.message.thinking:
        if not in_thinking:
            in_thinking = True
            print('[Denken]', end='', flush=True)
        print(chunk.message.thinking, end='', flush=True)
    elif chunk.message.content:
        if in_thinking:
            in_thinking = False
            print('\n'[Antwort]', end='', flush=True)
        print(chunk.message.content, end='', flush=True)

UI-Implementierungsvorschlag: thinking als einklappbaren grauen Bereich darstellen, content als Fließtext darstellen; die gpt-oss-Serie akzeptiert nur drei Thinking-Effort-Stufen — low / medium / high — das Übergeben eines booleschen Werts ist ungültig.


Fähigkeit 3: Strukturierte Ausgabe

Strukturierte Ausgabe bewirkt, dass das Modell Daten zurückgibt, die streng einem JSON-Schema entsprechen; kombiniert mit der Pydantic-Validierung ist dies der Standardweg, wie Programme Modellausgaben konsumieren.

Beispiel

from ollama import chat
from pydantic import BaseModel

# Definiere die erwartete Datenstruktur mit Pydantic
class Site(BaseModel):
    name: str
    category: str
    free: bool

response = chat(
    model='qwen3.5',
    messages=[{'role': 'user', 'content': 'Python-Tutorial einführen'}],
    format=Site.model_json_schema(),
)

# Der zurückgegebene Inhalt ist ein JSON-String, der dem Schema entspricht; validiere und parse ihn direkt
site = Site.model_validate_json(response.message.content)
print(site.name, site.category, site.free)

Dieses Muster ist der Eckpfeiler aller Datenextraktionsanwendungen: das Extrahieren von Feldern aus Lebensläufen, das Herausziehen von Schlüsselinformationen aus Tickets und das Extrahieren von Informationen aus Bildern (kombiniert mit Vision-Fähigkeiten) nutzen es alle.

Zwei Stabilitätstipps: Setze die Temperatur in den Optionen auf 0; beschreibe außerdem die Bedeutung der Felder im Prompt, was duale Einschränkungen mit dem Schema bietet.


Fähigkeit 4: Visuelles Verständnis

Multimodale Modelle (wie qwen3.5) können Bilder akzeptieren. Das SDK unterstützt die direkte Übergabe von Dateipfaden, was wesentlich bequemer ist als Base64-Kodierung in der REST-API.

Beispiel

from ollama import chat

response = chat(
    model='qwen3.5',
    messages=[{
        'role': 'user',
        'content': 'Welche Seite ist dieser Screenshot? Liste die Hauptfunktionen auf.',
        'images': ['screenshot.png'],
    }],
)

print(response.message.content)

Die Kombination von Vision mit strukturierter Ausgabe ermöglicht "Bild-zu-Daten":

Beispiel

from ollama import chat
from pydantic import BaseModel

# Definiere die Zielstruktur, die aus dem Bild extrahiert werden soll
class Receipt(BaseModel):
    merchant: str
    total: float
    date: str

response = chat(
    model='qwen3.5',
    messages=[{
        'role': 'user',
        'content': 'Extrahiere den Händler, den Betrag und das Datum aus diesem Belegfoto',
        'images': ['receipt.jpg'],
    }],
    format=Receipt.model_json_schema(),
    options={'temperature': 0},
)

print(Receipt.model_validate_json(response.message.content))

Fähigkeit 5: Vektor-Embeddings

Die embed-Schnittstelle erzeugt Textvektoren im Batch; kombiniert mit Kosinusähnlichkeit kann sie eine minimal viable semantische Suche implementieren.

Beispiel

import ollama

# Dokumentvektoren im Batch generieren
docs = [
    'Python ist eine interpretierte Sprache',
    'JavaScript läuft hauptsächlich im Browser',
    'EXAMPLE bietet kostenlose Programmier-Tutorials',
]
result = ollama.embed(model='embeddinggemma', input=docs)
vectors = result['embeddings']
print(len(vectors), len(vectors[0]))  # 3 Vektoren und ihre Dimensionen

# Berechne die Kosinusähnlichkeit zwischen dem Abfragevektor und den Dokumentvektoren, um Ergebnisse zu sortieren und abzurufen
query = ollama.embed(model='embeddinggemma', input='Ist es schwer, Python zu lernen?')

Indizierung und Abfrage müssen dasselbe Embedding-Modell verwenden; andernfalls sind die Vektorräume inkonsistent und die Abfrageergebnisse bedeutungslos. Die vollständige Implementierung der Wissensdatenbank wird im RAG-Projektkapitel behandelt.


Fähigkeit 6: Tool-Aufruf

Tool-Aufruf bringt dem Modell bei, "um Hilfe zu rufen": Wenn es feststellt, dass externe Informationen benötigt werden, gibt es tool_calls zurück; das Programm führt die eigentlichen Funktionen aus, und nachdem die Ergebnisse zurückgegeben wurden, fasst das Modell zusammen und antwortet.

Werfen Sie zunächst einen Blick auf die vollständige Agent-Loop-Sequenz, um zu verstehen, wie Nachrichten zwischen den vier Beteiligten fließen:

工具调用 Agent loop 时序图

Das Python-SDK ermöglicht es, Funktionen direkt als Tools zu übergeben; die Funktionssignatur und der Docstring werden automatisch in ein Schema geparst:

Beispiel

from ollama import chat

# Lokale Tool-Funktion: Der Docstring wird zur Tool-Beschreibung, die das Modell sieht
def get_weather(city: str) -> str:
    """Abfrage der aktuellen Temperatur der angegebenen Stadt

    Argumente:
city: Stadtname

    Rückgabe:
Beschreibung der aktuellen Temperatur
    """

    temperatures = {"Beijing": "22°C", "Shanghai": "26°C", "New York": "18°C"}
    return temperatures.get(city, "Unbekannte Stadt")

messages = [{'role': 'user', 'content': 'Wie ist die Temperatur in New York jetzt?'}]

# Agentenschleife: Iteriere, bis das Modell keine Tools mehr anfordert
while True:
    response = chat(
        model='qwen3.5',
        messages=messages,
        tools=[get_weather],
    )

    # Die Modellnachricht (einschließlich tool_calls) an den Verlauf anhängen
    messages.append(response.message)

    if not response.message.tool_calls:
        # Keine weiteren Tool-Anfragen; die finale Antwort ausgeben
        print(response.message.content)
        break

    # Hat Tool-Anfragen: führe sie aus und gib die Ergebnisse mit der Rolle tool zurück
    for call in response.message.tool_calls:
        result = get_weather(**call.function.arguments)
        messages.append({
            'role': 'tool',
            'tool_name': call.function.name,
            'content': result,
        })

Drei technische Punkte: Erstens muss jede response.message unverändert an messages angehängt werden, und Tool-Ergebnisse werden mit der tool-Rolle zurückgegeben; zweitens kann das Modell bei parallelen Tool-Aufrufen mehrere tool_calls auf einmal zurückgeben — führe sie nacheinander aus und hänge sie an; drittens können Tool-Ergebnisse in echten Projekten sehr lang sein, also kürze sie sorgfältig, um das Kontextfenster zu schützen.


Fähigkeit 7: Websuche

Ollama bietet offiziell zwei Web-Schnittstellen, web_search und web_fetch, die als Tools eingebunden werden können, damit das Modell neue Informationen jenseits seiner Trainingsdaten beantworten kann.

Beispiel

from ollama import chat, web_search, web_fetch

# Webzugriff als Tool einbinden
available_tools = {'web_search': web_search, 'web_fetch': web_fetch}

messages = [{'role': 'user', 'content': "Welche neuen Funktionen hat Ollama kürzlich?"}]

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:
            # Tool-Ergebnisse können sehr lang sein; kürzen, um den Kontext zu schützen
            result = str(func(**call.function.arguments))
            messages.append({
                'role': 'tool',
                'tool_name': call.function.name,
                'content': result[:2000],
            })

Die Webinterfaces erfordern das Erstellen eines API Keys auf ollama.com; Suchergebnisse können leicht Tausende von Tokens umfassen, daher empfiehlt es sich offiziell, den Kontext für solche Agent-Szenarien auf 32K oder höher einzustellen. Es gibt außerdem eine fertige MCP-Server-Implementierung, die mit Tools wie Cline und Codex integriert werden kann; siehe das Ökosystem-Kapitel für Integrationsdetails.

Andere Erweiterungen