Ollama Python Library: Der Einstieg in lokale LLMs

Cloud-LLM-APIs sind mächtig, bringen aber Kompromisse mit sich: nutzungsabhängige Preise, Ratenlimits und die ständige Unsicherheit, wo deine Daten verarbeitet werden. Für Entwickler, die mit sensiblen Daten arbeiten oder viel experimentieren, wird das schnell zur Hürde.

Genau hier punkten Local-First-Ansätze. Die Ollama Python Library beseitigt diese Reibung, indem du große Sprachmodelle lokal ausführst und über sauberen, Python-nativen Code mit ihnen interagierst. So behältst du die volle Kontrolle über Performance, Kosten und Datenschutz.

In diesem Artikel führe ich dich durch die komplette Ollama-Python-API – von einfacher Textgenerierung mit generate() bis hin zu Tool-Calling und Vision-Modellen.

Sieh dir dazu auch unsere neuesten Ollama-Tutorials an:

• Gemma 4 Tutorial: Einen lokalen KI-Coding-Agenten mit Gradio und Ollama bauen
• Qwen 3.5 Small Models Tutorial: Video-zu-Game-Generator mit Ollama entwickeln
• OpenClaw mit Ollama nutzen: Einen lokalen Data Analyst bauen
• Claude Code mit lokalen Ollama-Modellen verwenden

Voraussetzungen, um Ollama mit Python auszuführen

Bevor du startest, stelle sicher, dass Folgendes auf deinem Gerät eingerichtet ist:

• Python 3.8 oder höher

• Ollama von der Website heruntergeladen, installiert und gestartet (ollama serve)

• Mindestens ein Modell gepullt (z. B. ollama pull llama3.2)

Diese Voraussetzungen sind wichtig, da das Python-SDK nur ein Client ist; das eigentliche Inferenzlaufen erfolgt in der Ollama-Runtime. Ist die Runtime nicht verfügbar oder kein passendes Modell vorhanden, schlagen Aufrufe fehl.

Für konsistente Versionen kannst du auch Docker mit Ollama in Betracht ziehen.

Was ist die Ollama Python Library?

Die Ollama Python Library ist das offizielle SDK, das die Ollama-REST-API in eine einfache, Python-typische Schnittstelle kapselt. Anders gesagt: Aus Low-Level-HTTP-Requests und JSON-Payloads werden hochstufige Python-Funktionen, sodass du dich auf die Absicht statt auf Transportdetails konzentrieren kannst.

Wenn deine Anwendung wächst, erspart dir diese Abstraktion wiederholtes Request-Bauen, standardisiert die Antwortverarbeitung und bündelt Fehlerbehandlung an einer Stelle.

Zum Vergleich könnte ein Roh-Request so aussehen:

import requests

response = requests.post(
    "http://localhost:11434/api/generate",
    json={
        "model": "llama3.2",
        "prompt": "Explain recursion"
    }
)

Das funktioniert, wird aber schnell umständlich und fehleranfällig. Mit dem SDK wird dieselbe Aufgabe zu:

import ollama

response = ollama.generate(
    model='llama3.2',
    prompt='Explain recursion'
)

So kommuniziert die Library mit dem Ollama-Server

Unter der Haube wird jeder SDK-Aufruf zu einem HTTP-Request an den Ollama-Server unter http://localhost:11434. Dein Python-Skript agiert als Client, während die Ollama-Runtime als Server die Modelle hostet und ausführt.

Diese Trennung ist wichtig, weil das Modell so als eigener Dienst läuft, was Ressourcenmanagement (CPU/GPU) effizienter macht und mehreren Anwendungen erlaubt, sich eine Modellinstanz zu teilen.

Wenn du dich mit einer anderen Maschine verbinden musst, kannst du einen benutzerdefinierten Client konfigurieren:

from ollama import Client

client = Client(host='http://remote-server:11434')
response = client.generate(model='llama3.2', prompt='Hello')

Installation und Konfiguration der Library

Die Installation ist unkompliziert und benötigt nur wenige Abhängigkeiten:

pip install ollama

Nach der Installation solltest du die Konnektivität prüfen, indem du die verfügbaren Modelle auflistest.

So stellst du sicher, dass deine Python-Umgebung, das SDK und die Ollama-Runtime korrekt verbunden sind.

Führe dazu Folgendes aus:

import ollama

print(ollama.list())

Text generieren mit generate()

Die Funktion generate() ist für zustandslose Aufgaben gedacht. Jeder Request wird unabhängig verarbeitet, ohne sich frühere Interaktionen zu merken. Ideal für Aufgaben wie Zusammenfassen, Umformulieren oder Codegenerierung.

Weil kein Kontext behalten wird, hängt die Qualität der Ausgabe vollständig davon ab, wie klar dein Prompt formuliert ist.

Einfache Textgenerierung

Das folgende Beispiel zeigt den einfachsten Ablauf: Prompt senden, Antwort empfangen und den generierten Text extrahieren.

