Ollama-Python-Bibliothek: So startest du lokal mit LLMs

Cloud-LLM-APIs sind leistungsstark, bringen aber Kompromisse mit sich: nutzungsbasierte Preise, Ratenlimits und die ständige Unsicherheit, wo deine Daten verarbeitet werden. Für Entwicklerinnen und Entwickler, die mit sensiblen Daten arbeiten oder viel experimentieren, wird das schnell zum Bremsklotz.

Genau hier punkten Local-First-Ansätze. Die Ollama-Python-Bibliothek nimmt die Reibung raus, indem sie große Sprachmodelle lokal ausführt – und du interagierst damit über sauberen, Python-nativen Code. So behältst du die volle Kontrolle über Performance, Kosten und Datenschutz.

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

Schau dir außerdem 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 erstellen
• OpenClaw mit Ollama nutzen: Einen lokalen Data Analyst bauen
• Claude Code mit lokalen Ollama-Modellen verwenden

Voraussetzungen, um Ollama mit Python auszuführen

Stelle vor dem Start sicher, dass Folgendes auf deinem Gerät eingerichtet ist:

• Python 3.8 oder höher

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

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

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

Du kannst auch Docker mit Ollama nutzen, um Versionen konsistent zu halten.

Was ist die Ollama-Python-Bibliothek?

Die Ollama-Python-Bibliothek ist das offizielle SDK, das die Ollama-REST-API in eine einfache, „pythonic“ Schnittstelle kapselt. Anders gesagt: Aus Low-Level-HTTP-Requests und JSON-Payloads werden High-Level-Python-Funktionen – du konzentrierst dich auf die Intention, nicht auf den Transport.

Wenn deine Anwendung wächst, nimmt dir diese Abstraktion wiederholtes Request-Basteln ab, standardisiert die Verarbeitung von Antworten und bündelt Fehlerbehandlung an einer Stelle.

Zum Vergleich könnte ein Raw-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 Bibliothek mit dem Ollama-Server

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

Diese Trennung ist wichtig, weil das Modell als eigener Dienst läuft. So lassen sich Ressourcen (CPU/GPU) effizienter managen und mehrere Anwendungen können sich eine Modellinstanz teilen.

Wenn du dich mit einer anderen Maschine verbinden willst, kannst du einen Custom-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 Bibliothek

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

pip install ollama

Nach der Installation ist es sinnvoll, die Verbindung zu prüfen, indem du verfügbare Modelle auflistest. 

So stellst du sicher, dass Python-Umgebung, SDK und Ollama-Runtime korrekt zusammenspielen.

Führe dazu Folgendes aus:

import ollama

print(ollama.list())

Text mit generate() generieren

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

Weil kein Kontext behalten wird, hängt die Ausgabegüte vollständig von der Klarheit deiner Prompt ab.

Einfache Textgenerierung

Das folgende Beispiel zeigt den einfachsten Workflow: 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 außerdem Metadaten wie Laufzeit und Token-Zahlen – hilfreich bei der Performance-Optimierung.

Ausgaben mit Parametern steuern

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

Niedrige Temperaturwerte erzeugen deterministischere Ausgaben, höhere Werte mehr Vielfalt. Mit Parametern wie top_p und num_predict kannst du Diversität und Länge weiter verfeinern.

Wichtige Parameter im Überblick: 

Hier ein Beispiel für die Nutzung von 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
    }
)

Gespräche mit chat() aufbauen

Im Gegensatz zu generate() unterstützt die chat()-API zustandsbehaftete Interaktionen über eine Sequenz von Nachrichten. So kann das Modell Kontext über mehrere Turns hinweg behalten.

Jede Nachricht enthält eine Rolle wie user, assistant oder system, was die Unterhaltung strukturiert.

Single-Turn-Chat-Requests

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

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

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

Mehrere Turns mit Kontext

Damit der Kontext erhalten bleibt, speicherst und sendest du die komplette Gesprächshistorie bei jedem Request erneut. So steuerst du genau, 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 System-Prompts Verhalten steuern

Ein System-Prompt definiert vorab das Verhalten des Modells – etwa Tonalität, Grenzen 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-Bibliothek

Für interaktive Anwendungen ist Reaktionsfähigkeit genauso wichtig wie Korrektheit. Ollama unterstützt sowohl Streaming als auch asynchrone Ausführung – für bessere Performance und Nutzererlebnis.

Antworten in Echtzeit streamen

Beim Streaming verarbeitest du die Ausgabe schrittweise, während sie generiert wird – 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

Asynchrone Ausführung erlaubt deiner Anwendung, mehrere Anfragen gleichzeitig zu bearbeiten, ohne zu blockieren. Für die Implementierung brauchst 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 Funktionen, um Modelle programmatisch zu managen – 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 per Code laden 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-Bibliothek erzeugen und nutzen

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

Text-Embeddings erstellen

Das folgende Beispiel wandelt Text in eine Vektorrepräsentation um – nutzbar für Suche oder Clustering.

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

embedding = response['embeddings'][0]

Einfache Similarity-Suche bauen

Sind Embeddings vorhanden, lässt sich Ähnlichkeit z. B. per Kosinus-Ähnlichkeit messen, die den Winkel zwischen Vektoren vergleicht.

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-Bibliothek

Für fortgeschrittene Anwendungen müssen Modelle oft externe Funktionen aufrufen oder strukturierte Daten zurückgeben.

Tool-Calling mit Python-Funktionen umsetzen

Beim Tool-Calling kann das Modell vordefinierte Python-Funktionen basierend auf Nutzerintentionen 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 sorgen dafür, dass Antworten konsistent und maschinenlesbar sind – etwa als JSON.

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 cloudbasiertes Inferenz-Serving für anspruchsvollere Use Cases.

Bilder an Vision-Modelle senden

Vision-Modelle verarbeiten Text und Bilder – für Aufgaben wie 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 gehostetes Inferenz-Serving.

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

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

Fehlerbehandlung: Häufige Stolpersteine mit der Ollama-Python-Bibliothek

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

ResponseError-Exceptions behandeln

Das Ollama-SDK wirft strukturierte Exceptions für Serverfehler, sodass du genau prüfen 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

Typische Ursachen: Server läuft nicht, Modelle fehlen, zu wenig Speicher oder Kontextlimit überschritten.

• Server läuft nicht: Starte mit ollama serve

• Modell nicht gefunden: Führe ollama pull aus

• Zu wenig Speicher: Nutze kleinere Modelle oder Quantisierung

• Kontextprobleme: Passe num_ctx an

num_ctx steuert die maximale Anzahl an Tokens, die das Modell „auf einmal sieht“, einschließlich:

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

Ein sauberes Management dieses Parameters verhindert, dass das LLM früheren Inhalt (meist am Anfang) abschneidet oder wichtige Anweisungen/Daten unbemerkt verliert.

Fazit

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

Aus meiner Erfahrung mit Ollama ist es eine gute Option, ohne Cloud-LLMs auszukommen. Ich kann zum Beispiel Open-Source-Modelle freier nutzen. Wenn du ebenfalls flexibel zwischen Modellen wechseln möchtest, ist Ollama ein guter Einstiegspunkt, um darauf zuzugreifen.

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