Open WebUI für Automatisierung

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Open WebUI für Automatisierung behandelt

• Wie Du Open WebUI nicht nur als Chat-UI, sondern als Automatisierungs-Plattform nutzt.
• Wie Pipelines, Tools und Webhooks funktionieren.
• Wie Du Open WebUI mit n8n und anderen Systemen verbindest.
• Praxisbeispiele für Dokumentenverarbeitung, Recherche und Benachrichtigungen.
• Best Practices für Integration und Sicherheit.

Einleitung: Open WebUI für Automatisierung verständlich erklärt

Open WebUI ist bekannt als Chat-Oberfläche für Ollama. Aber es kann mehr: Pipelines für Custom-Logik, Tools für externe Aktionen, Webhooks für Event-Verarbeitung, RAG für Dokumente. Open WebUI wird so zu einer Automatisierungs-Plattform, nicht nur zu einem Chat.

Dieser Artikel richtet sich an Anwender, die Open WebUI für Automatisierung nutzen wollen. Grundlagen findest Du in Open WebUI und Ollama.

Warum brauche ich Open WebUI für Automatisierung?

Stell Dir vor, Du willst, dass ein KI-Chat nicht nur antwortet, sondern Aktionen ausführt: Dokumente verarbeiten, APIs aufrufen, Berichte erstellen. Open WebUI kann das, über Pipelines, die eigene Python-Logik in den Chat integrieren.

Open WebUI für Automatisierung kurz erklärt

Open WebUI bietet Pipelines (Python-Code, der bei jeder Nachricht läuft), Tools (Funktionen, die das Modell aufrufen kann) und Webhooks (HTTP-Endpoints für externe Events). Damit automatisierst Du Workflows direkt im Chat.

Der Kerngedanke lautet: Chat als Automatisierungs-Interface.

Für wen ist dieser Artikel gedacht?

• Open WebUI-Nutzer, die mehr als Chat wollen.
• Self-Hoster, die KI-Automatisierung lokal betreiben.
• Entwicklerinnen und Entwickler, die Pipelines und Tools bauen.
• Teams, die KI-Assistenten für Workflows nutzen.

Vorkenntnisse in Open WebUI und Python sind hilfreich.

Wichtige Begriffe

• Open WebUI - Chat-UI für Ollama. Wann nützlich: die Plattform.
• Pipelines - Python-Code in Open WebUI. Wann nützlich: für Custom-Logik.
• Tools - Funktionen für das Modell. Wann nützlich: für externe Aktionen.
• Webhooks - HTTP-Endpoints. Wann nützlich: für externe Events.
• RAG - Retrieval-Augmented Generation. Wann nützlich: für Dokumente.
• Ollama - Modellserver. Wann nützlich: das Backend.
• n8n - Workflow-Tool. Wann nützlich: für Orchestrierung.

Pipelines: Custom-Logik im Chat

Pipelines sind Python-Funktionen, die bei jeder Nachricht laufen. Sie können Nachrichten filtern, modifizieren oder externe Systeme aufrufen.

Einfache Pipeline

# pipelines/filter.py
class Pipeline:
    def __init__(self):
        self.name = "Automatisierungs-Pipeline"

    async def on_message(self, message, user):
        """Wird bei jeder Nachricht aufgerufen"""
        # Nachricht analysieren
        if "bericht" in message.lower():
            # Bericht-Workflow auslösen
            await self.trigger_workflow("bericht", message)
        return message

    async def trigger_workflow(self, typ, data):
        """Externen Workflow auslösen"""
        import aiohttp
        async with aiohttp.ClientSession() as session:
            await session.post(
                "http://n8n:5678/webhook/bericht",
                json={"typ": typ, "data": data}
            )

Pipeline installieren

# In Open WebUI:
# Admin Panel → Pipelines → Upload
# Datei: filter.py hochladen

# Oder via API:
curl -X POST http://open-webui:8080/pipelines/upload \
  -H "Authorization: Bearer ..." \
  -F "file=@filter.py"

Tools: Funktionen für das Modell

Tools sind Python-Funktionen, die das Modell aufrufen kann (Function Calling).

# tools/web_search.py
def web_search(query: str) -> str:
    """Sucht im Web nach Informationen."""
    import requests
    response = requests.get(
        "https://api.duckduckgo.com/",
        params={"q": query, "format": "json"}
    )
    return response.json().get("AbstractText", "Kein Ergebnis")

def get_weather(city: str) -> str:
    """Gibt das Wetter für eine Stadt zurück."""
    import requests
    response = requests.get(
        f"https://wttr.in/{city}?format=3"
    )
    return response.text

Tool in Open WebUI aktivieren

1. Admin Panel → Tools → New Tool
2. Python-Code einfügen
3. Speichern
4. Im Chat: Tool auswählen

Das Modell kann jetzt web_search() und get_weather() aufrufen.