import ollama

response = ollama.generate(
    model='llama3.2',
    prompt='Write a Python docstring for a function that calculates factorial'
)

print(response['response'])

Die Antwort enthält auch Metadaten wie Ausführungszeit und Token-Zahlen – nützlich zur Performanceoptimierung.

Ausgaben mit Parametern anpassen

Das Generationsverhalten lässt sich über Sampling-Parameter steuern, die beeinflussen, wie das Modell Tokens auswählt.

Niedrigere Temperaturwerte liefern deterministischere Ausgaben, höhere erzeugen mehr Varianz. Mit Parametern wie top_p und num_predict kannst du Vielfalt und Länge weiter feinsteuern.

Wichtige Parameter im Überblick:

Hier ein Beispiel für die Verwendung der Parameter top_p, temperature und num_predict:

response = ollama.generate(
    model='llama3.2',
    prompt='Explain machine learning in one paragraph',
    options={
        'temperature': 0.2,
        'top_p': 0.9,
        'num_predict': 100
    }
)

Unterhaltungen aufbauen mit chat()

Im Gegensatz zu generate() unterstützt die chat()-API zustandsbehaftete Interaktionen über eine Abfolge von Nachrichten. So kann das Modell den Kontext über mehrere Runden hinweg beibehalten.

Jede Nachricht enthält eine Rolle wie user, assistant oder system, um das Gespräch zu strukturieren.

Single-Turn-Chat-Anfragen

Auch eine einzelne Interaktion nutzt das Nachrichtenformat – die Basis für komplexere Gespräche.

response = ollama.chat(
    model='llama3.2',
    messages=[
        {'role': 'user', 'content': 'Explain Python decorators'}
    ]
)

print(response['message']['content'])

Mehrstufigen Kontext beibehalten

Um Kontext zu halten, speicherst und sendest du den kompletten Gesprächsverlauf bei jedem Request erneut. So kontrollierst du exakt, was das Modell "weiß".

messages = [
    {'role': 'user', 'content': 'What is recursion?'}
]

response = ollama.chat(model='llama3.2', messages=messages)
messages.append(response['message'])

messages.append({'role': 'user', 'content': 'Give an example in Python'})
response = ollama.chat(model='llama3.2', messages=messages)

Mit Systemprompts Verhalten steuern

Ein Systemprompt definiert das Verhalten des Modells im Voraus, etwa Tonalität, Einschränkungen oder Rolle.

messages = [
    {'role': 'system', 'content': 'You are a strict Python code reviewer.'},
    {'role': 'user', 'content': 'Review this code: def add(a,b): return a+b'}
]

Streaming und Async-Support in der Ollama Python Library

Für interaktive Anwendungen zählt Reaktionsgeschwindigkeit ebenso wie Korrektheit. Ollama unterstützt sowohl Streaming als auch asynchrone Ausführung, um Performance und Nutzererlebnis zu verbessern.

Antworten in Echtzeit streamen

Beim Streaming verarbeitest du Ausgaben schrittweise, sobald sie generiert werden – statt auf die vollständige Antwort zu warten.

for chunk in ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Write a story'}],
    stream=True
):
    print(chunk['message']['content'], end='', flush=True)

AsyncClient für asynchrone Anwendungen nutzen

Asynchrone Ausführung ermöglicht es deiner Anwendung, mehrere Anfragen nebenläufig zu bearbeiten, ohne zu blockieren. Dafür verwendest du die Python-Bibliothek asyncio.

Ein Beispiel:

import asyncio
from ollama import AsyncClient

async def main():
    client = AsyncClient()
    async for chunk in await client.chat(
        model='llama3.2',
        messages=[{'role': 'user', 'content': 'Explain async programming'}],
        stream=True
    ):
        print(chunk['message']['content'], end='')

asyncio.run(main())

Ollama-Modelle aus Python verwalten

Das Ollama-SDK bietet auch Werkzeuge, um Modelle programmatisch zu verwalten – besonders nützlich in automatisierten Umgebungen.

Lokale Modelle auflisten und inspizieren

Du kannst die Liste verfügbarer Modelle abrufen und Eigenschaften wie Größe und Konfiguration einsehen.

models = ollama.list()
print(models)

info = ollama.show('llama3.2')
print(info)

Modelle programmatisch pullen und löschen

Modelle lassen sich direkt aus Python herunterladen oder entfernen – ideal für dynamisches Abhängigkeitsmanagement.

ollama.pull('llama3.2')
ollama.delete('llama3.2')

Embeddings mit der Ollama Python Library erzeugen und nutzen

Embeddings stellen Text als numerische Vektoren dar, die semantische Bedeutung erfassen. So kannst du Texte nach Ähnlichkeit vergleichen statt nach exakter Wortgleichheit.

Text-Embeddings erstellen

