> ## Documentation Index
> Fetch the complete documentation index at: https://docs.langdock.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Agent

> Nutze KI, um Daten zu analysieren, Entscheidungen zu treffen, Inhalte zu generieren und strukturierte Informationen zu extrahieren.

<img src="https://mintcdn.com/langdock-34/cWyoB3RsITQmAUnM/images/workflows/nodes/agent.jpg?fit=max&auto=format&n=cWyoB3RsITQmAUnM&q=85&s=57e5116798473bd01464f22a0d8c2a28" alt="Agent Node" width="1920" height="903" data-path="images/workflows/nodes/agent.jpg" />

## Überblick

Der Agent-Node bringt KI in deinen Workflow. Er kann Text analysieren, intelligente Entscheidungen treffen, strukturierte Daten extrahieren, Inhalte generieren, Fragen beantworten und vieles mehr - alles mit natürlichsprachlichen Anweisungen.

<Info>
  **Am besten für**: Inhaltsanalyse, Kategorisierung, Datenextraktion, Entscheidungsfindung, Zusammenfassung und jede Aufgabe, die Intelligenz erfordert.
</Info>

## Wann du den Agent-Node verwenden solltest

**Perfekt für:**

* Inhalte analysieren und kategorisieren
* Strukturierte Daten aus unstrukturiertem Text extrahieren
* Entscheidungen basierend auf Kriterien treffen
* Zusammenfassungen oder Berichte generieren
* Sentiment-Analyse
* Fragen über Daten beantworten
* Content-Generierung
* Übersetzungs- und Sprachaufgaben

**Nicht ideal für:**

* Einfache Datentransformationen (verwende Code-Node)
* Mathematische Berechnungen (verwende Code-Node)
* Direkte API-Aufrufe (verwende HTTP-Request-Node)

## Konfiguration

### Agent auswählen oder erstellen

**Bestehenden Agenten verwenden**

* Wähle aus deinen Workspace-Agenten
* Erbt Konfiguration und Wissen des Agenten
* Konsistentes Verhalten über Chat und Workflows

**Neuen Agent erstellen**

* Definiere Agent speziell für diesen Workflow
* Konfiguriere unabhängig
* Optimiert für Automatisierung

### Agent-Anweisungen

Gib klare Anweisungen, was der Agent tun soll:

**Gute Anweisungen:**

```text theme={null}
Analysiere das Kundenfeedback und bestimme:
1. Stimmung (positiv, neutral, negativ)
2. Hauptthema-Kategorie (produkt, service, preise, support)
3. Dringlichkeitsstufe (niedrig, mittel, hoch)
4. Erwähnte Hauptprobleme

Feedback: {{trigger.output.feedback_text}}
```

**Schlechte Anweisungen:**

```text theme={null}
Analysiere dieses Feedback: {{trigger.output.feedback_text}}
```

### Input-Variablen

Übergib Daten von vorherigen Nodes an den Agenten:

```handlebars theme={null}
Kunde: {{trigger.output.customer_name}}
Bestell-ID: {{trigger.output.order_id}}
Problem: {{trigger.output.description}}

Bitte analysiere dieses Support-Ticket und kategorisiere es.
```

### Strukturierte Ausgabe (Empfohlen)

Definiere die exakte Struktur, die du vom Agenten möchtest:

**Warum strukturierte Ausgabe verwenden:**

* Garantiertes Format (immer gültiges JSON)
* Keine Parsing-Fehler
* Zuverlässig für nachgelagerte Nodes
* Einfacher zu debuggen

**Beispiel:**

```json theme={null}
{
  "sentiment": "positive",
  "category": "product_feedback",
  "priority": "medium",
  "summary": "Kunde liebt das neue Feature",
  "action_needed": false
}
```

**Konfiguriere:**

1. Aktiviere "Strukturierte Ausgabe"
2. Definiere Output-Felder:
   * Feldname
   * Typ (string, number, boolean, array)
   * Beschreibung

