> ## 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. # Variablen-Nutzung > Lerne, wie du auf Variablen zugreifst, sie referenzierst und mit ihnen arbeitest, um dynamische und leistungsstarke Automatisierungen in deinen Workflows zu erstellen. ## Einführung Variablen sind das Herzstück deiner Workflows – sie transportieren Daten zwischen Nodes und machen deine Automatisierungen dynamisch und kontextbewusst. Jedes Mal, wenn ein Node seine Ausführung abschließt, wird sein Output als Variable verfügbar, auf die nachfolgende Nodes zugreifen und sie verwenden können. **Stell dir Variablen wie Container vor**, die Daten enthalten, während sie durch deinen Workflow fließen. Zu verstehen, wie du auf sie zugreifst und sie manipulierst, ist der Schlüssel zum Erstellen leistungsstarker Automatisierungen. ## Auf Variablen zugreifen Langdock bietet dir zwei intuitive Möglichkeiten, auf Variablen von vorherigen Nodes in deinem Workflow zuzugreifen: ### Methode 1: Doppelte geschweifte Klammern (`{{}}`) Der direkteste Weg, Variablen zu referenzieren, ist die Verwendung der doppelten geschweiften Klammer-Syntax. Tippe einfach `{{` in ein beliebiges Feld, und du siehst ein Dropdown aller verfügbaren Variablen von vorherigen Nodes. **Grundlegende Syntax:** ```handlebars theme={null} {{node_name.output.field_name}} ``` **Praxisbeispiele:** ```handlebars theme={null} {{form1.output.email}} {{analyze_feedback.output.sentiment}} {{api_call.output.data.userId}} {{trigger.output.customer_name}} ``` ### Methode 2: Output-Selektor Output Selector Für Felder, die dies unterstützen, kannst du den visuellen Output-Selektor verwenden, anstatt Variablenpfade manuell einzugeben. Dies ist besonders hilfreich, wenn du dir nicht sicher bist, wie genau die Datenstruktur aussieht. **So verwendest du ihn:** 1. Klicke auf ein Feld, das Variablenauswahl unterstützt 2. Such nach dem Variablen-Picker-Symbol oder Dropdown 3. Durchsuche verfügbare Outputs von vorherigen Nodes 4. Wähle genau das Feld aus, das du benötigst Der Output-Selektor generiert automatisch die richtige Variablensyntax für dich, reduziert Fehler und macht die Konfiguration schneller. *** ## Variablenstruktur verstehen Variablen folgen einer konsistenten Struktur, die sie vorhersehbar und einfach zu verwenden macht: ```handlebars theme={null} {{node_name.output.property}} ``` Lass uns das aufschlüsseln: * **`node_name`**: Der eindeutige Name, den du dem Node gegeben hast (z.B. `form1`, `analyze_data`, `http_request`) * **`output`**: Das Standard-Output-Objekt, das jeder Node produziert * **`property`**: Das spezifische Datenfeld, auf das du zugreifen möchtest ### Auf verschachtelte Daten zugreifen Reale Daten haben oft verschachtelte Strukturen. Du kannst auf tief verschachtelte Eigenschaften mit Punkt-Notation zugreifen: ```handlebars theme={null} {{node_name.output.user.profile.email}} {{api_response.output.data.items[0].title}} {{trigger.output.metadata.created_at}} ``` ### Mit Arrays arbeiten Wenn deine Daten Arrays enthalten, kannst du auf bestimmte Elemente per Index zugreifen: ```handlebars theme={null} {{http_request.output.results[0].name}} {{trigger.output.attachments[2].url}} ``` Oder referenziere das gesamte Array: ```handlebars theme={null} {{trigger.output.tags}} {{api_call.output.items}} ``` ### Agent-Output-Struktur Agent-Nodes haben zwei Output-Typen je nach Konfiguration: **Wenn ein Output-Schema definiert ist:** ```handlebars theme={null} {{agent.output.structured.summary}} {{agent.output.structured.priority}} {{agent.output.structured.action_items[0]}} ``` **Wenn kein Schema definiert ist:** ```handlebars theme={null} {{agent.output.messages}} ``` Die `structured`-Eigenschaft existiert nur, wenn du ein Output-Schema im Agent-Node konfiguriert hast. Ohne Schema verwende das `messages`-Array, um auf die Konversation zuzugreifen. ### Optional Chaining mit `?` Verwende `?`, um sicher auf Eigenschaften zuzugreifen, die möglicherweise nicht existieren: ```handlebars theme={null} {{trigger.output.user?.email}} {{agent.output.structured?.priority}} {{http_request.output.data?.items?.[0]?.name}} ``` Dies verhindert Fehler, wenn Daten fehlen. Wenn irgendeiner Teil des Pfads `undefined` oder `null` ist, gibt der gesamte Ausdruck `undefined` zurück, anstatt einen Fehler zu werfen. *** ## Was passiert, wenn du Nodes umbenennst **Node-Namen sind mit Variablen verknüpft.** Wenn du einen Node umbenennst, werden alle Variablen, die auf diesen Node verweisen, automatisch in deinem gesamten Workflow aktualisiert – keine manuellen Korrekturen nötig. ### Automatische Variablen-Updates Nehmen wir an, du hast einen Formular-Trigger-Node namens `form1`, der an mehreren Stellen verwendet wird: ```handlebars theme={null} {{form1.output.email}} {{form1.output.subject}} {{form1.output.message}} ``` Wenn du `form1` in `PMApplicantForm` umbenennst, werden alle Referenzen automatisch aktualisiert: ```handlebars theme={null} {{PMApplicantForm.output.email}} {{PMApplicantForm.output.subject}} {{PMApplicantForm.output.message}} ``` **Dies geschieht automatisch in:** * Manuellen Modus-Feldern * AI Prompt Modus-Anweisungen * Code-Node-Referenzen * Condition-Node-Vergleichen * Allen anderen Node-Konfigurationen ### Best Practice: Benenne Nodes aussagekräftig Da Umbenennung nahtlos funktioniert, investiere Zeit in klare, beschreibende Namen von Anfang an: **Gute Node-Namen:** * `ExtractCustomerData` * `AnalyzeSentiment` * `SendWelcomeEmail` * `CheckInventoryStatus` **Vermeide generische Namen:** * ❌ `agent1` * ❌ `http_node` * ❌ `trigger` * ❌ `action` *** ## Variablen über mehrere Nodes hinweg wiederverwenden Eines der leistungsstärksten Features von Variablen ist, dass **du sie mehrfach über viele verschiedene Nodes hinweg verwenden kannst**. Sobald ein Node Output produziert, sind diese Daten für alle nachfolgenden Nodes in deinem Workflow verfügbar. ### Grundlegende Variablen-Wiederverwendung Verwende dieselbe Variable in mehreren Nodes: ```text theme={null} Trigger (form1) → ├─ Agent (analysiere mit {{form1.output.message}}) ├─ HTTP Request (logge {{form1.output.email}}) └─ Notification (informiere über {{form1.output.priority}}) ``` Alle drei Nodes können gleichzeitig auf `form1.output` zugreifen, da sie alle nach dem Trigger kommen. ### Anwendungsfall: Multi-Channel-Benachrichtigungen Sende dieselben Informationen über verschiedene Kanäle: ```text theme={null} Agent (analyze_ticket) → ├─ Email (sende {{analyze_ticket.output.summary}} an Support-Team) ├─ Slack (poste {{analyze_ticket.output.summary}} in #support) └─ Database (logge {{analyze_ticket.output.priority}} und {{analyze_ticket.output.category}}) ``` *** ## Fortgeschrittene Variablen-Techniken ### Mehrere Variablen kombinieren Mische Daten von verschiedenen Nodes in einem einzelnen Feld: ```handlebars theme={null} Neue Bestellung #{{trigger.output.order_id}} von {{customer_data.output.name}} über {{trigger.output.amount}} ``` ### Variablen in Code-Nodes Nutze Code-Nodes, um in eigenem Code auf Variablen zuzugreifen. [Mehr über Code-Nodes erfahren](/de/using-langdock/workflows/nodes/code-node). ```javascript theme={null} const email = trigger.output.email; const priority = analyze.output.structured?.priority || "medium"; return { email: email, priority: priority }; ``` Datei-Outputs aus vorherigen Nodes enthalten eine `path`-Eigenschaft, die du in Python-Code-Nodes direkt an `open()` übergeben kannst: ```python theme={null} file = trigger["output"]["resume"][0] with open(file["path"], "rb") as f: content = f.read() ``` Das vollständige Beispiel findest du unter [Dateien aus vorherigen Nodes lesen](/de/using-langdock/workflows/nodes/code-node#dateien-aus-vorherigen-nodes-lesen). ### Variablen im AI Prompt-Modus Referenziere mehrere Variablen in KI-Anweisungen: ```text theme={null} Analysiere die Kundennachricht {{trigger.output.message}} und berücksichtige deren Historie: - Vorherige Käufe: {{customer_data.output.purchase_count}} - Letzter Kontakt: {{customer_data.output.last_contact_date}} - Stimmung aus letzter Interaktion: {{previous_analysis.output.sentiment}} Gib eine personalisierte Antwort, die ihr Anliegen adressiert. ``` ### Filtern und Transformieren Verwende Variablen zum Filtern oder Transformieren von Daten: **In einem Condition-Node:** ```handlebars theme={null} {{ trigger.output.amount > 1000 }} {{ analyze.output.structured?.priority === "high" }} {{ customer.output.status !== "inactive" }} ``` Der gesamte Ausdruck muss innerhalb von `{{ }}` stehen. Der Ausdruck wird als JavaScript ausgewertet. **In einem Code-Node zum Filtern:** ```javascript theme={null} const orders = trigger.output.orders; const highValueOrders = orders.filter((order) => order.amount > 1000); return { filtered_orders: highValueOrders }; ``` *** ## Variablen-Troubleshooting ### Variable nicht verfügbar **Problem:** Die Variable, die du möchtest, erscheint nicht im Autocomplete. **Häufige Ursachen:** * Der Node wurde noch nicht verbunden * Der Node kommt nachgelagert (nach) dem aktuellen Node * Der Node wurde in einem Testlauf noch nicht ausgeführt **Lösung:** Stelle sicher, dass der Node, der die Variable produziert, vor dem Node kommt, der sie verwenden möchte, in deinem Workflow-Graphen. ### Undefined oder Null-Werte **Problem:** Variable existiert, gibt aber `undefined` oder `null` zurück. **Häufige Ursachen:** * Der Quell-Node ist fehlgeschlagen oder hat leere Daten zurückgegeben * Der Feldpfad ist inkorrekt * Optionale Daten wurden nicht bereitgestellt Wenn der Quell-Node mit der Strategie **Fortfahren (mit Fehlerausgabe)** fehlgeschlagen ist, enthält sein Output den Fehler statt der üblichen Felder. Referenziere ihn mit `{{node_name.output.error}}`. **Lösung:** ```javascript theme={null} // Stelle Standardwerte in Code-Nodes bereit const email = trigger.output.email || "unknown@example.com"; const amount = trigger.output.amount || 0; // Prüfe zuerst auf Existenz if (trigger.output && trigger.output.email) { // Sicher zu verwenden } ``` ### Falscher Datentyp **Problem:** Variable enthält unerwarteten Datentyp. **Lösung:** Überprüfe den Output-Tab des Quell-Nodes nach einem Testlauf, um die tatsächliche Datenstruktur zu sehen. ```javascript theme={null} // Debug durch Logging der Variable ld.log(typeof trigger.output.amount); ld.log(JSON.stringify(trigger.output, null, 2)); ``` ## Schnellreferenz ### Variablen-Syntax Spickzettel | Anwendungsfall | Syntax | Beispiel | | --------------------------- | ----------------------------------- | ----------------------------------------------------------------- | | Grundlegender Feldzugriff | `{{node.output.field}}` | `{{trigger.output.email}}` | | Verschachteltes Objekt | `{{node.output.object.property}}` | `{{user.output.profile.age}}` | | Array-Element | `{{node.output.array[index]}}` | `{{items.output.list[0]}}` | | Verschachtelt im Array | `{{node.output.array[0].property}}` | `{{orders.output.items[0].price}}` | | Gesamtes Array | `{{node.output.array}}` | `{{trigger.output.tags}}` | | Agent strukturierter Output | `{{agent.output.structured.field}}` | `{{analyze.output.structured.summary}}` | | Optional Chaining | `{{node.output.field?.property}}` | `{{trigger.output.user?.email}}` | | Mehrere in einem String | `Bestellung {{id}} über {{amount}}` | `Bestellung {{trigger.output.id}} über {{trigger.output.amount}}` | *** ## Best Practices Benenne Nodes klar, damit Variablen selbstdokumentierend sind: `{{AnalyzeCustomerFeedback.output.sentiment}}` ist viel klarer als `{{agent1.output.sentiment}}` Nachdem du einen Node hinzugefügt hast, führe einen Test aus und klicke auf den Node, um seinen Output zu inspizieren. Dies bestätigt die Datenstruktur, bevor du sie in nachgelagerten Nodes verwendest. Verwende Standardwerte für optionale Felder: ```javascript theme={null} const priority = analyze.output.priority || "medium"; const tags = trigger.output.tags || []; ``` Wenn du dich dabei erwischst, tief verschachtelte Pfade wie `{{node.output.data.items[0].meta.tags[2].value}}` zu schreiben, erwäge die Verwendung eines Code-Nodes, um die Datenstruktur zuerst zu vereinfachen. Füge Kommentare in Code-Nodes oder Beschreibungen in Nodes hinzu, wenn du komplexe Variablen-Logik verwendest, besonders für Team-Workflows. *** ## Nächste Schritte Jetzt, da du Variablen verstehst, erkunde, wie du sie effektiv in verschiedenen Kontexten verwenden kannst: Lerne, wie du Variablen in Auto-, Manual- und AI Prompt-Modi verwendest Transformiere und manipuliere Variablen mit benutzerdefiniertem Code Verwende Variablen, um dynamische Routing-Logik zu erstellen Verstehe, wie Variablen ins große Ganze passen ## FAQ Nutze Variablen, wenn ein späterer Node Daten von einem Trigger oder einem früheren Node braucht. Variablen machen Workflows dynamisch, indem sie Nutzereingaben, API-Antworten, generierten Text oder extrahierte Werte zwischen Schritten weitergeben. Prüfe den Variablenpfad, ob der frühere Node den Wert tatsächlich erzeugt hat und ob der Wert für den aktuellen Lauf existiert. Bei verschachtelten Daten überprüfe den exakten Feldnamen und die Struktur.