Das folgende Beispiel wandelt Text in eine Vektorrepräsentation um, die du für Suche oder Clustering nutzen kannst.

response = ollama.embed(
    model='nomic-embed-text',
    input='Ollama is a local LLM runtime'
)

embedding = response['embeddings'][0]

Einfache Similarity-Suche aufbauen

Sind Embeddings vorhanden, misst du Ähnlichkeit z. B. mit der Kosinusähnlichkeit, die den Winkel zwischen Vektoren vergleicht.

Hier eine einfache Suchfunktion:

import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

Tool-Calling und strukturierte Ausgaben in der Ollama Python Library

Für fortgeschrittene Anwendungen müssen Modelle oft mit externen Funktionen interagieren oder strukturierte Daten zurückgeben.

Tool-Calling mit Python-Funktionen implementieren

Beim Tool-Calling kann das Modell vordefinierte Python-Funktionen basierend auf der Nutzerabsicht aufrufen.

Erstellen wir eine Funktion, die solche Tools nutzt:

def get_weather(city: str) -> str:
    """Get current weather for a city"""
    return f"Weather in {city} is sunny"
response = ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'What is the weather in Paris?'}],
    tools=[get_weather]
)

Strukturierte JSON-Antworten erhalten

Strukturierte Ausgaben stellen sicher, dass Antworten in einem konsistenten, maschinenlesbaren Format wie JSON zurückgegeben werden.

response = ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Review: Great product, 5 stars!'}],
    format='json'
)

Fortgeschritten: Vision-Modelle und Ollama Cloud in Python

Ollama unterstützt multimodale Modelle und Cloud-Inferenz für anspruchsvollere Anwendungsfälle.

Bilder an Vision-Modelle senden

Vision-Modelle verarbeiten Text und Bilder – etwa für Bildbeschreibungen und visuelle Analysen.

response = ollama.chat(
    model='llama3.2-vision',
    messages=[{
        'role': 'user',
        'content': 'Describe this image',
        'images': ['image.jpg']
    }]
)

Cloud-Modelle aus Python ausführen

Für größere Modelle, die lokal nicht laufen, bietet Ollama Cloud gehostete Inferenz. Dafür musst du dich bei Ollama Cloud anmelden.

ollama signin

Nach der Anmeldung kannst du mit cloud-gehosteten Modellen so chatten:

from ollama import Client
import os

ollama.chat(model='deepseek-v3.1:671b-cloud', messages=[...])

client = Client(
    host='https://ollama.com',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)

Fehlerbehandlung: Häufige Stolperfallen der Ollama Python Library

Wenn du echte Anwendungen baust, verhindert explizite Fehlerbehandlung stille Fehler und erhöht die Zuverlässigkeit.

ResponseError-Ausnahmen behandeln

Das Ollama-SDK wirft strukturierte Ausnahmen für Serverfehler, damit du nachvollziehen kannst, was schiefgelaufen ist.

import ollama

try:
    ollama.generate(model='unknown', prompt='test')
except ollama.ResponseError as e:
    print(e.status_code, e.error)

Verbindungs- und Modellprobleme debuggen

Häufige Ursachen sind: Server läuft nicht, Modelle fehlen, zu wenig Speicher oder der Kontextrahmen wird überschritten.

• Server läuft nicht: Starte mit ollama serve

• Modell nicht gefunden: Führe ollama pull aus

• Speicher erschöpft: Nutze kleinere Modelle oder Quantisierung

• Kontextprobleme: Passe num_ctx an

num_ctx steuert die maximale Anzahl an Tokens, die das Modell gleichzeitig "sehen" kann, einschließlich:

• deines Prompts
• Systemanweisungen
• Gesprächsverlauf
• abgerufener Dokumente (RAG)
• und der vom Modell selbst generierten Tokens

Ein gutes Management dieses Parameters verhindert, dass das LLM frühere Inhalte (meist vom Anfang) abschneidet oder wichtige Anweisungen und Daten stillschweigend verliert.

Fazit

Die Ollama Python Library bietet eine vollständige Schnittstelle für lokale und Cloud-LLMs – von einfacher Textgenerierung bis zu fortgeschrittenen Funktionen wie Embeddings, Tool-Calling und multimodalen Eingaben. LLMs werden damit zu einem lokalen Dienst, gegen den du wie gegen jede andere Komponente in deinem Stack skripten, testen und skalieren kannst.

Aus meiner Erfahrung mit Ollama ist es eine starke Option, ohne Cloud-LLMs auszukommen. Zum Beispiel kann ich Open-Source-Modelle freier nutzen. Wenn du ebenfalls mehr Flexibilität beim Wechsel zwischen Modellen suchst, ist Ollama ein guter Einstiegspunkt, um all das zu nutzen.

Wenn du deine Kompetenzen vertiefen willst, empfehle ich unseren Kurs Developing LLM Applications with LangChain oder die Associate AI Engineer for Developers-Zertifizierung.