### Tools & Fähigkeiten

Aktiviere zusätzliche Fähigkeiten für den Agenten. Tools werden als Array mit vier Typen konfiguriert:

**Eingebaute Fähigkeiten**

* **Web-Suche**: Agent kann das Internet für Faktenprüfung und aktuelle Informationen durchsuchen
* **Code-Ausführung und Dateierstellung**: Workflow-Agenten können Shell-Befehle und Code ausführen, um Berechnungen durchzuführen, Daten zu transformieren und Dateien (CSVs, Tabellen, Dokumente, Bilder und mehr) zu erstellen. Diese Fähigkeit ist standardmäßig aktiviert und muss nicht zur Tools-Liste hinzugefügt werden.

**Integrations-Actions**

* Füge spezifische Actions aus deinen verbundenen Integrationen hinzu
* Jede Action kann optional eine Bestätigung vor der Ausführung erfordern (Human-in-the-Loop)
* Gib an, welche Verbindung verwendet werden soll, wenn du mehrere hast

**Ordner**

* Hänge Ordner an, damit der Agent deine Dokumente durchsuchen kann
* Agent durchsucht automatisch relevante Inhalte bei der Beantwortung von Fragen

**Andere Agenten**

* Rufe andere Agenten als Tools für spezialisierte Unteraufgaben auf
* Nützlich für komplexe Workflows mit mehreren Fachbereichen

### Fehlerbehandlung

Konfiguriere, wie der Workflow Fehler von diesem Node behandelt:

| Strategie           | Verhalten                                      |
| ------------------- | ---------------------------------------------- |
| **Stop** (Standard) | Workflow-Ausführung stoppt sofort bei Fehler   |
| **Callback**        | Leite zu einem Fehlerbehandlungs-Branch weiter |
| **Continue**        | Setze Ausführung mit Fehler-Output-Daten fort  |

### Verbindungs-Overrides

Bei Verwendung von Integrations-Actions kannst du überschreiben, welche Verbindung der Agent für bestimmte Tools verwendet. Das ist nützlich wenn:

* Du mehrere Verbindungen zur gleichen Integration hast (z.B. verschiedene Slack-Workspaces)
* Der Workflow einen bestimmten Service-Account verwenden soll

### Anhänge

Hänge Dateien direkt an den Agent-Node an, die zur Verarbeitung verfügbar sein werden. Das können sein:

* Dateien, die in den Workflow hochgeladen wurden
* Dateien aus vorherigen Node-Outputs
* Statische Referenzdokumente

## Beispiel-Anwendungsfälle

### Content-Kategorisierung

```text theme={null}
Agent-Konfiguration:
- Anweisungen: "Kategorisiere diesen Artikel nach Thema und schlage Tags vor"
- Input: {{trigger.output.article_text}}
- Modell: GPT-3.5 Turbo
- Strukturierte Ausgabe:
  {
    "category": "string",
    "tags": ["string"],
    "confidence": "number"
  }
```

### Lead-Qualifizierung

```text theme={null}
Agent-Konfiguration:
- Anweisungen: "Bewerte diesen Lead basierend auf Firmengröße, Rolle und Anwendungsfall"
- Input:
  Firma: {{trigger.output.company}}
  Rolle: {{trigger.output.role}}
  Anwendungsfall: {{trigger.output.use_case}}
- Modell: GPT-4
- Strukturierte Ausgabe:
  {
    "score": "number (0-100)",
    "qualification": "hot|warm|cold",
    "reasoning": "string"
  }
```

### Dokumentzusammenfassung

```text theme={null}
Agent-Konfiguration:
- Anweisungen: "Fasse dieses Dokument in 3-5 Stichpunkten zusammen"
- Input: {{trigger.output.document_text}}
- Modell: Claude Sonnet
- Strukturierte Ausgabe:
  {
    "summary_points": ["string"],
    "key_topics": ["string"],
    "word_count": "number"
  }
```

### Sentiment-Analyse

