Skip to main content
Automate ist die Workflow-Automatisierungsplattform von Localmind. Mit Automate können Sie komplexe Workflows erstellen, die Ihre KI-Agenten nahtlos mit anderen Systemen verbinden. Sie ermöglicht es Ihnen, visuelle Workflows zu erstellen, die verschiedene Dienste, APIs und Ihre Localmind-Agenten miteinander verbinden.

Visuelle Workflows

Erstellen Sie komplexe Automatisierungen durch einfaches Verbinden von Nodes – ohne Code zu schreiben.

KI-Integration

Nutzen Sie Ihre Localmind-Agenten direkt in Ihren Workflows für intelligente Entscheidungen.

Hunderte von Integrationen

Verbinden Sie sich mit über 400+ Apps und Diensten wie Slack, Google Sheets, APIs und mehr.

Self-Hosted Option

Behalten Sie die volle Kontrolle über Ihre Daten mit Self-Hosting-Optionen.

Erste Schritte

Zugriff auf Automate

  1. Navigieren Sie zum Automate-Bereich in Ihrem Localmind-Dashboard
  2. Klicken Sie auf “Neuer Workflow” um Ihren ersten Workflow zu erstellen
  3. Wählen Sie eine Vorlage oder starten Sie mit einem leeren Workflow
Wenn Sie neu bei Automate sind, beginnen Sie mit einer der vorgefertigten Vorlagen, um die Konzepte zu verstehen.

Grundkonzepte

Nodes (Knoten)

Nodes sind die Bausteine Ihrer Workflows. Jeder Node repräsentiert eine Aktion oder einen Schritt in Ihrem Automatisierungsprozess.
Trigger Nodes starten Ihren Workflow automatisch:
  • Webhook: Empfängt HTTP-Anfragen
  • Schedule: Zeitbasierte Ausführung (Cron)
  • Manual: Manuelle Ausführung
  • Email: E-Mail-basierte Trigger
{
  "method": "POST",
  "path": "/webhook/trigger",
  "responseMode": "responseNode"
}
Action Nodes führen Operationen aus:
  • HTTP Request: API-Aufrufe
  • Set: Daten setzen/transformieren
  • IF: Bedingte Logik
  • Switch: Multi-Branch-Logik
  • Localmind Agent: KI-Agenten aufrufen
{
  "method": "GET",
  "url": "https://api.example.com/data",
  "authentication": "genericCredentialType",
  "options": {}
}
Der Localmind Agent Node integriert Ihre KI-Agenten direkt in Workflows:
  • Wählen Sie einen Agenten aus Ihrer Agent-Bibliothek
  • Übergeben Sie Daten als Kontext
  • Erhalten Sie strukturierte Antworten
  • Nutzen Sie die Antworten für weitere Workflow-Schritte
{
  "agentId": "agent_123abc",
  "input": "{{ $json.userQuery }}",
  "context": {
    "userId": "{{ $json.userId }}",
    "sessionId": "{{ $json.sessionId }}"
  },
  "options": {
    "temperature": 0.7,
    "maxTokens": 500
  }
}

Workflow-Struktur

Ein typischer Workflow folgt diesem Muster:
Trigger → Datenverarbeitung → Agent-Aufruf → Aktion → Ausgabe
1

Workflow erstellen

  1. Klicken Sie auf “Neuer Workflow”
  2. Geben Sie einen Namen ein (z.B. “Kundenanfrage verarbeiten”)
  3. Wählen Sie einen Trigger-Node aus
Beginnen Sie mit einem Manual Trigger für Tests, später können Sie auf einen automatischen Trigger umstellen.
2

Nodes hinzufügen

  1. Klicken Sie auf das ”+” Symbol
  2. Suchen Sie nach dem gewünschten Node (z.B. “Localmind Agent”)
  3. Ziehen Sie den Node auf das Canvas
  4. Verbinden Sie Nodes durch Ziehen von den Ausgängen zu den Eingängen
Stellen Sie sicher, dass die Datenformate zwischen Nodes kompatibel sind. Verwenden Sie “Set” Nodes zur Datenumwandlung.
3

Node konfigurieren

  1. Klicken Sie auf einen Node, um ihn zu öffnen
  2. Füllen Sie die erforderlichen Felder aus
  3. Verwenden Sie Expressions ({{ }}) für dynamische Werte
  4. Testen Sie mit “Execute Node”
// Zugriff auf vorherige Node-Daten
{{ $json.fieldName }}

// Zugriff auf Workflow-Daten
{{ $workflow.staticData.value }}

// Funktionen verwenden
{{ $now.toISO() }}
{{ $json.text.toUpperCase() }}

