Lokale KI-Installation: Self-hosted AI Package Anleitung - Grams IT

Die digitale Landschaft verändert sich rasant, und künstliche Intelligenz (KI) ist längst kein Nischenphänomen mehr. Doch mit dem Aufstieg der Cloud-basierten KI-Dienste wachsen auch die Bedenken hinsichtlich Datenschutz, Datenhoheit und laufender Abonnementkosten. Hier kommt die Lokale KI-Installation ins Spiel – eine strategische Entscheidung, die Ihnen die volle Kontrolle über Ihre intelligenten Anwendungen gibt. Dieser umfassende Leitfaden stellt das „Self-hosted AI Package“ vor, ein leistungsstarkes Starter-Kit, das Ihnen den Einstieg in die Welt der selbstgehosteten KI erleichtert.

Warum Lokale KI-Installation? Vorteile des Self-hosted AI Package

Das „Self-hosted AI Package“, oft auch als „Self-hosted AI Starter Kit“ bezeichnet, ist eine offene Docker Compose-Vorlage, die darauf abzielt, eine voll ausgestattete lokale KI- und Low-Code-Entwicklungsumgebung schnell und effizient bereitzustellen. Es ist die ideale Lösung für alle, die Wert auf Datenhoheit, Privatsphäre und Kostenkontrolle legen.

Die Hauptvorteile der Lokalen Installation von KI-Lösungen sind vielfältig:

Volle Kontrolle über Ihre Daten: Ihre Daten verlassen niemals Ihre Server, was insbesondere für Unternehmen in regulierten Branchen oder mit sensiblen Informationen von entscheidender Bedeutung ist. Sie sind nicht von Drittanbietern oder deren Datenschutzrichtlinien abhängig.
Keine Abonnementkosten: Einmal eingerichtet, entfallen die wiederkehrenden Gebühren für Cloud-KI-Dienste. Dies führt zu erheblichen Kosteneinsparungen, insbesondere bei intensiver Nutzung oder Skalierung Ihrer KI-Anwendungen.
Maximale Privatsphäre: Da alle Prozesse und Daten lokal ablaufen, wird das Risiko von Datenlecks oder unerwünschter Datennutzung durch Dritte minimiert. Ihre Modelle und die damit verarbeiteten Informationen bleiben in Ihrer abgeschirmten Umgebung.
Anpassungsfähigkeit: Sie haben die Freiheit, die Umgebung nach Ihren spezifischen Bedürfnissen anzupassen und zu erweitern, ohne an die Einschränkungen von Cloud-Plattformen gebunden zu sein.
Geringere Latenz: Interaktionen mit Ihren KI-Modellen erfolgen lokal, was zu einer deutlich geringeren Latenz und einer schnelleren Verarbeitung führt.

Dieses Paket ist eine ausgezeichnete Wahl, um fundiert und sicher mit selbstgehosteter KI zu beginnen. Es bietet eine robuste und flexible Grundlage, die es Ihnen ermöglicht, innovative KI-Anwendungen zu entwickeln, ohne Kompromisse bei Sicherheit und Kosten eingehen zu müssen.

„Die Verlagerung von KI-Workloads in die eigene Infrastruktur ist ein wachsender Trend, der von dem Wunsch nach verbesserter Datensicherheit und der Vermeidung unkalkulierbarer Cloud-Kosten angetrieben wird“, so ein Branchenanalyst. „Das Self-hosted AI Package bietet hierfür einen hervorragenden Startpunkt.“

Wichtige enthaltene Komponenten für Ihre KI-Umgebung

Das „Self-hosted AI Package“ ist mehr als nur eine Sammlung von Tools; es ist ein durchdacht integrierter Stack, der alle essenziellen Komponenten für eine umfassende lokale KI-Entwicklung und -Nutzung vereint. Jedes Element spielt eine spezifische Rolle und trägt zur Leistungsfähigkeit und Flexibilität der Gesamtlösung bei.

Hier sind die Schlüsselkomponenten, die in diesem Paket integriert sind:

n8n: Dies ist eine leistungsstarke Low-Code-Plattform für die Workflow-Automatisierung. Mit über 1.200 vorgefertigten Integrationen und erweiterten KI-Komponenten ermöglicht n8n Ihnen, komplexe Arbeitsabläufe zu definieren, die Ihre lokalen KI-Modelle nutzen. Es dient als das zentrale Nervensystem für die Orchestrierung Ihrer KI-Agenten und die Verbindung verschiedener Dienste.
Ollama: Ollama ist eine plattformübergreifende Plattform, die das lokale Installieren und Ausführen der neuesten Large Language Models (LLMs) wie Llama, Mistral und andere vereinfacht. Es abstrahiert die Komplexität der Modellbereitstellung und macht LLMs auf Ihrer eigenen Hardware zugänglich.
Open WebUI: Eine intuitive, ChatGPT-ähnliche Benutzeroberfläche, die speziell für die private Interaktion mit Ihren lokalen KI-Modellen und n8n-Agenten entwickelt wurde. Sie bietet eine benutzerfreundliche Oberfläche für Chats, das Experimentieren mit Modellen und die Verwaltung von Konversationen, alles innerhalb Ihrer eigenen sicheren Umgebung.
Qdrant: Dieser quelloffene, hochleistungsfähige Vektorspeicher bietet eine umfassende API und ist ideal für Retrieval Augmented Generation (RAG)-Anwendungen. RAG-Anwendungen ermöglichen es, LLMs mit externen Datenquellen zu erweitern, um präzisere und relevantere Antworten zu generieren. Qdrant speichert die Vektoreinbettungen Ihrer Daten effizient.
PostgreSQL (mit pgvector): Ein robustes und weit verbreitetes Open-Source-Datenbankmanagementsystem. In Verbindung mit der pgvector-Erweiterung kann PostgreSQL auch für die Vektorsuche und zur Speicherung der Konversationshistorie Ihrer KI-Anwendungen genutzt werden, was es zu einer vielseitigen Komponente macht.
Flowise: Ein weiterer No-Code/Low-Code-Agent-Builder, der speziell für die Entwicklung von LLM-Anwendungen konzipiert ist. Flowise ergänzt n8n hervorragend und bietet zusätzliche Möglichkeiten zur visuellen Erstellung und Konfiguration von KI-Agenten.
SearXNG: Eine quelloffene Metasuchmaschine für das Internet. SearXNG aggregiert Ergebnisse von vielen Suchdiensten, ohne Nutzer zu verfolgen. Dies ist besonders nützlich für KI-Agenten, die Zugang zu aktuellen Informationen aus dem Internet benötigen, ohne die Privatsphäre zu kompromittieren.
Caddy: Ein leistungsstarker, Open-Source-Webserver mit automatischer HTTPS-Verwaltung. Caddy wird in diesem Paket für verwaltetes HTTPS/TLS für benutzerdefinierte Domänen verwendet, was die Sicherheit Ihrer lokalen KI-Dienste erhöht.
Supabase: Eine quelloffene Datenbank als Dienst, die häufig für KI-Agenten verwendet wird. Supabase bietet eine Reihe von Funktionen, darunter Authentifizierung, Echtzeit-Datenbank und Speicherung, die für die Entwicklung robuster KI-Anwendungen von Vorteil sein können.
Neo4j: Eine führende Knowledge-Graph-Engine. Neo4j ist ideal, um komplexe Beziehungen und Kontextinformationen zu speichern und abzufragen, was Tools wie GraphRAG antreibt und die Qualität der KI-Antworten durch ein besseres Verständnis von Wissen verbessert.
Langfuse: Eine quelloffene LLM-Engineering-Plattform, die für die Beobachtbarkeit von Agenten entwickelt wurde. Langfuse hilft Ihnen, die Leistung Ihrer KI-Agenten zu überwachen, Fehler zu beheben und deren Verhalten zu analysieren, was für die Optimierung und Wartung von KI-Anwendungen unerlässlich ist.

Diese sorgfältig ausgewählten und integrierten Komponenten bilden die Grundlage für eine leistungsstarke und flexible Lokale KI-Installation. Sie ermöglichen es Ihnen, komplexe KI-Workflows zu erstellen, mit großen Sprachmodellen zu interagieren und datenschutzkonforme Anwendungen zu entwickeln – alles in Ihrer eigenen Umgebung.

Voraussetzungen für die Lokale KI-Installation

Bevor Sie mit der Anleitung zur Lokalen KI-Installation des „Self-hosted AI Package“ beginnen können, ist es entscheidend, dass Ihr System die notwendigen Voraussetzungen erfüllt. Diese Tools bilden das Fundament, auf dem Ihre gesamte KI-Umgebung aufgebaut wird.

Stellen Sie sicher, dass die folgende Software auf Ihrem System installiert und korrekt konfiguriert ist:

Python:
- Notwendigkeit: Python ist erforderlich, um das zentrale Setup-Skript start_services.py auszuführen, das den Start und die Konfiguration der verschiedenen Dienste im Paket verwaltet.
- Installation: Laden Sie die neueste stabile Version von Python von der offiziellen Website (Python.org) herunter und folgen Sie den Installationsanweisungen für Ihr Betriebssystem. Vergewissern Sie sich, dass Python zu Ihrem System-PATH hinzugefügt wurde.
Git / GitHub Desktop:
- Notwendigkeit: Git ist ein verteiltes Versionskontrollsystem, das zum Klonen und Verwalten des Repositorys für das „Self-hosted AI Package“ unerlässlich ist. Wenn Sie eine grafische Oberfläche bevorzugen, ist GitHub Desktop eine ausgezeichnete Wahl.
- Installation Git: Laden Sie Git von der offiziellen Website (Git-SCM.com) herunter.
- Installation GitHub Desktop: Laden Sie GitHub Desktop von der offiziellen Website (Desktop.GitHub.com) herunter.
Docker / Docker Desktop:
- Notwendigkeit: Docker ist die zentrale Technologie dieses Pakets. Es ermöglicht das Ausführen aller Dienste in isolierten Containern, was die Bereitstellung, Skalierung und Verwaltung der Anwendungen erheblich vereinfacht. Docker Desktop bietet eine benutzerfreundliche Oberfläche für Windows und macOS.
- Installation: Besuchen Sie die offizielle Docker-Website (Docker.com/products/docker-desktop) und laden Sie Docker Desktop für Ihr Betriebssystem herunter. Folgen Sie den detaillierten Installationsanweisungen. Stellen Sie sicher, dass Docker nach der Installation korrekt läuft (z.B. indem Sie docker run hello-world in Ihrem Terminal ausführen).

„Robuste Containerisierung mit Docker ist der Schlüssel zur Portabilität und Reproduzierbarkeit komplexer Software-Stacks wie dem Self-hosted AI Package“, bemerkt ein führender Software-Architekt. „Es eliminiert ‚Dependency Hell‘ und beschleunigt die Bereitstellung.“

Die Erfüllung dieser Voraussetzungen ist ein entscheidender erster Schritt, um sicherzustellen, dass Ihre Lokale KI-Installation reibungslos verläuft. Nehmen Sie sich die Zeit, jede Komponente korrekt zu installieren und zu testen, bevor Sie mit den eigentlichen Installationsschritten fortfahren.

Schritt-für-Schritt-Anleitung zur Installation

Nachdem alle Voraussetzungen erfüllt sind, können Sie mit der eigentlichen Anleitung zur Lokalen KI-Installation des „Self-hosted AI Package“ beginnen. Die Installation erfolgt primär über Docker Compose, um alle Komponenten konsistent zu starten und zu verwalten.

1. Repository klonen

Der erste Schritt besteht darin, das Projekt-Repository auf Ihr lokales System zu bringen.

Öffnen Sie Ihr Terminal (macOS/Linux) oder Ihre Kommandozeile (Windows).
Navigieren Sie zu dem Verzeichnis, in dem Sie das Paket speichern möchten (z.B. cd Documents).
Klonen Sie das Repository mit dem folgenden Befehl:git clone https://github.com/coleam00/local-ai-packaged.git cd local-ai-packagedHinweis: Wenn Sie die Originalversion von n8n.io verwenden möchten, ersetzen Sie coleam00/local-ai-packaged.git durch https://github.com/n8n-io/self-hosted-ai-starter-kit.git. Achten Sie darauf, dass der Klonbefehl dann auch in das entsprechende neue Verzeichnis (self-hosted-ai-starter-kit) wechselt.

2. Umgebungsvariablen einrichten

Die Konfiguration der Umgebungsvariablen ist entscheidend für die korrekte Funktion der Dienste.

Kopieren Sie die Datei .env.example im Stammverzeichnis des Projekts und benennen Sie sie in .env um. Dies kann manuell im Dateiexplorer oder über das Terminal erfolgen:cp .env.example .env # Für Linux/macOS copy .env.example .env # Für Windows
Öffnen Sie die neu erstellte .env-Datei mit einem Texteditor (z.B. VS Code, Notepad++, Sublime Text).
Bearbeiten Sie diese Datei, um die erforderlichen Umgebungsvariablen festzulegen. Achten Sie besonders auf die Variablen für n8n, Supabase und Neo4j.
- Wichtig für n8n-Verschlüsselungsschlüssel: Da alles lokal läuft, können Sie für den n8n-Verschlüsselungsschlüssel (N8N_ENCRYPTION_KEY) eine beliebige alphanumerische Zeichenkette verwenden. Es muss kein komplexer, sicherer Schlüssel sein, da er nur für interne Verschlüsselung innerhalb Ihrer lokalen Umgebung dient.
- Überprüfen Sie alle anderen Variablen und passen Sie sie bei Bedarf an Ihre Präferenzen an (z.B. Datenbank-Passwörter, Benutzernamen).

3. Dienste starten

Das Projekt enthält ein Skript start_services.py, das den Start der Dienste verwaltet und GPU-Konfigurationen berücksichtigt.

Stellen Sie sicher, dass Sie sich im geklonten Verzeichnis befinden (cd local-ai-packaged).
Führen Sie das Skript mit dem --profile-Flag aus, um Ihre GPU-Konfiguration anzugeben:
- Für Nvidia GPU-Benutzer:python start_services.py --profile nvidiaBeachten Sie: Wenn Sie Ihre Nvidia GPU noch nicht mit Docker verwendet haben, müssen Sie möglicherweise zusätzliche Schritte ausführen. Befolgen Sie die Offiziellen Ollama Docker-Anweisungen für die Einrichtung des Nvidia Container Toolkits, um sicherzustellen, dass Docker Ihre GPU korrekt nutzen kann.
- Für AMD GPU-Benutzer unter Linux:python start_services.py --profile amd
- Alternative für alle ohne GPU oder für Mac-Benutzer, die Ollama lokal ausführen wollen:python start_services.py --profile cpuDieser Befehl startet alle Dienste und verwendet die CPU für LLM-Berechnungen, falls keine kompatible GPU erkannt oder gewünscht wird.
- Hinweis für Mac-Benutzer, die Ollama lokal ausführen: Wenn Sie Ollama nicht im Docker-Container, sondern nativ auf Ihrem Mac installieren und ausführen möchten, müssen Sie die OLLAMA_HOST-Umgebungsvariable in der n8n-Dienstkonfiguration in Ihrer docker-compose.yml-Datei anpassen. Suchen Sie den n8n-Dienst und ändern Sie die Variable zu:# Beispielausschnitt in docker-compose.yml für n8n-Dienst services: n8n: environment: - OLLAMA_HOST=host.docker.internal:11434Dieser Schritt ist entscheidend, damit n8n mit der nativen Ollama-Installation kommunizieren kann.
Der Startvorgang wird die erforderlichen Docker-Images herunterladen (falls noch nicht vorhanden) und die Container nacheinander starten. Dieser Vorgang kann je nach Internetgeschwindigkeit und Systemleistung einige Minuten in Anspruch nehmen. Geduld ist hier gefragt!

4. LLM-Modelle herunterladen (optional, aber empfohlen)

Nachdem Ollama erfolgreich läuft, können Sie die Large Language Models herunterladen, die Sie verwenden möchten.

Im Beispiel-Setup des coleam00/local-ai-packaged Repositorys werden standardmäßig llama3.1 (oder llama3.2) und nomic-embed-text heruntergeladen, wenn Sie das Skript start_services.py zum Starten verwenden.
Sie können dies auch manuell tun, indem Sie einen Befehl im Ollama-Container ausführen. Um beispielsweise das llama2-Modell herunterzuladen, können Sie folgenden Befehl im Terminal ausführen, nachdem Ihre Dienste gestartet sind:docker exec -it ollama ollama pull llama2Ersetzen Sie llama2 durch den Namen des gewünschten Modells. Eine Liste der verfügbaren Modelle finden Sie auf der Ollama Model Library.

Diese Schritte bilden die Grundlage Ihrer Lokalen KI-Installation. Sobald alle Dienste laufen und Ihre LLM-Modelle heruntergeladen sind, können Sie mit der Konfiguration der einzelnen Komponenten beginnen.

Erste Konfiguration und Nutzung Ihrer KI-Umgebung

Nachdem der gesamte KI-Stack über Docker Compose erfolgreich gestartet wurde, sind die einzelnen Komponenten über Ihre Webbrowser zugänglich. Dies ist der Zeitpunkt, an dem Sie die Initialkonfiguration vornehmen, um Ihre Lokale Installation der KI-Dienste voll funktionsfähig zu machen.

1. n8n einrichten

n8n ist das Herzstück für die Workflow-Automatisierung und KI-Agenten.

Öffnen Sie Ihren Webbrowser und navigieren Sie zu: http://localhost:5678/
Beim ersten Zugriff werden Sie aufgefordert, ein lokales Konto für Ihre n8n-Instanz zu erstellen. Es ist wichtig zu verstehen, dass dies ein Konto ist, das ausschließlich für Ihre Lokale Installation gedacht ist und keinerlei Verbindung zu einem n8n-Cloud-Konto hat. Alle Ihre Daten und Workflows bleiben sicher auf Ihren Servern.
Wichtiger Hinweis: Wenn Sie das coleam00/local-ai-packaged Repository geklont und gestartet haben, finden Sie den Local RAG AI Agent workflow bereits automatisch in Ihrer n8n-Instanz vorinstalliert. Dies ist eine hervorragende Ausgangsbasis, um die Funktionen von RAG zu erkunden.

2. Open WebUI einrichten

Open WebUI bietet eine benutzerfreundliche Schnittstelle zur Interaktion mit Ihren lokalen LLMs.

Öffnen Sie einen neuen Tab in Ihrem Browser und navigieren Sie zu: http://localhost:3000/
Ähnlich wie bei n8n müssen Sie hier ein Admin-Konto erstellen. Auch dieses Konto ist ausschließlich für Ihre lokale Instanz von Open WebUI bestimmt.
Wichtig: Wenn Open WebUI Modelle von Ihrem lokal installierten Ollama (d.h. Ollama läuft nativ auf Ihrem Host-System und nicht im Docker-Container) ziehen soll, müssen Sie die Ollama API-URL anpassen.
- Navigieren Sie in Open WebUI nach der Anmeldung zu: Admin Panel > Settings > Connections.
- Ändern Sie die Ollama API-URL zu http://ollama:11434. Dies ist der interne Docker-Netzwerkname des Ollama-Containers, der es Open WebUI ermöglicht, den Ollama-Dienst innerhalb des Docker-Netzwerks zu finden.
- Falls Sie Ollama nicht als Docker-Container, sondern nativ auf Ihrem Mac oder Linux-Host betreiben, müsste die URL http://host.docker.internal:11434 lauten, da host.docker.internal der Weg ist, wie Docker-Container auf Dienste zugreifen, die auf dem Host-System laufen.

Diese ersten Konfigurationsschritte sind entscheidend, um die einzelnen Komponenten Ihrer Lokalen KI-Installation zugänglich und miteinander kommunikationsfähig zu machen. Mit n8n und Open WebUI einsatzbereit, können Sie nun tiefer in die Konfiguration Ihrer KI-Workflows und die Interaktion mit Ihren LLMs eintauchen.

n8n für lokale KI konfigurieren: Workflows & Integrationen

n8n ist das Kraftpaket dieses Stacks, wenn es darum geht, Ihre lokalen KI-Dienste miteinander zu verbinden und intelligente Workflows zu erstellen. Die korrekte Konfiguration der Anmeldeinformationen und die Einrichtung von Wissensbasen sind entscheidend für effektive RAG-Anwendungen und KI-Agenten.

1. Ollama-Anmeldeinformationen in n8n einrichten

Um n8n mit Ihrem lokalen Ollama-Dienst zu verbinden, müssen Sie die entsprechenden Anmeldeinformationen hinterlegen.

Gehen Sie in n8n entweder zu Credentials (Anmeldeinformationen) im linken Navigationsbereich oder wählen Sie im AI Agent Node die Option zum Erstellen neuer Anmeldeinformationen.
Suchen Sie nach dem Ollama Credential-Typ.
Base URL: Die Base URL für Ollama sollte http://ollama:11434 sein, da ollama der interne Docker-Container-Name ist. Dies ermöglicht die Kommunikation zwischen den n8n– und Ollama-Containern im Docker-Netzwerk.
Alternative (Ollama außerhalb von Docker): Wenn Sie Ollama außerhalb von Docker (z.B. nativ auf Ihrem Mac oder Linux-System) betreiben, verwenden Sie stattdessen http://host.docker.internal:11434/v1. Der v1-Suffix ist wichtig, da dies der Standard-API-Endpunkt für Ollama ist, wenn es auf dem Host-System läuft und von einem Container aus angesprochen wird.
Modellauswahl: Wählen Sie Ihr gewünschtes Modell (z.B. llama3.2, llama2, mistral) aus der Liste der zuvor heruntergeladenen Modelle. Stellen Sie sicher, dass das Modell in Ihrer Ollama-Instanz verfügbar ist.

2. PostgreSQL-Anmeldeinformationen in n8n einrichten

PostgreSQL dient als robuste Datenbank, die auch für die Vektorsuche (pgvector) genutzt werden kann.

Erstellen Sie neue Anmeldeinformationen für PostgreSQL in n8n.
Hostname: Der Hostname ist postgres (der interne Docker-Container-Name).
Geben Sie den User, das Password und den Database Name an, die Sie zuvor in Ihrer .env-Datei festgelegt haben. Diese müssen exakt übereinstimmen.

3. Qdrant-Anmeldeinformationen in n8n einrichten

Qdrant ist Ihr hochleistungsfähiger Vektorspeicher, essenziell für RAG-Anwendungen.

Erstellen Sie neue Anmeldeinformationen für Qdrant in n8n.
API-Schlüssel: Die API-Schlüssel sind für lokale Installationen nicht relevant, da die Authentifizierung innerhalb des Docker-Netzwerks normalerweise nicht erforderlich ist. Sie können hier beliebige Werte eingeben oder das Feld leer lassen, wenn dies zulässig ist.
URL: Die URL ist http://qdrant:6333 (interne Docker-Kommunikation). Dies ist der Standard-Port, auf dem Qdrant innerhalb des Docker-Netzwerks lauscht.

4. Wissensdatenbank für RAG-Anwendungen einrichten

Um Dokumente in Ihre Vektordatenbank zu laden und somit die Grundlage für RAG-Anwendungen zu schaffen, müssen Sie einen n8n-Workflow erstellen.

Workflow-Trigger: Beginnen Sie einen neuen Workflow mit einem geeigneten Trigger, z.B.:
- On Form Submission: Wenn Sie Dokumente über ein Webformular hochladen möchten.
- Local File Trigger: Wenn Sie Dokumente von Ihrem lokalen Dateisystem verarbeiten möchten.
- HTTP Request: Um Dokumente über eine API zu empfangen.
Datenverarbeitungskette: Verbinden Sie die folgenden Nodes in einer Kette:
- Default Data Loader: Zum Laden der Dokumente (z.B. PDFs, Textdateien).
- Recursive Character Text Splitter: Zum Zerlegen der Dokumente in kleinere „Chunks“ (Textabschnitte). Dies ist wichtig, da LLMs nur eine begrenzte Eingabelänge haben und präzisere Antworten auf kleinere, relevante Textabschnitte geben können.
- Embeddings Ollama: Zum Erstellen von Vektoreinbettungen aus den Text-Chunks unter Verwendung Ihres Ollama-Modells (z.B. nomic-embed-text). Diese Einbettungen repräsentieren die semantische Bedeutung der Textabschnitte.
- PostgreSQL PG Vector Store oder Qdrant Vector Store: Zum Speichern der generierten Embeddings und der zugehörigen Metadaten (z.B. ursprünglicher Text, Dokumentenname) in Ihrer gewählten Vektordatenbank.
Tabellenname-Konsistenz: Stellen Sie unbedingt sicher, dass der Tabellenname, den Sie im Vector Store Node festlegen (z.B. n8n_tutorial), mit dem im AI Agent Node konfigurierten Tabellennamen übereinstimmt. Andernfalls kann der AI Agent die Daten nicht finden.
Wichtiger Hinweis zur Datenqualität:
- Das „dumme Zerlegen“ von Dokumenten (einfaches Chunking nach Zeichenanzahl) kann zu schlechten RAG-Ergebnissen führen, da wichtige Kontextinformationen in Textabschnitten verloren gehen können.
- Erwägen Sie fortgeschrittenere Preprocessing-Schritte:
  - Konvertierung von PDFs/DOCX in Markdown oder reinen Textformaten, um strukturelle Informationen zu erhalten.
  - Verwendung von Tools wie Apache Tika oder Unstructured.io für intelligentere Dokumentenanalyse und -extraktion.
  - Experimentieren Sie mit verschiedenen Chunking-Strategien (z.B. semantisches Chunking, Parent-Child-Chunking).

Beispiel (importierbare n8n Workflow Datei):

{
  "nodes": [
    {
      "parameters": {},
      "id": "e2293026-64e0-4a82-bb3a-d6e0c65c82c3",
      "name": "Start (Manuell Auslösen)",
      "type": "n8n-nodes-base.triggerButton",
      "typeVersion": 1,
      "position": [
        400,
        200
      ]
    },
    {
      "parameters": {
        "text": "Dies ist ein Beispieltext für Ihre Wissensdatenbank. Er könnte aus einem Dokument oder einer Webseite stammen. Die lokale KI-Installation ist ein Schlüsselthema, das hier behandelt wird, und bietet Vorteile wie Datenschutz und Kostenersparnis. Der Umgang mit Datenqualität ist entscheidend für gute RAG-Ergebnisse.",
        "options": {}
      },
      "id": "b2c1d3e4-5f6a-7b8c-9d0e-1f2a3b4c5d6e",
      "name": "Dokument laden (Beispieltext)",
      "type": "n8n-nodes-base.set",
      "typeVersion": 1,
      "position": [
        650,
        200
      ]
    },
    {
      "parameters": {
        "chunkSize": 1000,
        "chunkOverlap": 200,
        "options": {}
      },
      "id": "a1b2c3d4-e5f6-7890-1234-56789abcdef0",
      "name": "Text zerlegen (Chunking)",
      "type": "n8n-nodes-langchain.textSplittersRecursiveCharacterTextSplitter",
      "typeVersion": 1,
      "position": [
        900,
        200
      ]
    },
    {
      "parameters": {
        "ollamaConnectionId": "YOUR_OLLAMA_CREDENTIAL_ID",
        "model": "nomic-embed-text",
        "options": {}
      },
      "id": "f0e1d2c3-b4a5-6789-0123-456789abcdef",
      "name": "Einbettungen erstellen (Ollama)",
      "type": "n8n-nodes-ollama.ollamaEmbeddings",
      "typeVersion": 1,
      "position": [
        1150,
        200
      ]
    },
    {
      "parameters": {
        "databaseConnectionId": "YOUR_POSTGRES_CREDENTIAL_ID",
        "tableName": "n8n_rag_data",
        "options": {}
      },
      "id": "c1a2b3d4-e5f6-7890-1234-567890abcdef",
      "name": "In Vector Store speichern (PostgreSQL)",
      "type": "n8n-nodes-langchain.vectorStoresPostgresJsVectorStore",
      "typeVersion": 1,
      "position": [
        1400,
        200
      ]
    }
  ],
  "connections": {
    "Start (Manuell Auslösen)": [
      {
        "node": "Dokument laden (Beispieltext)",
        "type": "main",
        "index": 0
      }
    ],
    "Dokument laden (Beispieltext)": [
      {
        "node": "Text zerlegen (Chunking)",
        "type": "main",
        "index": 0
      }
    ],
    "Text zerlegen (Chunking)": [
      {
        "node": "Einbettungen erstellen (Ollama)",
        "type": "main",
        "index": 0
      }
    ],
    "Einbettungen erstellen (Ollama)": [
      {
        "node": "In Vector Store speichern (PostgreSQL)",
        "type": "main",
        "index": 0
      }
    ]
  },
  "active": false,
  "versionId": "df1b8b0e-f0c0-4e78-9a21-1b2c3d4e5f6a",
  "triggerCount": 0
}
```
Dieser n8n-Workflow enthält folgende Schritte:

1.  **Start (Manuell Auslösen)**: Ein manueller Trigger, um den Workflow einfach zu starten.
2.  **Dokument laden (Beispieltext)**: Ein "Set"-Node, der einen Beispieltext enthält. In einer realen Anwendung würden Sie diesen Node durch einen "Default Data Loader" (um Dateien zu laden), einen "HTTP Request"-Node oder einen anderen Daten-Node ersetzen, um Ihre tatsächlichen Dokumente zu laden.
3.  **Text zerlegen (Chunking)**: Zerlegt den Text in kleinere Abschnitte (Chunks), die für Large Language Models besser verarbeitbar sind.
4.  **Einbettungen erstellen (Ollama)**: Verwendet Ihren lokalen Ollama-Dienst (mit dem Modell `nomic-embed-text`) um Vektoreinbettungen für die Text-Chunks zu generieren.
5.  **In Vector Store speichern (PostgreSQL)**: Speichert die generierten Einbettungen und Metadaten im PostgreSQL Vector Store. Sie können dies auch auf Qdrant umstellen, falls Sie Qdrant verwenden.

**Wichtige Hinweise zur Verwendung:**

* **Anmeldeinformationen ersetzen**: Sie müssen die Platzhalter `YOUR_OLLAMA_CREDENTIAL_ID` und `YOUR_POSTGRES_CREDENTIAL_ID` in den entsprechenden Nodes durch die tatsächlichen IDs Ihrer in n8n konfigurierten Ollama- und PostgreSQL-Anmeldeinformationen ersetzen. Diese finden Sie in n8n unter "Credentials".
* **Modellname**: Stellen Sie sicher, dass das in `Einbettungen erstellen (Ollama)` genannte Modell (`nomic-embed-text`) auf Ihrer Ollama-Instanz heruntergeladen und verfügbar ist.
* **Tabellenname**: Passen Sie den `tableName` im Node `In Vector Store speichern (PostgreSQL)` bei Bedarf an.

Sie können diese JSON-Datei in Ihre n8n-Instanz importieren, indem Sie in der n8n-Benutzeroberfläche auf "Workflows" gehen und dann die Import-Option nutz

„Die Qualität der Einbettungen ist direkt proportional zur Effektivität einer RAG-Anwendung. Eine sorgfältige Datenvorbereitung, insbesondere das Chunking, ist kein optionaler Schritt, sondern eine Notwendigkeit für präzise Ergebnisse“, so ein KI-Forscher.

5. Tools zu Ihrem AI Agent hinzufügen (optional)

Im AI Agent Node in n8n können Sie verschiedene Tools hinzufügen, die Ihr LLM nutzen kann, um seine Fähigkeiten zu erweitern. Dies ermöglicht es dem KI-Agenten, Aktionen auszuführen oder Informationen abzurufen, die über sein reines Sprachverständnis hinausgehen.

Beispiele für Tools:
- Calculator Tool: Ermöglicht dem KI-Agenten, mathematische Berechnungen durchzuführen.
- SER API (für Websuchen): Integrieren Sie eine Such-API (z.B. über SearXNG), damit Ihr Agent auf aktuelle Informationen aus dem Internet zugreifen kann.
- n8n bietet Integrationen für eine Vielzahl von Diensten wie Gmail, Airtable, Slack, CRM-Systeme und viele andere. Jede dieser Integrationen kann als „Tool“ für Ihren KI-Agenten dienen, sodass er E-Mails senden, Datenbankeinträge aktualisieren oder Nachrichten verschicken kann.
Konfigurieren Sie die entsprechenden Anmeldeinformationen für diese Tools in n8n, genau wie Sie es für Ollama und PostgreSQL getan haben.

Durch die sorgfältige Konfiguration von n8n-Anmeldeinformationen, den Aufbau von Wissensbasen und die Integration von Tools schaffen Sie eine leistungsstarke und vielseitige Umgebung für Ihre Lokale KI-Installation. Dies bildet die Grundlage für die Entwicklung komplexer und nützlicher KI-Anwendungen, die auf Ihren eigenen Daten und Systemen basieren.

Integration von n8n-Workflows mit Open WebUI

Die nahtlose Integration Ihrer n8n-Workflows mit Open WebUI ist ein entscheidender Schritt, um Ihre KI-Agenten über eine benutzerfreundliche Chat-Schnittstelle zugänglich zu machen. Dies ermöglicht die direkte Interaktion mit Ihren intelligenten Systemen.

1. „Community packages allow tool usage“ in n8n aktivieren

Bevor Open WebUI n8n-Agenten als Tools nutzen kann, müssen Sie eine bestimmte Umgebungsvariable in n8n aktivieren.

Wenn Sie ls.io-Hosting verwenden (oder eine ähnliche verwaltete Docker-Umgebung):
- Gehen Sie zu Ihrem n8n-Dienst und klicken Sie auf Update config > Docker Compose.
- Fügen Sie die Umgebungsvariable N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE mit dem Wert true hinzu.
Wenn Sie Docker Compose manuell bearbeiten:
- Öffnen Sie Ihre docker-compose.yml-Datei im Projektverzeichnis.
- Suchen Sie den n8n-Dienst und fügen Sie die Umgebungsvariable im environment-Abschnitt hinzu:
services: n8n: environment: - N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true # ... weitere n8n KonfigurationenNach dieser Änderung müssen Sie den n8n-Container neu starten, damit die Änderung wirksam wird. Dies kann über docker-compose restart n8n oder einen kompletten Neustart des Stacks erfolgen.

2. n8n-Pipe-Funktion in Open WebUI einrichten

Die „n8n pipe“-Funktion in Open WebUI ermöglicht es, Anfragen an Ihre n8n-Agenten weiterzuleiten und deren Antworten zu empfangen.

Navigieren Sie in Open WebUI zu Workspace (oben links in der Navigationsleiste) > Functions.
Sie können die vorgefertigte „n8n pipe“-Funktion importieren. Eine solche Funktion finden Sie beispielsweise im GitHub-Repository von Cole Medins, das oft als Referenz für das „Self-hosted AI Package“ dient. Suchen Sie nach einer n8n-pipe.json oder einer ähnlichen Datei.
Konfigurieren Sie die URL in der Funktion: Dies ist ein kritischer Schritt für die Inter-Container-Kommunikation. Stellen Sie sicher, dass die n8n_url in der Open WebUI-Funktionskonfiguration auf den internen Docker-Hostnamen von n8n zeigt:
- http://n8n:5678/webhook/invoke_n8n_agent (oder den von Ihnen gewählten Pfad für den Webhook-Endpunkt Ihres n8n-Agenten).
- Verwenden Sie n8n statt localhost für die Kommunikation zwischen den Containern. localhost würde innerhalb des Open WebUI-Containers auf sich selbst verweisen und nicht auf den n8n-Container.
n8n-Webhook-Trigger Konfiguration: Stellen Sie in Ihrem n8n-Workflow (insbesondere im Webhook-Trigger, der von Open WebUI aufgerufen wird) sicher, dass die Respond from-Einstellung auf Using respond to webhook node gesetzt ist. Dies gewährleistet eine korrekte bidirektionale Kommunikation und stellt sicher, dass die Antwort des KI-Agenten an Open WebUI zurückgesendet wird.

3. Agenten in Open WebUI nutzen

Nachdem die „n8n pipe“-Funktion in Open WebUI korrekt konfiguriert und aktiviert ist, können Sie Ihre n8n-Agenten direkt im Chat nutzen.

Starten Sie einen neuen Chat in Open WebUI.
Aus der Modellauswahl (typischerweise ein Dropdown-Menü am oberen Rand des Chats) können Sie nun den „n8n pipe“-Modell oder den spezifischen Agenten auswählen, den Sie konfiguriert haben.
Sie können nun direkt mit Ihrem n8n-Agenten chatten, Fragen stellen und sehen, wie er die hinterlegten Workflows und Tools nutzt, um Antworten zu generieren.
Dies ermöglicht auch die Nutzung von Sprachchat-Funktionen von Open WebUI (falls aktiviert und konfiguriert) mit Ihren n8n-Agenten, was eine noch intuitivere Interaktion ermöglicht.

Die Integration von n8n und Open WebUI ist ein Paradebeispiel für die Flexibilität und Interoperabilität, die das „Self-hosted AI Package“ für Ihre Lokale KI-Installation bietet. Sie können komplexe KI-Logik in n8n entwickeln und diese dann über eine einfache, leistungsstarke Benutzeroberfläche zugänglich machen.

Herausforderungen und Überlegungen bei der lokalen KI-Installation

Die Lokale KI-Installation mit dem „Self-hosted AI Package“ bietet zahlreiche Vorteile, bringt aber auch bestimmte Herausforderungen und Überlegungen mit sich, die Sie kennen sollten, um eine reibungslose und effiziente Umgebung zu gewährleisten.

1. Hardware-Anforderungen

Die Leistung Ihrer Lokalen Installation hängt maßgeblich von der verfügbaren Hardware ab, insbesondere wenn es um Large Language Models (LLMs) geht.

RAM (Arbeitsspeicher): Während kleinere LLMs möglicherweise auf älterer Hardware laufen können, erfordern größere Modelle und eine gute Performance ausreichend RAM.
- Mindestens 16-32 GB sind für den Einstieg empfehlenswert.
- Ideal sind 64 GB+, um mehrere Modelle gleichzeitig zu laden oder größere Modelle effizient zu betreiben.
GPU (Grafikprozessoreinheit): Eine leistungsstarke GPU mit viel VRAM (Video RAM) ist entscheidend für das Inferenzieren von LLMs und anderen KI-Modellen. Die Berechnungen auf der GPU sind um Größenordnungen schneller als auf der CPU.
- Mindestens 12 GB VRAM sind für mittelgroße Modelle ratsam.
- Ideal sind 24 GB+ VRAM für größere Modelle (z.B. 70B Parameter-Modelle oder mehr) und für Aufgaben, die mehrere Modelle gleichzeitig nutzen.
Nvidia-GPUs: Nvidia-GPUs werden oft bevorzugt, da viele ML-Frameworks (wie PyTorch und TensorFlow) und KI-Software (wie Ollama) für sie optimiert sind und CUDA (Compute Unified Device Architecture) umfassende Unterstützung bietet. Achten Sie auf die Kompatibilität Ihrer GPU und der entsprechenden Treiber.
Festplattenspeicher: LLM-Modelle können sehr groß sein (mehrere GB bis zu hunderten von GB). Stellen Sie sicher, dass Sie ausreichend schnellen Festplattenspeicher (SSD wird dringend empfohlen) zur Verfügung haben.

„Die Investition in adäquate Hardware ist die Basis für eine leistungsstarke lokale KI-Infrastruktur. Unterschätzen Sie nicht den Bedarf an VRAM, wenn Sie ernsthaft mit großen Sprachmodellen arbeiten wollen“, erklärt ein Hardware-Spezialist.

2. Datenqualität für RAG

Die Effektivität von RAG (Retrieval Augmented Generation)-Anwendungen hängt stark von der Qualität der Datenaufbereitung ab.

„Dummes Zerlegen“ (Chunking): Wie bereits erwähnt, kann das einfache Zerlegen von Dokumenten in gleich große Textabschnitte ohne Berücksichtigung des Kontexts zu schlechten RAG-Ergebnissen führen. Der KI-Agent findet möglicherweise nicht die relevantesten Informationen, wenn sie über mehrere Chunks verteilt oder in unpassenden Abschnitten zerstückelt sind.
Verbesserung der Datenqualität:
- Verwenden Sie intelligente Chunking-Strategien, die den Kontext berücksichtigen (z.B. nach Abschnitten, Überschriften oder semantischen Einheiten).
- Konvertieren Sie PDFs, DOCX und andere Dokumentenformate in sauberes Markdown oder reinen Text, um die Extraktion und Verarbeitung zu erleichtern.
- Erwägen Sie den Einsatz von Bibliotheken oder Tools für die Dokumentenverarbeitung und -bereinigung (z.B. OCR für gescannte Dokumente, Bibliotheken zur Entfernung von Boilerplate-Text).

3. LLMOps/MLOps

Der Aufbau und die Wartung robuster KI-Lösungen erfordert etablierte MLOps- (Machine Learning Operations) oder LLMOps-Praktiken (für LLMs).

Datenverwaltung: Sicherstellung der Konsistenz, Versionierung und Pflege der für die KI-Modelle verwendeten Daten.
Modelltraining und -optimierung: Prozesse für das Retraining, Fine-Tuning und die Optimierung Ihrer Modelle.
Bereitstellung und Monitoring: Effektive Bereitstellung der Modelle und Überwachung ihrer Leistung, des Ressourcenverbrauchs und der Genauigkeit im Laufe der Zeit.
Automatisierung: Automatisierung von Pipelines für Datenaufnahme, Modelltraining und Bereitstellung.
Herausforderung für Unternehmen: Viele Unternehmen befinden sich hier noch im Aufbau. Eine Lokale KI-Installation erfordert, dass Sie diese Prozesse selbst etablieren und pflegen.

4. AI Agent Protokolle (MCP)

Die Integration und Nutzung von AI Agent Protokollen (z.B. Messaging und Kommunikationsprotokolle, die die Interaktion zwischen Agenten oder Diensten steuern) ist noch in einer frühen Phase der Entwicklung und Standardisierung.

Potenzielle Probleme: Es kann zu Problemen kommen, wenn Server bestimmte Funktionen nicht bereitstellen oder unzuverlässig sind. Die Interaktion zwischen verschiedenen KI-Agenten oder die Anbindung an externe Dienste über diese Protokolle kann noch fehleranfällig sein.
Lösung: Bleiben Sie auf dem Laufenden über die Entwicklung von KI-Agenten-Frameworks und -Protokollen. Das n8n-Ökosystem und Open WebUI entwickeln sich ständig weiter, um diese Integrationen zu verbessern.

Trotz dieser Herausforderungen bietet das „Self-hosted AI Package“ eine leistungsstarke und flexible Grundlage für die Entwicklung datenschutzkonformer und kosteneffizienter KI-Anwendungen in Ihrer eigenen Umgebung. Mit sorgfältiger Planung und einem Verständnis für die genannten Punkte können Sie eine robuste und wertvolle Lokale KI-Installation realisieren.

Fazit: Die Zukunft der lokalen KI-Installation

Die Entscheidung für eine Lokale KI-Installation mittels des „Self-hosted AI Package“ ist ein strategischer Schritt in Richtung Autonomie und Effizienz im Bereich der künstlichen Intelligenz. Wie diese umfassende Anleitung gezeigt hat, bietet das Paket eine robuste und flexible Umgebung, die Ihnen die volle Kontrolle über Ihre Daten und KI-Anwendungen ermöglicht, während gleichzeitig Abonnementkosten vermieden und maximale Privatsphäre gewährleistet werden.

Durch die Integration von Schlüsselkomponenten wie n8n, Ollama, Open WebUI, Qdrant und vielen weiteren erhalten Sie einen vollständigen KI-Stack, der von der Workflow-Automatisierung über die Modellbereitstellung bis hin zur interaktiven Nutzung alles abdeckt. Die detaillierten Schritte zur Installation und Konfiguration zeigen, dass der Einstieg in die Welt der selbstgehosteten KI auch für weniger erfahrene Nutzer machbar ist, vorausgesetzt, die Voraussetzungen sind erfüllt.

Die Vorteile der Lokalen Installation – Datenhoheit, Kosteneffizienz und verbesserte Sicherheit – sind immens und sprechen für sich. Während Hardware-Anforderungen und die Komplexität der RAG-Datenqualität oder MLOps-Praktiken Herausforderungen darstellen können, sind diese mit sorgfältiger Planung und kontinuierlicher Optimierung gut zu bewältigen.

Das „Self-hosted AI Package“ ist nicht nur ein Werkzeug, sondern eine Philosophie, die die Demokratisierung der KI vorantreibt. Es ermöglicht Unternehmen und Einzelpersonen, die transformative Kraft der KI zu nutzen, ohne dabei die Kontrolle abzugeben oder sich von externen Dienstleistern abhängig zu machen. Steigen Sie ein in die Welt der Lokalen KI-Installation und gestalten Sie Ihre intelligente Zukunft selbst.