KI-Agenten in n8n bauen

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über KI-Agenten in n8n behandelt

• Wie Du mit dem AI-Agent-Node in n8n Agenten baust.
• Wie Du Tools an den Agenten anbindest (Suche, Datenbank, APIs).
• Wie Du Ollama als Backend für den Agenten nutzt.
• Wie Multi-Step-Agenten und Memory funktionieren.
• Praxisbeispiele für verschiedene Agenten-Typen.

Einleitung: KI-Agenten in n8n verständlich erklärt

n8n hat seit Version 1.x einen dedizierten AI-Agent-Node. Dieser Node ist kein einfacher Text-Generator, sondern ein echter Agent: Er kann Tools aufrufen, Entscheidungen treffen und mehrere Schritte ausführen, um eine Aufgabe zu lösen. Kombiniert mit Ollama läuft das alles lokal.

Dieser Artikel richtet sich an Anwender, die in n8n nicht nur einfache Prompts, sondern echte Agenten bauen wollen. Grundlagen findest Du in KI-Agenten und n8n-Ollama-Integration.

Warum brauche ich KI-Agenten in n8n?

Ein einfacher Workflow ruft das Modell einmal auf: „Fasse diesen Text zusammen”. Ein Agent-Workflow ist anders: Der Agent bekommt ein Ziel („Recherchiere dieses Thema und erstelle einen Bericht”), entscheidet selbst, welche Tools er braucht (Web-Suche, Dokumentenleser, Rechner), und führt mehrere Schritte aus, bis das Ziel erreicht ist.

KI-Agenten in n8n kurz erklärt

Der AI-Agent-Node in n8n verbindet ein Sprachmodell (Ollama, OpenAI, Claude) mit Tools (HTTP-Request, Code, Datenbank, Suche). Der Agent plant selbst, ruft Tools auf und iteriert, bis die Aufgabe gelöst ist.

Der Kerngedanke lautet: Modell + Tools + Loop = Agent.

Für wen ist dieser Artikel gedacht?

• n8n-Nutzer, die über einfache Prompts hinausgehen wollen.
• Automatisierer, die agentische Workflows bauen.
• Self-Hoster, die Agenten mit Ollama lokal betreiben.
• Entwicklerinnen und Entwickler, die n8n als Agenten-Plattform nutzen.

Vorkenntnisse in n8n und KI-Agenten sind hilfreich.

Wichtige Begriffe

• AI Agent Node - n8n-Node für Agenten. Wann nützlich: das Herzstück.
• Tool - Werkzeug für den Agenten. Wann nützlich: was der Agent aufrufen kann.
• Ollama - Lokaler Modellserver. Wann nützlich: als Agenten-Backend.
• Function Calling - Tool-Use-Mechanismus. Wann nützlich: wie der Agent Tools aufruft.
• Memory - Gesprächsgedächtnis. Wann nützlich: für Multi-Turn-Agenten.
• Window Buffer Memory - Einfaches Memory. Wann nützlich: für Konversationen.
• ReAct - Reasoning + Acting. Wann nützlich: das Agenten-Muster.

Der AI-Agent-Node im Detail

Grundaufbau

Der AI-Agent-Node hat mehrere Anschlüsse:

                    ┌──────────────────┐
Trigger ──────────► │   AI Agent Node  │ ──► Ausgabe
                    │                  │
   Model ─────────► │  ○ Chat Model    │
   Memory ────────► │  ○ Memory        │
   Tool 1 ────────► │  ○ Tool          │
   Tool 2 ────────► │  ○ Tool          │
                    └──────────────────┘

• Chat Model: Das Sprachmodell (Ollama, OpenAI, etc.)
• Memory: Optional, für Gesprächskontext
• Tool: Bis zu mehrere Tools, die der Agent aufrufen kann

Agent-Typen

n8n bietet verschiedene Agent-Typen:

Setup: Ollama als Agenten-Modell

1. Chat Model konfigurieren

Füge einen Ollama Chat Model-Node hinzu und verbinde ihn mit dem Chat-Model-Eingang des AI-Agent-Nodes:

Ollama Chat Model:
  Model: llama3.1
  Base URL: http://ollama:11434
  Temperature: 0.3

Wichtig: Für Tool-Calling brauchst Du ein Modell, das das kann. Siehe Function Calling.

2. Geeignete Modelle für Tool-Calling

Tools anbinden

Tool 1: HTTP-Request (Web-Suche)

// Custom Tool Node: Web-Suche via SearXNG
{
  "name": "web_search",
  "description": "Sucht im Web nach aktuellen Informationen. Input: Suchanfrage als String.",
  "schema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" }
    }
  }
}

// Im Tool-Node: HTTP Request an SearXNG
// POST http://searxng:8080/search?q={{query}}&format=json

Tool 2: Code (Berechnungen)

// Code-Tool für Berechnungen
// Der Agent kann JavaScript-Code ausführen lassen

const input = $json.input;
// Beispiel: Prozentrechnung
const result = eval(input);
return { result };

Tool 3: Datenbank (Postgres)

// Postgres-Tool: Der Agent kann die Datenbank abfragen
{
  "name": "query_database",
  "description": "Führt eine SQL-Abfrage auf der Kundendatenbank aus.",
  "schema": {
    "type": "object",
    "properties": {
      "sql": { "type": "string" }
    }
  }
}

Tool 4: Workflow als Tool

Ein mächtiges Pattern: Ein anderer n8n-Workflow wird als Tool eingebunden:

AI Agent
  └─ Tool: "Dokument verarbeiten"
       └─ Sub-Workflow:
            ├─ PDF herunterladen
            ├─ Text extrahieren
            └─ Zusammenfassen