// JSON Stringify - Objekte in Strings umwandeln
{{ JSON.stringify($json) }}
{{ JSON.stringify($json.user) }}
4

Workflow aktivieren

  1. Klicken Sie auf “Active” Toggle oben rechts
  2. Für Production: Konfigurieren Sie einen automatischen Trigger
  3. Überwachen Sie Ausführungen im “Executions” Tab
Testen Sie Ihren Workflow gründlich, bevor Sie ihn aktivieren. Nutzen Sie die “Test Workflow” Funktion.

Praktisches Beispiel: E-Mail-zu-Agent-Workflow

Lassen Sie uns einen einfachen Workflow erstellen, der E-Mails empfängt, sie an einen Localmind-Agenten weiterleitet und eine Antwort sendet.

Workflow-Struktur

Email Trigger → Set Node → Localmind Agent → HTTP Request (Send Email)

Schritt-für-Schritt Anleitung

IMAP Email Trigger einrichten:
  1. Node hinzufügen: “IMAP Email”
  2. Credentials konfigurieren (IMAP-Server, Benutzername, Passwort)
  3. Polling-Intervall setzen (z.B. jede Minute)
  4. Filter konfigurieren (optional): Nur E-Mails von bestimmten Absendern
{
  "mailbox": "INBOX",
  "options": {
    "allowUnauthorizedCerts": false
  },
  "format": "simple"
}
Set Node verwenden, um Daten für den Agenten zu strukturieren:
  1. Node hinzufügen: “Set”
  2. Felder setzen:
    • emailSubject: {{ $json.subject }}
    • emailBody: {{ $json.textPlain }}
    • senderEmail: {{ $json.from.value[0].address }}
    • timestamp: {{ $now.toISO() }}
{
  "values": {
    "emailSubject": "={{ $json.subject }}",
    "emailBody": "={{ $json.textPlain }}",
    "senderEmail": "={{ $json.from.value[0].address }}",
    "timestamp": "={{ $now.toISO() }}"
  },
  "options": {}
}
Localmind Agent Node konfigurieren:
  1. Node hinzufügen: “Localmind Agent”
  2. Agent auswählen (z.B. “E-Mail-Assistent”)
  3. Prompt erstellen:
Du bist ein hilfreicher E-Mail-Assistent. 
Analysiere die folgende E-Mail und erstelle eine professionelle Antwort.

Betreff: {{ $json.emailSubject }}
Nachricht: {{ $json.emailBody }}
Absender: {{ $json.senderEmail }}
  1. Kontext-Daten übergeben (optional)
  2. Ausgabe-Modus wählen (JSON oder Text)
{
  "agentId": "email_assistant_123",
  "prompt": "Analysiere diese E-Mail: {{ $json.emailBody }}",
  "context": {
    "sender": "={{ $json.senderEmail }}",
    "subject": "={{ $json.emailSubject }}"
  },
  "options": {
    "temperature": 0.7,
    "responseFormat": "json"
  }
}
HTTP Request Node für E-Mail-Versand:
  1. Node hinzufügen: “HTTP Request”
  2. Methode: POST
  3. URL: Ihre E-Mail-API (z.B. SendGrid, Mailgun)
  4. Body konfigurieren:
{
  "to": "{{ $('Set').item.json.senderEmail }}",
  "subject": "Re: {{ $('Set').item.json.emailSubject }}",
  "text": "{{ $json.agentResponse }}"
}
Verwenden Sie $('NodeName') um auf Daten von vorherigen Nodes zuzugreifen.

Häufige Patterns

Pattern 1: Bedingte Verarbeitung

Verwenden Sie IF Nodes für bedingte Logik:
Trigger → IF (Bedingung) → [True Branch] → [False Branch]
// Prüfe ob E-Mail wichtig ist
{{ $json.importance === 'high' }}

// Prüfe ob Betreff bestimmtes Keyword enthält
{{ $json.subject.includes('URGENT') }}

// Prüfe ob Absender in Whitelist
{{ ['admin@company.com', 'support@company.com'].includes($json.senderEmail) }}

Pattern 2: Parallele Verarbeitung

Verwenden Sie mehrere ausgehende Verbindungen für parallele Ausführung:
Trigger → [Branch 1] → Agent 1
       → [Branch 2] → Agent 2
       → [Branch 3] → Agent 3

Pattern 3: Error Handling

Implementieren Sie Fehlerbehandlung mit Error Trigger:
Workflow → Try/Catch → Error Trigger → Notification
Immer Error Handling implementieren! Nutzen Sie den “Error Trigger” Node für robuste Workflows.

Pattern 4: Daten Stringifyen

Stringifyen bedeutet, Objekte oder andere Datentypen in Strings (Zeichenketten) umzuwandeln. Dies ist wichtig, wenn Sie komplexe Datenstrukturen in Textfelder einfügen oder als Parameter in HTTP-Anfragen verwenden müssen.
Objekte in JSON-Strings umwandeln:
// Komplettes Objekt stringifyen
{{ JSON.stringify($json) }}

// Spezifisches Feld stringifyen
{{ JSON.stringify($json.user) }}

// Mit Formatierung (schöner lesbar)
{{ JSON.stringify($json, null, 2) }}

// In Set Node verwenden
{
  "jsonString": "={{ JSON.stringify($json) }}",
  "userString": "={{ JSON.stringify($json.user) }}"
}
JSON-Daten als String im Request Body:
{
  "method": "POST",
  "url": "https://api.example.com/webhook",
  "body": {
    "data": "={{ JSON.stringify($json) }}",
    "metadata": "={{ JSON.stringify($json.metadata) }}"
  }
}
Stringifyen in Function Node:
// Objekt stringifyen
const dataString = JSON.stringify($input.item.json);

// Mit Formatierung
const formattedString = JSON.stringify($input.item.json, null, 2);

// Für Logging
console.log('Data:', JSON.stringify($input.item.json));

return [{
  json: {
    originalData: $input.item.json,
    stringified: dataString,
    formatted: formattedString
  }
}];
Arrays in Strings umwandeln:
// Array stringifyen
{{ JSON.stringify($json.items) }}

// Array als komma-separierte Werte
{{ $json.items.map(item => item.id).join(',') }}

// Array als JSON-String
{{ JSON.stringify($json.items.map(item => item.name)) }}
Häufige Anwendungsfälle:

HTTP Request Body

Wenn API nur String erwartet, nicht JSON-Objekt

Logging

Für strukturiertes Logging von Objekten

Datenbank-Speicherung

Wenn Datenbank nur Textfelder unterstützt

E-Mail-Body

Für formatierte JSON-Daten in E-Mails

Webhook-Payload

Wenn Webhook JSON-String erwartet

Debugging

Für bessere Lesbarkeit in Logs
Strings zurück in Objekte umwandeln:
// String zurück zu Objekt
{{ JSON.parse($json.jsonString) }}

// Mit Fehlerbehandlung
{{ JSON.parse($json.jsonString || '{}') }}

// In Function Node
const parsed = JSON.parse($input.item.json.jsonString);
const userId = parsed.user.id;
Best Practice: Verwenden Sie JSON.stringify() immer dann, wenn Sie komplexe Datenstrukturen als String übergeben müssen. Für einfache Werte (Strings, Numbers) ist Stringifyen nicht notwendig.

Best Practices

Diese Best Practices basieren auf bewährten Methoden für die Entwicklung professioneller, wartbarer Automate-Workflows. Sie helfen Ihnen, effiziente und zuverlässige Automatisierungen zu erstellen.

1. Use Case First, Workflow Second

Beginnen Sie mit der Problemdefinition, bevor Sie mit der Workflow-Implementierung starten. Dieser Ansatz stellt sicher, dass der Workflow sich an Ihre Anforderungen anpasst, nicht umgekehrt.
1

Geschäftsproblem definieren

Formulieren Sie das zu lösende Problem in klaren, geschäftlichen Begriffen.Beispiel: “Automatische Kategorisierung von Support-E-Mails mit Weiterleitung dringender Anfragen an das Support-Team.”
2

Input und Output spezifizieren

Definieren Sie präzise die erwarteten Eingabedaten und das gewünschte Ausgabeformat.Input: E-Mail mit Betreff, Absender, Inhalt Output: Kategorisierung (dringend/normal) mit entsprechender Weiterleitung
3

Logische Schritte identifizieren

Zerlegen Sie den Prozess in 3-5 logische Verarbeitungsschritte.
  1. E-Mail empfangen
  2. Mit Agent analysieren
  3. Kategorisierung durchführen
  4. Bei “dringend” → Benachrichtigung senden
4

Node-Auswahl

Wählen Sie die erforderlichen Nodes basierend auf den definierten Schritten aus.
Der Workflow sollte sich an Ihren Use Case anpassen. Beginnen Sie mit einer einfachen Implementierung und iterieren Sie basierend auf den Ergebnissen.

2. Vorlagen und bestehende Lösungen nutzen

Vor der Implementierung eines neuen Workflows sollten Sie zunächst nach bestehenden Vorlagen und ähnlichen Lösungen suchen. Dies beschleunigt die Entwicklung und reduziert Fehler.

Community-Vorlagen

Durchsuchen Sie die Automate-Vorlagenbibliothek und Community-Beispiele für ähnliche Use Cases.

Use Case Recherche

Recherchieren Sie nach dokumentierten Automatisierungen für vergleichbare Anforderungen.
Vorteile:
  • Schnellere Entwicklung durch Wiederverwendung bewährter Patterns
  • Entdeckung neuer Nodes und Implementierungsansätze
  • Vermeidung bekannter Fehlerquellen

3. Data Flow Principle verstehen

Jeder Automate-Workflow folgt dem grundlegenden Prinzip: Input → Transform → Output Häufig verwendete Datenquellen:
  • Eigene Datenbanken (Airtable, Google Sheets, Supabase)
  • Öffentliche APIs (HTTP Request Node, dedizierte API-Nodes)
Empfohlener Workflow für HTTP Request Nodes:
1

cURL-Befehl aus API-Dokumentation extrahieren

Kopieren Sie den cURL-Befehl aus der offiziellen API-Dokumentation.
2

In Postman validieren

Importieren Sie den Request in Postman und testen Sie ihn mit realen Parametern.
3

Funktionalität verifizieren

Stellen Sie sicher, dass der Request mit Ihrem spezifischen Use Case funktioniert.
4

Nach Automate übertragen

Übertragen Sie den validierten Request nach Automate.
Postman ist ein wertvolles Tool für die API-Entwicklung und wird von professionellen Entwicklern häufig verwendet. Es erleichtert das Testen und Debugging von API-Requests erheblich.

4. Kern-Nodes beherrschen

Die meisten Workflows können mit einer überschaubaren Anzahl von Nodes implementiert werden. Konzentrieren Sie sich zunächst auf diese Kern-Nodes: Datenbereinigung und Transformation:
  • Set/Edit Fields: Spalten extrahieren, Datentypen konvertieren, Datenstrukturen anpassen
  • Filter: Ungültige Datensätze entfernen (null-Werte, Duplikate, Formatfehler)
  • Merge: Spalten hinzufügen oder Datensätze kombinieren
  • Code: Komplexe Transformationen, die mit Standard-Nodes nicht möglich sind
  • IF: Bedingte Verarbeitungslogik implementieren
KI-Verarbeitung:
  • Localmind Agent: Für die meisten KI-basierten Aufgaben
Typischer Workflow-Pattern:
HTTP Request → Set (Datenbereinigung) → Filter (Validierung) → 
Agent (Analyse) → Set (Output-Formatierung) → Datenbank-Insert
Für Code-Nodes können Sie KI-Assistenten verwenden, um Code basierend auf Input-Datenstruktur und gewünschtem Output zu generieren. Dies beschleunigt die Entwicklung komplexer Transformationen.

5. Node-Outputs pinnen für effizientes Testing

Das Pinnen von Node-Outputs ermöglicht es, nachgelagerte Nodes zu testen, ohne den gesamten Workflow erneut auszuführen. Dies spart Zeit und reduziert Kosten bei API-Calls und KI-Verarbeitung.
1

Workflow initial ausführen

Führen Sie den Workflow einmal vollständig aus, um echte Daten zu generieren.
2

Outputs pinnen

Klicken Sie auf das Pin-Icon bei jedem Node-Output, den Sie für Tests wiederverwenden möchten.
3

Gepinnte Daten anpassen

Bearbeiten Sie gepinnte Daten, um verschiedene Test-Szenarien zu simulieren, einschließlich Edge Cases.
4

Downstream-Nodes testen

Testen Sie nachgelagerte Nodes mit gepinnten Daten, ohne erneute API-Calls oder KI-Verarbeitung.
Kostenoptimierung: Ein einzelner Agent-Node-Test ohne Pinning kann mehr als $0.10 kosten. Bei wiederholten Tests summieren sich diese Kosten erheblich. Pinnen Sie Outputs immer für Testzwecke.

6. Sub-Workflows für modulare Architektur

Komplexe Workflows sollten in wiederverwendbare Sub-Workflows aufgeteilt werden. Dies verbessert die Wartbarkeit, Testbarkeit und Wiederverwendbarkeit. Empfohlene Struktur:
  • Haupt-Workflows enthalten maximal 4-6 Nodes
  • Häufig verwendete Funktionalität wird in Sub-Workflows abstrahiert
  • Sub-Workflows fungieren als wiederverwendbare Komponenten
Organisationsstruktur:
1

Components-Ordner anlegen

Erstellen Sie einen dedizierten Ordner für wiederverwendbare Komponenten.
2

Sub-Workflows entwickeln

Entwickeln Sie Sub-Workflows für häufige Aufgaben:
  • Datenbereinigung und Validierung
  • Error Handling und Retry-Logik
  • Benachrichtigungen und Alerting
3

In Haupt-Workflows integrieren

Referenzieren Sie Sub-Workflows in Ihren Haupt-Workflows.
Vorteile:
  • Isolierte Fehlerbehebung: Fehler können schnell auf einen spezifischen Sub-Workflow eingegrenzt werden
  • Wiederverwendbarkeit: Komponenten können in verschiedenen Workflows verwendet werden
  • Bessere Übersichtlichkeit: Haupt-Workflows bleiben übersichtlich und nachvollziehbar

7. Umfassendes Error Logging implementieren

Ein robustes Error-Logging-System ermöglicht proaktive Fehlererkennung und schnelle Problemlösung. Implementieren Sie Logging, das alle relevanten Informationen erfasst. Erforderliche Logging-Informationen:
  • Fehlermeldung und Fehlertyp
  • Fehlerstelle (Node-Name, Execution-ID)
  • Input-Daten, die den Fehler verursacht haben
  • Zeitstempel und Workflow-Kontext
  • Retry-Versuche und deren Ergebnisse
Erfolgreiche Executions sollten ebenfalls geloggt werden. Dies ermöglicht die Erstellung von Berichten über Workflow-Performance und hilft bei der Identifizierung von Trends.

8. KI-Kostenüberwachung

Unkontrollierte KI-Kosten können zu unerwarteten Ausgaben führen. Implementieren Sie ein System zur Überwachung und Kontrolle von KI-bezogenen Kosten. Zu überwachende Metriken:

Token-Verbrauch

Überwachen Sie den Token-Verbrauch pro Execution und identifizieren Sie Optimierungspotenziale.

Kosten pro Execution

Berechnen Sie die Kosten pro Workflow-Ausführung für Budgetplanung und Kostentransparenz.

Ausgabenlimits

Implementieren Sie tägliche und monatliche Ausgabenlimits, um unerwartete Kosten zu vermeiden.

Performance-Metriken

Überwachen Sie Model-Performance und Response-Qualität zur kontinuierlichen Optimierung.
Kostentransparenz: Unerwartete Kosten können das Vertrauen in Automatisierungen beeinträchtigen. Implementieren Sie von Anfang an ein transparentes Kosten-Tracking und kommunizieren Sie Kostenstrukturen klar.

Debugging

Erfahren Sie mehr über Debugging-Techniken und Fehlerbehebung in unserer Debugging-Anleitung.

Häufige Probleme und Lösungen

Mögliche Ursachen:
  • Workflow ist nicht aktiviert
  • Trigger ist nicht konfiguriert
  • Credentials fehlen oder sind ungültig
Lösung:
  1. Prüfen Sie den “Active” Status
  2. Überprüfen Sie Trigger-Konfiguration
  3. Testen Sie Credentials einzeln
Mögliche Ursachen:
  • Falsche Expression-Syntax
  • Datenformat-Inkompatibilität
  • Node-Reihenfolge falsch
Lösung:
  1. Verwenden Sie {{ $json.fieldName }} für Datenzugriff
  2. Prüfen Sie Datenformate zwischen Nodes
  3. Nutzen Sie “Set” Nodes zur Datenumwandlung
  4. Überprüfen Sie die Execution-Logs
Mögliche Ursachen:
  • Agent-ID falsch
  • Prompt-Format ungültig
  • API-Limits erreicht
Lösung:
  1. Überprüfen Sie Agent-ID und Verfügbarkeit
  2. Testen Sie Prompt direkt im Agent-Interface
  3. Prüfen Sie API-Quotas und Limits
  4. Überprüfen Sie Error-Logs im Agent-Node

Execution Logs nutzen

  1. Navigieren Sie zum “Executions” Tab
  2. Wählen Sie eine fehlgeschlagene Execution aus
  3. Klicken Sie auf jeden Node, um Input/Output zu sehen
  4. Überprüfen Sie Error-Messages für Details
Aktivieren Sie “Save Data on Error” in Workflow-Einstellungen, um Debugging zu erleichtern.

Nächste Schritte

Nachdem Sie die Grundlagen verstanden haben, erkunden Sie:
Brauchen Sie Hilfe? Unser Support-Team hilft Ihnen gerne bei der Einrichtung Ihrer ersten Workflows. Kontaktieren Sie uns unter support@localmind.ai.