```text theme={null}
Agent-Konfiguration:
- Anweisungen: "Analysiere Stimmung und emotionalen Ton"
- Input: {{trigger.output.customer_message}}
- Modell: GPT-3.5 Turbo
- Strukturierte Ausgabe:
  {
    "sentiment": "positive|neutral|negative",
    "emotion": "string",
    "confidence": "number"
  }
```

## Auf Agent-Output zugreifen

**Ohne strukturierte Ausgabe:**

```handlebars theme={null}
{{agent_node_name.output.messages}}
```

**Mit strukturierter Ausgabe:**

```handlebars theme={null}
{{agent_node_name.output.structured.sentiment}}
{{agent_node_name.output.structured.category}}
{{agent_node_name.output.structured.summary}}
{{agent_node_name.output.structured.tags[0]}}
```

## Prompt-Engineering-Tipps

**Sei explizit**

```text theme={null}
❌ "Analysiere diesen Text"
✅ "Analysiere dieses Kundenfeedback und kategorisiere als Bug, Feature-Anfrage oder Frage"
```

**Gib Kontext**

```text theme={null}
Du analysierst Kunden-Support-Tickets für ein SaaS-Unternehmen.
Kategorisiere nach Dringlichkeit basierend auf:
- Dringend: System down, Datenverlust, Sicherheitsproblem
- Hoch: Blockiert Arbeit des Benutzers
- Mittel: Unannehmlichkeit, aber Workaround vorhanden
- Niedrig: Feature-Anfrage oder Frage
```

**Verwende Beispiele**

```text theme={null}
Kategorisiere diese Probleme:
Beispiel 1: "Kann mich nicht anmelden, erhalte 500-Fehler" → Dringend
Beispiel 2: "Wie exportiere ich Daten?" → Niedrig

Kategorisiere jetzt: {{trigger.output.issue}}
```

**Begrenze Output**

```text theme={null}
Antworte NUR mit einer dieser Kategorien: bug, feature, question
Erkläre deine Begründung nicht.
```

## Best Practices

<AccordionGroup>
  <Accordion title="Verwende immer strukturierte Ausgabe">
    Für Workflows ist strukturierte Ausgabe fast immer besser. Sie verhindert Parsing-Fehler und macht Daten einfacher in nachfolgenden Nodes verwendbar.
  </Accordion>

  <Accordion title="Sei spezifisch in Anweisungen">
    Klare, detaillierte Anweisungen führen zu besseren Ergebnissen. Füge Beispiele hinzu, wenn die Aufgabe komplex ist.
  </Accordion>

  <Accordion title="Limitiere Input-Länge">
    Agenten arbeiten am besten mit fokussierten Inputs. Wenn lange Dokumente verarbeitet werden, erwäge, relevante Abschnitte zuerst zu extrahieren.
  </Accordion>

  <Accordion title="Teste mit echten Daten">
    Agent-Performance kann variieren. Teste mit tatsächlichen Datenbeispielen, um konsistente Ergebnisse sicherzustellen.
  </Accordion>

  <Accordion title="Handle Edge-Cases">
    Füge Validierung nach dem Agent-Node hinzu, um unerwartete Outputs oder Fehler zu behandeln.
  </Accordion>
</AccordionGroup>

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Code-Node" icon="code" href="/de/using-langdock/workflows/nodes/code-node">
    Transformiere Daten vor/nach Agent-Verarbeitung
  </Card>

  <Card title="Condition-Node" icon="code-branch" href="/de/using-langdock/workflows/nodes/condition-node">
    Route basierend auf Agent-Entscheidungen
  </Card>

  <Card title="Kostenmanagement" icon="dollar-sign" href="/de/using-langdock/workflows/guides/cost-management">
    Optimiere Agent-Kosten
  </Card>

  <Card title="Agenten" icon="message-bot" href="/de/using-langdock/agents/introduction">
    Lerne über die Verwendung von Agenten in Workflows
  </Card>
</CardGroup>