Open WebUI & API-Schnittstelle
Uwe Rittmeyer
Durch den Einsatz von KI-Agenten ist es immer wichtiger, API-Schnittstellen zur Verfügung zu stellen. Insbesondere beim Einsatz von lokalen KI-Modellen ist eine saubere Architektur essenziell.
Die Open WebUI -API, als zentrale Kommunikations-Schnittstelle, orientiert sich an der Syntax der Anthropic Messages API, was eine hohe Kompatibilität mit bestehenden Client-Bibliotheken und Skripten ermöglicht.
Alternativ kann auch die HTTP-basiert Open WebUI -Schnittstelle verwendet werden, um Anfragen zu stellen – von
einfachen cURL-Befehlen bis hin zu komplexeren Implementierungen in gängigen Programmiersprachen wie JavaScript,
Python, Java uvm. Open WebUI verwaltet im Hintergrund die KI-Modelle. Ob lokale LLM's (wie hier in dem
Beispiel von gemma4:26b-mlx oder Cloud-Modellen,
die via API-Key in Open WebUI integriert werden.
Die Nutzung dieser API erlaubt es, lokale Modelle nicht nur über eine grafische Oberfläche, sondern direkt in eigene Anwendungen, Automatisierungen oder Skripte zu integrieren.
TL;DR
- Open WebUI stellt eine API bereit, die der Anthropic Messages API entspricht.
- Die Schnittstelle ist unabhängig von der gewählten Programmiersprache nutzbar (JavaScript, Python, Java, cURL).
- Für die Authentifizierung wird in der Regel ein API-Token benötigt, der in Open WebUI generiert wird.
- Der Basis-Endpunkt lautet standardmäßig
http://localhost:3000/api(z. B.https://open-webui.example.com/api).
API-Token in Open WebUI erstellen
Ist die API-Berechtigung aktiviert bzw. freigeschaltet, kann in den Benutzereinstellungen der API-Key erstellt werden:
Direkte Anfrage via cURL (no-stream)
Für schnelle Tests oder einfache Automatisierungen im Terminal eignet sich der Aufruf über cURL:
- Definition des Headers mit dem API-Key
- Angabe des Modells
- Übermittlung der Nachricht
OPEN_WEBUI_BASE_URL="https://open-webui.example.com/api"
OPEN_WEBUI_API_KEY="xxx"
curl -X POST ${OPEN_WEBUI_BASE_URL}/chat/completions \
-H "Authorization: Bearer ${OPEN_WEBUI_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"model": "gemma4:26b-mlx",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": "Warum ist der Himmel blau?"
}
]
}'
In diesem Beispiel wird das Modell gemma4:26b-mlx angesprochen. "stream": False ist die Standardeinstellung und
muss daher nicht angegeben werden.
Anwendung in JavaScript (Node.js)
Für JavaScript-Umgebungen kann das TypeScript SDK von Anthropic verwendet werden. Open WebUI stellt die erforderiche Kompatibilität bereit.
Pakete installieren:
# Install dependencies
npm install --save @anthropic-ai/sdk
npm install --save dotenv
Datei erstellen: .env.local
# Set environment variables
OPEN_WEBUI_BASE_URL="https://open-webui.example.com/api"
OPEN_WEBUI_API_KEY="xxx"
Datei erstellen: index.js
import Anthropic from "@anthropic-ai/sdk";
import path from "node:path";
import dotenv from "dotenv";
dotenv.config({path: path.join(path.dirname("."), '.env.local')});
const client = new Anthropic({
baseURL: process.env["OPEN_WEBUI_BASE_URL"],
apiKey: process.env["OPEN_WEBUI_API_KEY"],
});
async function callModel(){
const message = await client.messages.create({
model: "gemma4:26b-mlx",
max_tokens: 1024,
messages: [
{
role: "user",
content: "Warum ist der Himmel blau?"
}
]
});
if (!message || message.content.length <= 0) {
throw new Error("Report generation failed - received empty content");
}
console.log("content:", message.content);
}
callModel().then(() => { console.log("Done!");});
Anwendung in Java
Auch in Java-Umgebungen ist die Integration möglich, wenngleich hier oft eine etwas ausführlichere Syntax notwendig ist. Mit modernen HTTP-Clients, die in neueren Java-Versionen enthalten sind, lässt sich die Kommunikation effizient gestalten. (Alternativ kann auch hier das Java SDK von Anthropic verwendet werden.)
Gradle Projekt für Java erstellen:
Siehe Tutorials, z. B. hier: Creating a Gradle project (von Helen Scott, JetBrains)
Dependency hinzufügen: build.gradle
implementation("tools.jackson.core:jackson-databind:3.1.4")
Datei erstellen: LLMClient.java
import tools.jackson.core.JacksonException;
import tools.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
import java.util.Map;
public class LLMClient {
public static void main(String[] args) throws Exception {
String baseUrl = System.getProperty("OPEN_WEBUI_BASE_URL");
String apiKey = System.getProperty("OPEN_WEBUI_API_KEY");
// Create the HttpClient
HttpClient client = HttpClient.newHttpClient();
// Create the RequestBody
ObjectMapper mapper = new ObjectMapper();
Map<String, Object> message = Map.of(
"role", "user",
"content", "Warum ist der Himmel blau?"
);
Map<String, Object> payload = Map.of(
"model", "gemma4:26b-mlx",
"max_tokens", "1024",
"messages", List.of(message)
);
String jsonBody = mapper.writeValueAsString(payload);
// Create the HttpRequest
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(baseUrl))
.header("Content-Type", "application/json")
.header("Authorization", "Bearer " + apiKey)
.POST(HttpRequest.BodyPublishers.ofString(jsonBody))
.build();
// Send request to API
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
// Handle response
if (response.statusCode() == 200) {
System.out.println(response.body());
} else {
System.err.println("Fehler: " + response.statusCode());
}
}
}
Program ausführen (hier als Command line Beispiel):
java -DOPEN_WEBUI_BASE_URL="https://open-webui.example.com/api/chat/completions" -DOPEN_WEBUI_API_KEY="xxx" LLMClient
Oder vie "Run Configuration" in der IDE:
Anwendung in Phyton
Für Python stellt Anthropic ebenfalls das Python SDK bereit. Alternativ können auch in Python Http-Request abgesetzt werden und die Ergebnisse ausgewertet werden.
import requests
def chat_with_model():
baseUrl = 'https://open-webui.example.com/api/chat/completions'
apiKey = 'xxx'
headers = {
'Authorization': f'Bearer {apiKey}',
'Content-Type': 'application/json'
}
data = {
"model": "gemma4:26b-mlx",
"max_tokens": "1024",
"messages": [
{
"role": "user",
"content": "Why is the sky blue?"
}
]
}
response = requests.post(baseUrl, headers=headers, json=data)
return response.json()
Sicherheit und Best Practices
Bei der Nutzung lokaler APIs auf eigenen Servern sollten Sicherheitsaspekte beachtet werden. Zwar befindet sich der Dienst oft im lokalen Netzwerk, doch sollte der Zugriff durch Firewalls oder Netzwerkkonfigurationen eingeschränkt werden, falls das Gerät mit externen Netzwerken verbunden ist.
Die API-Tokens sollten niemals in Versionskontrollsystemen wie Git committed werden. Stattdessen empfiehlt sich die Verwendung von Umgebungsvariablen oder sicheren Secret-Managern.
Zudem ist die Wahl des richtigen Modells (model-Parameter) essenziell. Open WebUI muss wissen, welches Modell von Ollama geladen ist, um die Anfrage korrekt zu routen. Eine falsche Modellbezeichnung führt zu Fehlern auf Serverseite.
Fazit
Die API von Open WebUI bietet eine flexible Brücke zwischen lokalen LLM-Instanzen und externen Anwendungen. Durch die Orientierung an etablierten Standards wie der Anthropic Messages API sinkt die Einstiegshürde für Entwickler erheblich. Ob durch einfache Shell-Skripte, komplexe Python-Anwendungen oder Enterprise-Lösungen in Java – die Integration erfolgt über eine einheitliche Schnittstelle, die Stabilität und Leistungsfähigkeit lokaler KI-Modelle erschließt.
Happy AI-messaging 👨🏼💻👩🏻💻🚀