Praxisbeispiel 1: Recherche-Agent

Workflow: Recherche-Agent

1. Webhook Trigger: Thema kommt rein
2. AI Agent Node:
   - Model: Ollama llama3.1
   - Tools:
     * web_search (SearXNG)
     * fetch_page (HTTP Request)
     * save_note (Code)
3. Agent-Prompt:
   "Recherchiere das Thema [THEMA].
    Nutze web_search für Quellen,
    fetch_page für Details,
    save_note für Zwischenergebnisse.
    Erstelle am Ende einen Bericht mit Quellen."
4. E-Mail Node: Bericht versenden

Praxisbeispiel 2: Ticket-Agent

Workflow: Support-Ticket-Agent

1. Webhook: Neues Ticket
2. AI Agent Node:
   - Model: Ollama qwen2.5
   - Memory: Window Buffer (für Follow-ups)
   - Tools:
     * knowledge_base (RAG via Qdrant)
     * ticket_status (Datenbank)
     * create_response (Code)
3. Agent-Prompt:
   "Beantworte das Support-Ticket.
    Suche zuerst in der Wissensdatenbank.
    Prüfe den Ticket-Status.
    Wenn Du keine Antwort findest: eskaliere."
4. IF Node: Eskaliert? → An Menschen / Antwort senden

Praxisbeispiel 3: Datenbank-Agent

Workflow: SQL-Agent

1. Schedule Trigger: Täglich 8 Uhr
2. AI Agent Node (SQL Agent):
   - Model: Ollama llama3.1
   - Tools: Postgres (automatisch als SQL-Tool)
3. Prompt:
   "Analysiere die Verkaufszahlen der letzten Woche.
    Erstelle einen Bericht mit Top-Produkten und Trends."
4. Slack/Email: Bericht versenden

Memory konfigurieren

Window Buffer Memory

// Einfaches Memory: Letzte N Nachrichten
{
  "type": "windowBuffer",
  "windowSize": 10  // Letzte 10 Nachrichten
}

Persistent Memory (Redis/Postgres)

Für langlebige Gespräche:

// Redis Memory
{
  "type": "redis",
  "host": "redis",
  "port": 6379,
  "sessionKey": "{{$json.session_id}}"
}

Fehlerbehandlung im Agenten

// Retry-Logik im Agent-Node
{
  "maxIterations": 10,      // Max. 10 Tool-Aufrufe
  "returnIntermediateSteps": true  // Debugging
}

// Nach dem Agent: Erfolg prüfen
const output = $json.output;
if (!output || output.includes("I don't know")) {
  // Fallback oder Eskalation
  return { status: "failed", needs_human: true };
}

Guardrails für Agenten

// Guardrail-Node vor dem Agent
function validateInput(input) {
  // Prompt Injection filtern
  const dangerous = ["ignore previous", "system:", "forget all"];
  for (const pattern of dangerous) {
    if (input.toLowerCase().includes(pattern)) {
      throw new Error("Potential prompt injection");
    }
  }
  return input;
}

Siehe Guardrails konfigurieren und Prompt Injection.

Sicherheitshinweise

• Tool-Berechtigungen einschränken: Der Agent sollte nur lesen, was er braucht. Siehe Tool-Berechtigungen.
• Max Iterations: Begrenze die Anzahl der Tool-Aufrufe, sonst kann der Agent endlos laufen.
• Output validieren: Kritische Aktionen (E-Mail senden, Daten löschen) sollten von Menschen freigegeben werden. Siehe Menschliche Freigabe.
• Logging: Protokolliere alle Agenten-Entscheidungen. Siehe Protokollierung.
• Sandboxing: Führe generierten Code isoliert aus. Siehe Sandboxing.

Typische Stolpersteine

• Modell ohne Tool-Calling: Nicht jedes Modell kann Tools aufrufen. Nutze llama3.1 oder qwen2.5.
• Zu viele Tools: Mehr als 5-7 Tools überfordern das Modell. Weniger ist mehr.
• Schlechte Tool-Beschreibungen: Das Modell entscheidet anhand der Beschreibung, welches Tool es nutzt. Sei präzise.
• Keine Iterationsgrenze: Agenten können in Schleifen landen. Immer maxIterations setzen.
• Kontext überladen: Lange Tool-Ausgaben überlasten den Kontext. Truncaten.
• Kein Fallback: Wenn der Agent scheitert, sollte ein Fallback greifen.

Weiterführende Links

• n8n Guide - n8n im Detail.
• n8n-Ollama-Integration - Ollama in n8n.
• n8n Installation - n8n einrichten.
• KI-Agenten Grundlagen - Was Agenten sind.
• Function Calling - Tool-Calling verstehen.
• Tool-Berechtigungen - Agenten absichern.
• Protokollierung - Agenten loggen.

Key Takeaways:

• Der AI-Agent-Node verbindet Modell, Tools und Memory zu einem echten Agenten.
• Ollama mit llama3.1 oder qwen2.5 als lokales Backend.
• Tools: HTTP-Request, Code, Datenbank, sogar Sub-Workflows.
• Max Iterations setzen, Tool-Beschreibungen präzise formulieren.
• Sicherheit: Tool-Berechtigungen, Output-Validierung, Logging.

FAQ

Quellen und weiterführende Literatur

• n8n AI Agent Node - Dokumentation.
• Ollama Function Calling - Tool-Support in Ollama.
• ReAct Pattern - Reasoning + Acting.
• LangChain Agents - Agenten-Konzepte.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert