Wichtigste Erkenntnisse
- Ollama stellt eine REST API unter `http://localhost:11434/v1` bereit, die OpenAI-API exakt abbildet.
- Nutzen Sie die OpenAI Python Bibliothek: ändern Sie `api_key="openai"` zu `api_key="ollama"` und setzen Sie `base_url="http://localhost:11434/v1"`.
- Gleicher Ansatz in Node.js: OpenAI SDK zeigt auf localhost:11434.
- Die OpenAI-kompatible API ist identisch über Ollama, vLLM und LM Studio -- kein Code-Wechsel nötig zum Provideraustausch.
- Seit May 2026 funktionieren Streaming (token-für-token Responses) und Function Calling mit lokalen Modellen über diese API.
⚡ Schnelle Fakten
Ollama API: `http://localhost:11434/v1` — bildet OpenAI `/chat/completions` exakt ab
LM Studio API: `http://localhost:1234/v1` — gleicherFormat, anderer Port
vLLM API: `http://localhost:8000/v1` — Produktionsreife Server
Code-Änderung: 2 Zeilen — `base_url` und `api_key`. Rest des Codes bleibt identisch.
Unterstützt: Chat Completions, Text Completions, Embeddings, Streaming, Function Calling
Authentifizierung: Keine standardmäßig — nur Localhost-Zugang. Reverse Proxy für Netzwerkzugang.
Modell für Code-Beispiele: Llama 4 Scout (beste Qualität auf 12 GB) oder Llama 3.2 3B (leichtgewichtig)
Was bedeutet OpenAI-kompatibel?
OpenAI-kompatibel bedeutet, dass der API-Endpoint Responses in gleichem Format wie OpenAI API zurückgibt. Dies ermöglicht jeder Bibliothek oder jedem Tool, das für OpenAI gebaut wurde, mit lokalen Modellen zu arbeiten, indem nur auf andere URL gezeigt wird. Erfahren Sie, wie Ollama vs LM Studio diese Standard-Implementierung vergleichen.
Beispiel: OpenAI Python Bibliothek sendet Requests so:
``` POST /chat/completions { "model": "gpt-4o", "messages": [...], "temperature": 0.7 } ```
Ollama API akzeptiert exakt denselben Request auf `localhost:11434/v1/chat/completions` und gibt Response in OpenAI Format zurück:
``` { "choices": [{"message": {"content": "..."}}], "usage": {"prompt_tokens": 10, "completion_tokens": 20} } ```
Da das Format identisch ist, müssen Sie keine neue API lernen oder Code umschreiben.
---
🔍 Wussten Sie: OpenAI API Format ist de facto Standard für alle LLM APIs geworden. Anthropic (Claude), Google (Gemini), und jedes große lokale Inference Tool (Ollama, vLLM, LM Studio, llama.cpp) unterstützen es jetzt. Code gegen dieses Format ist echte Provider-agnostisch — das nächste zur universalen API, das die AI-Industrie hat.
Was ist Ollamas API Endpoint?
**Wenn Sie `ollama serve` laufen lassen, startet Ollama eine REST API unter `http://localhost:11434`.** OpenAI-kompatible Endpoints sind:
| Endpoint | URL | Beschreibung |
|---|---|---|
| Chat Completions | POST http://localhost:11434/v1/chat/completions | Entspricht `/chat/completions` von OpenAI |
| Text Completions | POST http://localhost:11434/v1/completions | Entspricht `/completions` von OpenAI |
| Embeddings | POST http://localhost:11434/v1/embeddings | Konvertiert Text zu Vektoren |
| List Models | GET http://localhost:11434/v1/models | Listet verfügbare Modelle |
Wie nutze ich Ollama API mit Python (OpenAI Bibliothek)?
Installieren Sie OpenAI Bibliothek und zeigen Sie auf localhost.
🔍 Pro Tipp: Setzen Sie `OPENAI_BASE_URL=http://localhost:11434/v1` als Umgebungsvariable. Viele Tools (LangChain, LlamaIndex, aider) lesen diese Variable automatisch — keine Code-Änderungen nötig. Sie können zwischen OpenAI und Ollama wechseln, indem Sie nur eine env var ändern.
# 1. OpenAI Bibliothek installieren
pip install openai
# 2. Mit Ollama verbinden
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama" # Dummy-Key; Ollama ignoriert ihn
)
# 3. Request stellen
response = client.chat.completions.create(
model="llama4:scout", # Beste Qualität auf 12 GB VRAM (MoE)
# model="llama3.2:3b", # Leichte Alternative für 8 GB RAM
messages=[
{"role": "user", "content": "What is 2+2?"}
]
)
print(response.choices[0].message.content)Wie nutze ich Ollama API mit Node.js?
Installieren Sie OpenAI SDK und verbinden Sie es mit lokaler Ollama Instance.
// 1. Installieren
npm install openai
// 2. Mit Ollama verbinden
const OpenAI = require("openai").default;
const client = new OpenAI({
baseURL: "http://localhost:11434/v1",
apiKey: "ollama"
});
// 3. Request stellen
const response = await client.chat.completions.create({
model: "llama4:scout", // Beste Qualität auf 12 GB VRAM
// model: "llama3.2:3b", // Leicht für 8 GB RAM
messages: [{
role: "user",
content: "What is 2+2?"
}]
});
console.log(response.choices[0].message.content);Wie nutze ich LM Studio OpenAI-kompatibler Server (localhost:1234)
**LM Studio stellt OpenAI-kompatible API unter `http://localhost:1234/v1` bereit.** Aktivieren Sie unter Local Server Tab -- Modell laden, dann Start Server klicken. Gleicher Python und Node.js Code funktioniert mit LM Studio -- ändern Sie nur Port von 11434 zu 1234.
LM Studio eignet sich für GUI-Nutzer, die visuell Modelle durchsuchen und leicht wechseln wollen. Ollama ist bevorzugt für Scripting, Automatisierung und CI Pipelines.
| Plattform | Port | Beste für | GPU erforderlich |
|---|---|---|---|
| LM Studio | localhost:1234 | GUI Nutzer, visuelles Modell-Management | Nein (CPU funktioniert) |
| Ollama | localhost:11434 | Scripting, Automatisierung, Produktion | Nein (CPU funktioniert) |
| vLLM | localhost:8000 | Multi-GPU, hochdurchsatzige Server | Empfohlen |
# Python: Mit LM Studio verbinden (localhost:1234)
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:1234/v1",
api_key="lm-studio" # Beliebiger String; LM Studio ignoriert ihn
)
response = client.chat.completions.create(
model="llama-3.2-3b-instruct", # Exakter Modellname in LM Studio
messages=[
{"role": "user", "content": "What is 2+2?"}
]
)
print(response.choices[0].message.content)Wie nutze ich Ollama API von JavaScript im Browser?
Ollama vom Browser-JavaScript aufrufen erfordert, dass Browser und Server auf gleicher Maschine sind (oder CORS erlaubt). Aus Sicherheitsgründen funktionieren Browser-Requests zu localhost nur, wenn JavaScript auch von localhost serviert wird. Schauen Sie beste lokale LLM Frontends für Browser-ready UIs, die dies nahtlos handhaben.
Wenn Sie Ollama von Browser auf anderem IP aufrufen müssen, richten Sie CORS Proxy oder Server-seitigen Middleware auf.
// Browser-seitiges JavaScript (wenn Server localhost:3000, Ollama ist localhost:11434)
fetch("http://localhost:11434/v1/chat/completions", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
model: "llama4:scout", // Beste Qualität auf 12 GB VRAM
// model: "llama3.2:3b", // Leicht für 8 GB RAM
messages: [{ role: "user", content: "What is 2+2?" }]
})
})
.then(res => res.json())
.then(data => console.log(data.choices[0].message.content))Wie streame ich Responses Token-für-Token?
Streaming lässt Sie Responses anzeigen, während sie generiert werden, Token für Token, anstatt auf ganze Response zu warten. Seit May 2026 funktioniert Streaming mit allen lokalen Modellen via OpenAI-kompatible API.
# Python: streaming example
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama"
)
stream = client.chat.completions.create(
model="llama4:scout",
messages=[{"role": "user", "content": "Count to 10"}],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
Kann mein lokales Modell Funktionen aufrufen?
Ja, seit May 2026 funktioniert Function Calling mit lokalen Modellen via OpenAI API. Sie definieren Funktions-Schema und Modell kann mit Argumenten zum Aufrufen antworten. Dies ermöglicht beste lokale LLMs zum Codieren sich in Ihr Tool-Ökosystem zu integrieren.
Function Calling Support hängt vom Modell ab. Llama 4 Scout, Qwen3 8B, Gemma 4 9B, und Mistral Small 3.1 unterstützen Tool Calling zuverlässig. Llama 3.1 8B und Qwen2.5 7B unterstützen es auch (legacy). Kleinere Modelle (3B) erzeugen möglicherweise nicht zuverlässig strukturiertes Tool Call JSON.
In 2026 erweitert Model Context Protocol (MCP) Function Calling zu standardisiertem Tool Connection Layer. MCP ermöglicht jedem Client (Claude Code, Cursor, custom Apps) sich über einheitliches Protokoll mit jedem Tool Server zu verbinden — über diese pro-Request Tool Definitionen hinaus. Ollama unterstützt MCP-style Tool Calling durch standard OpenAI-kompatibles Function Calling API. Für Produktion Tool Integrationen wird MCP Standard; die Function Calling Beispiele hier bleiben Grundlage.
Wenn Sie OpenAI-kompatible APIs lokal nutzen, funktionieren structured Output und JSON Mode gleich wie bei Cloud APIs. Für Schema Compliance und Format Kontrolle über lokale und Cloud Modelle, siehe strukturierte Output und JSON Mode.
OpenAI-kompatible APIs akzeptieren gleiche Prompt Formate wie Cloud Versionen — System Messages, User Messages, und Structured Output. Ganze Bibliothek von Prompt Engineering Techniken wendet sich direkt auf lokale API Aufrufe an.
# Beispiel: lokales Modell ruft Wetter-Funktion auf
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather",
"parameters": {
"type": "object",
"properties": {
"location": {"type": "string"}
}
}
}
}]
response = client.chat.completions.create(
model="llama4:scout",
messages=[{"role": "user", "content": "What is the weather in SF?"}],
tools=tools
)
# Prüfen, ob Modell Function Call zurückgab
if response.choices[0].message.tool_calls:
call = response.choices[0].message.tool_calls[0]
print(f"Call function: {call.function.name} with {call.function.arguments}")
Lokale LLM OpenAI APIs nach Region
EU / DSGVO & AI Act: Für EU Entwickler stellt Ollama lokal sicher, dass DSGVO Artikel 5 konform ist (Datensparsamkeit) -- alle Inferenz bleibt on-device ohne Datensicherung zu Cloud APIs. Ollama wird von GitHub unter MIT Lizenz heruntergeladen und erfüllt EU Compliance-Anforderungen. Hochrisiko-Systeme der EU AI Act Verpflichtungen gelten ab August 2, 2026 (ausstehend Digital Omnibus). Lokale API Inferenz erfüllt DSGVO Daten-Residenz-Anforderungen by default. Für Unternehmen eliminiert dies Vendor Lock-in und garantiert Daten-Residenz.
Japan / APPI: Unter Japans Act on Protection of Personal Information (APPI), umgeht On-Premises Modell Inferenz Cloud Datentransfer-Anforderungen. Ollama + Qwen3 8B läuft auf Standard-Corporate-Laptops (8 GB RAM) mit verbesserter Japanischer Sprach-Unterstützung über Qwen2.5, mit 30-50 tok/sek Latenz, die Echtzeit-Response-Erwartungen für Japanische Sprachverarbeitung erfüllt.
China / CAC: Für Deployment unter Chinas Cybersecurity Law (CAC Artikel 37), erfüllt lokale Inferenz Daten-Lokalisierungs-Mandates -- Ollama + Qwen3 läuft auf jedem Linux Device ohne externe API Aufrufe. Qwen3's native Chinesische Tokenisierung fügt 30-40% Effizienz über Llama hinzu, reduziert lokale Inferenz Overhead.
Was sind häufige Fehler mit lokalen LLM OpenAI APIs?
- API Key wird ignoriert vergessen. Ollama erfordert `api_key="ollama"` (beliebiger String funktioniert) da es nicht authentifiziert. Die echte Authentifizierung ist, dass Request von localhost kommt oder lokalem Netzwerk, nicht Internet.
- Nicht realisieren, dass Modellname zählt. Wenn Sie `/chat/completions` mit `model="gpt-4"` aufrufen aber nur `llama3.2:3b` in Ollama gepullt haben, schlägt Request fehl. Verwenden Sie exakte Modellnamen von `ollama list`.
- Annehmen Ollama braucht Internet. Das macht es nicht. API ist vollständig lokal. Aber wenn Ihr Python Code versucht, zuerst OpenAI Server zu erreichen (default), schlägt es fehl. Setzen Sie `base_url` immer explizit.
- CORS Fehler vom Browser. Wenn Sie Ollama von Browser-Skript aufrufen und CORS Fehler bekommen, hat Browser Request aus Sicherheit blockiert. Siehe Lokale LLMs mit VS Code und Cursor für Editor-basierte Lösungen, die CORS umgehen.
- Nicht stream=True setzen wenn Streaming erwartet. Wenn Sie Token-für-Token Responses wollen, müssen Sie explizit `stream=True` setzen. Default wartet auf ganze Response.
- `llama3.2:3b` in Beispielen verwenden wenn bessere Modelle verfügbar. Viele Tutorials verwenden Llama 3.2 3B da es auf 8 GB RAM passt. Wenn Sie 12+ GB VRAM haben, wechseln Sie zu `llama4:scout` — dramatisch bessere Qualität für gleichen API Code. Verwenden Sie 3B Modelle nur für API Integration Testen, nicht Produktions-Workloads.
- `OLLAMA_NUM_PARALLEL` für concurrent Requests nicht setzen. Default verarbeitet Ollama einen Request aufs Mal. Für Multi-User Apps oder parallele Test Suites, setzen Sie `OLLAMA_NUM_PARALLEL=4` (oder höher) um concurrent API Calls zu handhaben. Ohne das, Requests queue und Latenz spikt.
- ---
- ⚠️ Warnung: Ollama API hat KEINE Authentifizierung by default. Wenn Sie es für Netzwerk freigeben (`OLLAMA_HOST=0.0.0.0`), jeder auf dem Netzwerk kann Requests senden, Modelle laden, und GPU Ressourcen verbrauchen. Für Multi-User oder Produktions Setups, stellen Sie Reverse Proxy (nginx, Caddy) mit Authentifizierung vor Ollama -- geben Sie Port 11434 niemals direkt an Internet frei.
Häufig gestellte Fragen über lokale LLM APIs
Muss ich meinen OpenAI Code ändern um Ollama zu nutzen?
Nein. Setzen Sie `base_url="http://localhost:11434/v1"` und `api_key="ollama"`. Alles andere bleibt gleich. Wenn Sie Code mit OpenAI Bibliothek haben, tauschen Sie diese zwei Zeilen aus und es funktioniert mit Ihrem lokalen Modell.
Kann ich API von anderem Computer auf meinem Netzwerk nutzen?
Ja. Default hört Ollama nur auf localhost. Um Netzwerk Zugang zu erlauben, setzen Sie Umgebungsvariable `OLLAMA_HOST=0.0.0.0:11434` bevor Sie Ollama laufen lassen. Dann zeigen Sie Ihren Code auf `http://<machine-ip>:11434/v1`. Seien Sie mit Sicherheit vorsichtig -- nutzen Sie Firewall wenn das Produktion ist.
Hat LM Studio OpenAI-kompatible API?
Ja. LM Studio stellt OpenAI-kompatible API unter `http://localhost:1234/v1` bereit. Aktivieren Sie unter Local Server Tab, laden Sie Modell, dann klicken Sie Start Server. Nutzen Sie gleichen Python oder Node.js Code wie Ollama -- nur Port ändert sich (1234 statt 11434).
Kann ich mehrere Modelle gleichzeitig aufrufen?
Wenn Sie sie in Ollama geladen haben, ja. Aber beachten Sie, dass zwei Modelle gleichzeitig laufen VRAM Nutzung verdoppelt. Sie müssen genug GPU Speicher haben.
Ist API authentifiziert?
Nein. By default hat Ollama API keine Authentifizierung. Jeder mit Zugang zu localhost:11434 kann sie nutzen. Für Produktion mit Netzwerk Zugang, fügen Sie Authentifizierung über Reverse Proxy (nginx mit Basic Auth, etc.) hinzu.
Wie nutze ich Streaming mit Ollama OpenAI API?
Setzen Sie stream=True in Ihrem OpenAI Bibliotheks Aufruf. Ollama gibt Server-Sent Events (SSE) mit jedem Token zurück. In Python: for chunk in client.chat.completions.create(stream=True, ...): print(chunk.choices[0].delta.content).
Unterstützt Ollama Function Calling / Tool Use via API?
Ja, für Modelle die es unterstützen (Llama 4 Scout, Qwen3 8B, Gemma 4 9B, Mistral Small 3.1). Legacy Modelle (Llama 3.1 8B, Qwen2.5 7B) auch unterstützt. Übergeben Sie tools=[] im API Aufruf wie Sie es mit OpenAI täten. Ollama parst Tool Calls und gibt strukturiertes JSON zurück. Nicht alle Modelle unterstützen das -- schau Modell Dokumentation.
Was ist MCP und wie bezieht sich das auf OpenAI-kompatible API?
MCP (Model Context Protocol) ist standardisiertes Protokoll zum Verbinden von AI Modellen mit externen Tools und Datenquellen. Es basiert auf Function Calling — gleicher `tools=[]` Parameter wie oben -- aber fügt standardisierten Server-Client Architektur hinzu damit Tools entdeckbar und wiederverwendbar über Applikationen sind. Ollama unterstützt MCP-style Tool Interaktionen durch sein OpenAI-kompatibles Function Calling Endpoint. Für einfache Integrationen reichen Function Calling Beispiele hier. Für komplexe Multi-Tool Workflows bietet MCP strukturierteren Ansatz.
Unterschied zwischen Ollama /api/generate und /v1/chat/completions?
/api/generate ist Ollamas natives Single-Turn Endpoint. /v1/chat/completions ist OpenAI-kompatibles Multi-Turn Endpoint. Nutzen Sie /v1/chat/completions für alle neuen Projekte -- es unterstützt Konversations-History und ist kompatibel mit OpenAI Bibliotheken.
Kann ich vLLM als OpenAI-kompatible API nutzen?
Ja. vLLM läuft OpenAI-kompatible Server unter http://localhost:8000/v1 by default. Starten Sie mit: python -m vllm.entrypoints.openai.api_server --model mistralai/Mistral-7B-v0.1. Nutzen Sie gleichen Client Code wie Ollama.
Wie nutze ich Ollama API mit Node.js openai Package?
Importieren Sie OpenAI aus openai. Setzen Sie baseURL: "http://localhost:11434/v1" und apiKey: "ollama" im Constructor. Rufen Sie dann client.chat.completions.create() exakt wie mit echter OpenAI API auf -- keine anderen Änderungen nötig.
Wie wechsle ich zwischen Ollama und OpenAI in gleicher Codebase?
Nutzen Sie Umgebungsvariable: Setzen Sie USE_LOCAL=true für Ollama (base_url http://localhost:11434/v1, api_key "ollama") und USE_LOCAL=false für OpenAI. OpenAI Python Bibliothek akzeptiert base_url als Constructor Argument. Setzen Sie USE_LOCAL=false in Produktion um zu OpenAI zu wechseln ohne Code zu ändern.
Kann ich OpenAI-kompatible API mit LangChain nutzen?
Ja. Nutzen Sie ChatOpenAI mit base_url="http://localhost:11434/v1" und api_key="ollama". Das macht Ollama Drop-in Replacement für OpenAI in jedem LangChain Pipeline -- RAG Chains, Agents, und Tools funktionieren ohne Änderung. LangChain hat auch dedizierte ChatOllama Klasse für Ollama-spezifische Features.
Quellen
- Ollama. (2026). "Ollama OpenAI Compatibility." https://github.com/ollama/ollama/blob/main/docs/openai.md -- Offizielle Dokumentation für Ollama OpenAI-kompatible REST API Endpoints.
- LM Studio. (2026). "LM Studio Local Server." https://lmstudio.ai/docs/local-server -- Dokumentation für LM Studio OpenAI-kompatibler Local Server auf localhost:1234.
- OpenAI. (2024). "OpenAI Python Library." https://github.com/openai/openai-python -- Offizielle Python SDK um sich mit OpenAI und lokalen LLMs via base_url Override zu verbinden.
- vLLM Team. (2024). "vLLM OpenAI-Compatible Server." https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html -- vLLM OpenAI-kompatible API Server Docs (Port 8000, Produktions Nutzung).