Webhooks: Externe Events empfangen

Open WebUI kann Webhooks empfangen und Nachrichten generieren:

# Webhook-Endpoint in Open WebUI
# POST /api/v1/webhook

# Beispiel: n8n sendet Benachrichtigung
curl -X POST http://open-webui:8080/api/v1/webhook \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Neues Dokument wurde hochgeladen",
    "chat_id": "abc123"
  }'

Praxisbeispiel 1: Dokument verarbeiten

# Pipeline: Dokument automatisch verarbeiten
class Pipeline:
    async def on_file_upload(self, file, user):
        """Bei Datei-Upload"""
        if file.name.endswith(".pdf"):
            # PDF verarbeiten
            text = extract_pdf(file)
            summary = await self.summarize(text)
            # Als Nachricht posten
            return f"Zusammenfassung von {file.name}:\n\n{summary}"
        return None

    async def summarize(self, text):
        import aiohttp
        async with aiohttp.ClientSession() as s:
            async with s.post(
                "http://ollama:11434/api/chat",
                json={
                    "model": "llama3.1",
                    "messages": [
                        {"role": "user", "content": f"Fasse zusammen:\n{text[:4000]}"}
                    ]
                }
            ) as r:
                data = await r.json()
                return data["message"]["content"]

Praxisbeispiel 2: Chat → n8n Workflow

# Tool: n8n Workflow auslösen
def trigger_n8n_workflow(workflow_name: str, data: str) -> str:
    """Löst einen n8n Workflow aus."""
    import requests
    response = requests.post(
        f"http://n8n:5678/webhook/{workflow_name}",
        json={"input": data}
    )
    return response.text

# Der Nutzer schreibt im Chat:
# "Erstelle einen Bericht über lokale KI"
# → Das Modell ruft trigger_n8n_workflow("bericht", "lokale KI") auf
# → n8n führt den Workflow aus
# → Ergebnis kommt zurück

Praxisbeispiel 3: Automatische Antworten mit Kontext

# Pipeline: Kontext aus anderen Systemen hinzufügen
class Pipeline:
    async def on_message(self, message, user):
        """Bei jeder Nachricht Kontext hinzufügen"""
        # Aktuelle Dokumente aus Nextcloud holen
        docs = await self.get_recent_documents()

        # Kontext zur Nachricht hinzufügen
        enriched = f"{message}\n\nRelevante Dokumente:\n{docs}"
        return enriched

Open WebUI + n8n Integration

Open WebUI Chat
    │
    ▼ (Tool oder Pipeline)
HTTP Request → n8n Webhook
    │
    ▼
n8n Workflow:
  ├─ Daten verarbeiten
  ├─ Ollama für KI
  ├─ Datenbank abfragen
  └─ Ergebnis zurückgeben
    │
    ▼
Antwort in Open WebUI Chat

Sicherheitshinweise

• Pipelines prüfen: Pipelines haben vollen Zugriff. Nur vertrauenswürdigen Code hochladen.
• Tools absichern: Tools können beliebige Aktionen ausführen. Berechtigungen einschränken. Siehe Tool-Berechtigungen.
• Authentifizierung: Open WebUI mit Passwort schützen. Siehe Authentifizierung.
• Audit Logging: Protokolliere Pipeline- und Tool-Aufrufe. Siehe Audit Logging.

Typische Stolpersteine

• Pipelines blockieren: Langsame Pipelines verlangsamen den Chat. Asynchron nutzen.
• Tool-Beschreibungen: Das Modell nutzt die Docstring als Beschreibung. Präzise formulieren.
• Context-Länge: Zu viel Kontext überlastet das Modell. Truncaten.
• Keine Fehlerbehandlung: Wenn ein Tool fehlschlägt, sollte der Chat nicht abstürzen.
• Zu viele Tools: Mehr als 5-7 Tools verwirren das Modell.

Weiterführende Links

• Open WebUI - Open WebUI im Detail.
• Open WebUI RAG - RAG einrichten.
• Open WebUI Tools - Tools konfigurieren.
• Ollama - Modellserver.
• n8n - Workflow-Automatisierung.
• Lokales RAG - Dokumenten-Q&A.
• Function Calling - Tool-Calling.

Key Takeaways:

• Open WebUI ist mehr als Chat: Pipelines, Tools, Webhooks.
• Pipelines: Python-Code, der bei jeder Nachricht läuft.
• Tools: Funktionen, die das Modell aufrufen kann.
• Integration mit n8n und anderen Systemen über HTTP.
• Sicherheit: Pipelines prüfen, Tools absichern, Auth aktivieren.

FAQ

Quellen und weiterführende Literatur

• Open WebUI - Dokumentation.
• Open WebUI Pipelines - Pipeline-Docs.
• Ollama - Modellserver.
• n8n Webhooks - Webhook-Node.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert