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.
- Aider, Cline und Roo Code verbinden sich alle über dieselbe base_url-Einstellung mit lokalen Modellen -- keine separate Integration nötig.
⚡ 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
KI-Coding-Tools: Aider, Cline und Roo Code unterstützen alle einen OpenAI-kompatiblen Provider-Modus über dieselbe base_url
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.3 8B und Qwen3 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}")
Wie verbinde ich Aider, Cline oder Roo Code mit einem lokalen Modell?
**Zeigen Sie Aider, Cline oder Roo Code auf dieselbe OpenAI-kompatible base_url, die auch sonst in diesem Guide verwendet wird -- `http://localhost:11434/v1` für Ollama oder `http://localhost:1234/v1` für LM Studio -- und nutzen Sie eine beliebige Zeichenfolge als API-Key.** Alle drei Tools unterstützen einen generischen "OpenAI Compatible"-Provider-Modus genau für diesen Fall.
Cline und Roo Code (ein Cline-Fork) teilen dasselbe Konfigurationsmuster: Öffnen Sie die Erweiterungseinstellungen in VS Code, wählen Sie den OpenAI-Compatible-API-Provider, geben Sie Base URL und einen beliebigen API-Key ein, und tragen Sie den exakten Modellnamen aus `ollama list` oder dem LM-Studio-Modell-Browser ein.
Aider verbindet sich über dieselbe OpenAI-kompatible Schicht mithilfe der Umgebungsvariablen `OPENAI_API_BASE` und `OPENAI_API_KEY` (oder der entsprechenden Kommandozeilen-Flags), die auf Ihren lokalen Server zeigen. Aider hat zudem native Ollama-Unterstützung über einen eigenen Provider-Präfix -- prüfen Sie die aktuelle Aider-Dokumentation für die bevorzugte Methode, da sich exakte Flag-Namen zwischen Releases ändern.
Nutzen Sie Aider, Cline oder Roo Code mit lokalen Modellen, wenn: Sie während der Entwicklung keine API-Kosten wollen, Ihr Code die Maschine nicht verlassen darf, oder Sie Prompts testen, bevor Sie für Produktion auf ein Cloud-Modell wechseln. Vermeiden Sie lokale Modelle in diesen Tools, wenn Sie längeres Kontext-Reasoning benötigen, als ein Modell mit 8-24 GB VRAM zuverlässig leisten kann -- wechseln Sie dann zu einem Cloud-Modell oder einem größeren lokalen Modell (Llama 4 Scout).
| Tool | Konfigurationsort | Lokale Base URL |
|---|---|---|
| Cline | VS Code Erweiterungseinstellungen → API Provider → OpenAI Compatible | http://localhost:11434/v1 (Ollama) oder :1234/v1 (LM Studio) |
| Roo Code | VS Code Erweiterungseinstellungen → API Provider (gleiches Muster wie Cline) | http://localhost:11434/v1 (Ollama) oder :1234/v1 (LM Studio) |
| Aider | OPENAI_API_BASE / OPENAI_API_KEY Umgebungsvariablen oder CLI-Flags | http://localhost:11434/v1 (Ollama) oder :1234/v1 (LM Studio) |
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 -- Eingabedaten verlassen das eigene Netzwerk nicht (kein Art.-44-DSGVO-Transferrisiko für Inferenzdaten).
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 Qwen3, 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.3 8B, Qwen3 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.
Wie nutze ich Aider mit einem lokalen Modell über Ollama oder LM Studio?
Zeigen Sie Aider über die Umgebungsvariablen OPENAI_API_BASE und OPENAI_API_KEY (oder die entsprechenden CLI-Flags) auf http://localhost:11434/v1 (Ollama) oder http://localhost:1234/v1 (LM Studio), mit beliebiger Zeichenfolge als Key. Aider hat zudem native Ollama-Unterstützung über einen eigenen Provider-Präfix -- prüfen Sie die Aider-Dokumentation für die aktuell bevorzugte Methode.
Können Cline oder Roo Code lokale Modelle über LM Studio oder Ollama nutzen?
Ja. Beide VS-Code-Erweiterungen bieten eine OpenAI-Compatible-Provider-Option in den Einstellungen. Tragen Sie http://localhost:11434/v1 (Ollama) oder http://localhost:1234/v1 (LM Studio) als Base URL, eine beliebige Zeichenfolge als API-Key und den exakten Modellnamen ein. Roo Code ist ein Cline-Fork und nutzt dasselbe Konfigurationsmuster.
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).