> ## 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.
# Loop
> Iteriere über Arrays und verarbeite mehrere Items mit derselben Logik.
## Überblick
Der Loop-Node verarbeitet Arrays von Daten - iteriere durch Listen von Kunden, Bestellungen, Dateien oder jeder Sammlung und wende dieselbe Logik auf jedes Item an.
**Am besten für**: Batch-Verarbeitung, Verarbeitung mehrerer Datensätze, Generierung individueller Berichte und Iterieren über Listen.
## Konfiguration
**Input-Array**: Wähle das Array aus, über das iteriert werden soll
```handlebars theme={null}
{{trigger.output.customers}}
{{api_response.output.items}}
{{google_sheets.output.rows}}
```
**Loop-Variablenname**: Name für aktuelles Item (z.B., `customer`, `item`, `record`)
**Max. Iterationen**: Sicherheitslimit (Standard: 200, Maximum: 2000)
### Erweiterte Optionen
**Parallelität**: Aktiviere parallele Verarbeitung von Loop-Iterationen
Wenn aktiviert, laufen alle Iterationen gleichzeitig statt nacheinander. Das beschleunigt Loops erheblich, erfordert aber, dass die Iterationen nicht voneinander abhängen.
| Parallelität | Verhalten | Geeignet für |
| ------------------ | ----------------------------------------------------- | ------------------------------------------------ |
| **Aus** (Standard) | Sequentiell - jede Iteration wartet auf die vorherige | Abhängige Operationen, rate-limitierte APIs |
| **An** | Parallel - alle Iterationen laufen gleichzeitig | Unabhängige Operationen, schnellere Verarbeitung |
Bei aktivierter Parallelität können Iterationen in beliebiger Reihenfolge abschließen. Nutze keine Parallelität, wenn spätere Iterationen von Ergebnissen früherer abhängen.
**Outputs sammeln**: Fasse alle Iterationsergebnisse in einem Array zusammen
Wenn aktiviert, gibt der Loop-End-Node ein Array mit Ergebnissen jeder Iteration aus. Das ist nützlich, um im Loop verarbeitete Daten zu aggregieren.
```handlebars theme={null}
{{ loop_end.output.iterations }} → Array aller Iterationsdaten
{{ loop_end.output.iterations[0].item }} → Input-Item der ersten Iteration
{{ loop_end.output.iterations[0].executions }} → Ausgeführte Nodes der ersten Iteration
{{ loop_end.output.total }} → Gesamtzahl der Iterationen
```
**Struktur der gesammelten Outputs:**
```json theme={null}
{
"iterations": [
{
"index": 0,
"item": { "original": "data" },
"executions": [
{
"nodeId": "abc123",
"nodeSlug": "agent",
"nodeType": "agent",
"input": { ... },
"output": { "result": "processed" }
}
]
}
],
"total": 10
}
```
Nutze **Outputs sammeln**, wenn du Ergebnisse aggregieren, Berichte aus allen Iterationen erstellen oder Loop-Ergebnisse an einen nachfolgenden Node zur finalen Verarbeitung übergeben möchtest.
## Innerhalb des Loops
Der Loop-Node-Slug wird dein Variablenname. Greife auf aktuelles Item und Iterations-Info zu:
```handlebars theme={null}
{{customer.output.currentItem}} // Das volle aktuelle Item
{{customer.output.currentItem.name}} // Zugriff auf Item-Eigenschaften
{{customer.output.currentItem.email}}
{{customer.output.currentIndex}} // Aktuelle Iteration (0-basiert)
{{customer.output.total}} // Gesamtzahl Items im Array
```
## Beispiel-Anwendungsfälle
### Kundenliste verarbeiten
```text theme={null}
Loop über {{trigger.output.customers}}
Loop-Node-Slug: customer
→ Agent: Analysiere {{customer.output.currentItem.feedback}}
→ Condition: Prüfe {{customer.output.currentItem.score}}
→ Hoch: Sende Dankes-E-Mail
→ Niedrig: Erstelle Follow-up-Aufgabe
```
### Batch-Update von Datensätzen
```text theme={null}
Loop über {{api_response.output.records}}
Loop-Node-Slug: record
→ Code: Transformiere {{record.output.currentItem.data}}
→ HTTP Request: Aktualisiere Datensatz {{record.output.currentItem.id}}
```
### Individuelle Berichte generieren
```text theme={null}
Loop über {{trigger.output.team_members}}
Loop-Node-Slug: member
→ HTTP Request: Hole {{member.output.currentItem.id}} Daten ab
→ Agent: Generiere Bericht für {{member.output.currentItem.name}}
→ Action: E-Mail-Bericht an {{member.output.currentItem.email}}
```
### Parallele Bildverarbeitung (Parallelität)
```text theme={null}
Loop über {{trigger.output.images}}
Loop-Node-Slug: image
Parallele Ausführung: An
→ Agent: Analysiere {{image.output.currentItem.url}}
→ Code: Extrahiere Metadaten
```
Alle Bilder werden gleichzeitig analysiert und deutlich schneller fertig als bei sequentieller Verarbeitung.
### Ergebnisse aggregieren (Outputs sammeln)
```text theme={null}
Loop über {{trigger.output.documents}}
Loop-Node-Slug: doc
Outputs sammeln: An
→ Agent: Fasse {{doc.output.currentItem.content}} zusammen
→ Code: Extrahiere Kernpunkte
→ Agent: Erstelle Gesamtzusammenfassung aus {{loop_end.output.iterations}}
→ Action: Sende kombinierten Bericht
```
Der finale Agent erhält alle Zusammenfassungen auf einmal, um einen umfassenden Bericht zu erstellen.
## Best Practices
Verhindere Endlosschleifen und ausufernde Kosten. Setze ein vernünftiges Maximum.
Anstatt 100 individuelle Agent-Aufrufe, fasse Items in Gruppen von 10 zusammen.
Füge eine Bedingung vor dem Loop hinzu, um zu prüfen, ob das Array Items hat.
Loops mit KI-Agenten können teuer sein. Berechne: Kosten pro Item × Anzahl der Items.
## Kosten-Warnung
Loops können signifikante Credits verbrauchen, wenn viele Items mit KI-Agenten verarbeitet werden. Ein Loop mit 100 Items und einem Agent-Aufruf zu je $0.10 = $10 pro Durchlauf.
## Nächste Schritte
Verarbeite Items mit KI
Optimiere Loop-Kosten