Flows verstehen: Multi-Agent-Workflows

Willkommen zu Teil 4 unseres achtteiligen Leitfadens GitLab Duo Agent Platform: Der vollständige Einstiegsleitfaden, in dem du lernst, KI-Agenten und Workflows in deinem Entwicklungslebenszyklus zu erstellen und bereitzustellen. Folge Tutorials, die dich von deiner ersten Interaktion zu produktionsreifen Automatisierungs-Workflows mit vollständiger Anpassung führen.

In diesem Artikel:

• Was sind Flows und wie funktionieren sie?
• Foundational Flows von GitLab
• Custom Flows erstellen
• Flow-Ausführung und Orchestrierung
• Real-World-Beispiele und Use Cases

🎯 Probiere GitLab Duo Agent Platform noch heute aus!

Einführung in Flows

Flows sind Kombinationen aus einem oder mehreren Agenten, die zusammenarbeiten. Sie orchestrieren mehrstufige Workflows, um komplexe Probleme zu lösen, und werden auf der GitLab-Plattform-Compute ausgeführt.

Hauptmerkmale von Flows:

• Multi-Agent-Orchestrierung: Kombiniere mehrere spezialisierte Agenten
• Built-in: Laufen auf Plattform-Compute, keine zusätzliche Umgebung erforderlich
• Event-gesteuert: Ausgelöst durch Mention, Assignment oder Assign as Reviewer
• Asynchron: Laufen im Hintergrund, während du weiterarbeitest
• Vollständige Workflows: Erledigen End-to-End-Aufgaben von Analyse bis Implementierung

Denke an Flows als autonome Workflows, die Kontext sammeln, Entscheidungen treffen, Änderungen ausführen und Ergebnisse liefern können, während du dich auf andere Arbeit konzentrierst.

Flows vs. Agents: Den Unterschied verstehen

Agenten arbeiten interaktiv mit dir. Flows arbeiten autonom für dich.

Flow-Typen im Überblick

Foundational Flows

Foundational Flows sind produktionsreife Workflows, die von GitLab erstellt und gewartet werden. Sie sind über dedizierte UI-Controls oder IDE-Interfaces zugänglich.

Aktuell verfügbare Foundational Flows

Custom Flows

Custom Flows sind YAML-definierte Workflows, die du für die spezifischen Anforderungen deines Teams erstellst. Sie laufen in GitLab Runner und können durch GitLab-Events ausgelöst werden.

🎯 Jetzt ausprobieren: Interaktive Demo von Custom Flows – Erkunde, wie du Custom Flows erstellen und konfigurieren kannst.

Warum Custom Flows erstellen?

Custom Flows automatisieren sich wiederholende mehrstufige Aufgaben, die spezifisch für den Workflow deines Teams sind. Anders als Foundational Flows, die allgemeinen Zwecken dienen, sind Custom Flows auf die Prozesse, Tools und Anforderungen deiner Organisation zugeschnitten.

Häufige Use Cases:

• Automatisierter Code Review: Mehrstufiger Review-Prozess (Security Scan → Quality Check → Style Validation)
• Compliance Checking: Überprüfe regulatorische Anforderungen, Lizenz-Compliance oder Sicherheitsrichtlinien bei jedem MR
• Dokumentationsgenerierung: Automatisches Update von API-Docs, README-Dateien oder Changelogs basierend auf Code-Änderungen
• Dependency Management: Wöchentliche Security-Scans, automatisierte Updates und Schwachstellenberichte
• Custom Testing: Spezialisierte Test-Suites für deinen Tech-Stack oder Integrationstests

Real-World-Beispiel

Ein Fintech-Unternehmen erstellt einen Compliance-Flow, der bei jedem Merge Request läuft. Wenn er durch @compliance-flow ausgelöst wird, führt der Flow folgende Schritte aus:

1. Security Agent scannt Code auf PCI-DSS-Verstöße und prüft auf exponierte sensible Daten.
2. Code Review Agent verifiziert, dass Änderungen sicheren Coding-Standards und Best Practices folgen.
3. Documentation Agent prüft, dass API-Änderungen aktualisierte Dokumentation enthalten.
4. Summary Agent aggregiert Findings und postet einen Compliance-Report mit Pass/Fail-Status.

Die gesamte Compliance-Überprüfung erfolgt automatisch in 5-10 Minuten und bietet konsistente Checks über alle Merge Requests hinweg.

Wie du Custom Flows auslöst

Custom Flows können auf mehrere Arten ausgelöst werden:

1. Via Mentions in Issues/MRs: Erwähne den Flow in einem Kommentar, um ihn auszulösen. Beispiel für einen Dokumentationsgenerierungs-Flow: @doc-generator Generate API documentation for this feature

2. Durch Zuweisen des Flows zu einem Issue oder MR: Weise den Flow über eine der folgenden Methoden zu:

• GitLab UI: Klicke den „Assign"-Button auf dem Issue/MR und wähle den Flow
• Command: Verwende den /assign-Befehl in einem Kommentar. Beispiel: /assign @doc-generator

3. Durch Zuweisen des Flows als Reviewer: Weise den Flow als Reviewer auf einem Merge Request über eine der folgenden Methoden zu:

• GitLab UI: Klicke den „Assign reviewer"-Button auf dem Merge Request und wähle den Flow
• Command: Verwende den /assign_reviewer-Befehl in einem Kommentar. Beispiel: /assign_reviewer @doc-reviewer Jede dieser Methoden löst den Flow automatisch aus, um seine Aufgaben auszuführen.

Wie du Custom Flows erstellst

Custom Flows werden über die GitLab UI unter Automate → Flows → New flow in deinem Projekt oder über Explore → AI Catalog → Flows → New flow erstellt. Du definierst deinen Flow mithilfe einer YAML-Konfiguration, die Komponenten, Prompts, Routing und Ausführungsablauf spezifiziert. Das YAML-Schema ermöglicht es dir, ausgeklügelte Multi-Agent-Workflows mit präziser Kontrolle über Agentenverhalten und Orchestrierung zu erstellen.

Schlüsselelemente eines Custom Flows:

• Components: Definiere die Agenten und Schritte in deinem Workflow
• Prompts: Konfiguriere KI-Modellverhalten und Anweisungen
• Routers: Steuere den Flow zwischen Komponenten
• Toolsets: Spezifiziere, welche GitLab-API-Tools Agenten verwenden können

Beispiel Custom Flow YAML

Hintergrund: Dieses Beispiel zeigt einen Feature-Implementierungs-Flow für eine Reisebuchungsplattform. Wenn ein(e) Entwickler(in) ein Issue mit Feature-Anforderungen erstellt, kann dieser Flow ausgelöst werden, um automatisch die Anforderungen zu analysieren, die Codebasis zu überprüfen, die Lösung zu implementieren und einen Merge Request zu erstellen, alles ohne manuelle Intervention. Hier ist die YAML-Konfiguration:

      version: "v1"
environment: ambient
components:
  - name: "implement_feature"
    type: AgentComponent
    prompt_id: "implementation_prompt"
    inputs:
      - from: "context:goal"
        as: "user_goal"
      - from: "context:project_id"
        as: "project_id"
    toolset:
      - "get_issue"
      - "get_repository_file"
      - "list_repository_tree"
      - "find_files"
      - "blob_search"
      - "create_file"
      - "create_commit"
      - "create_merge_request"
      - "create_issue_note"
    ui_log_events:
      - "on_agent_final_answer"
      - "on_tool_execution_success"
      - "on_tool_execution_failed"

prompts:
  - name: "Cheapflights Feature Implementation"
    prompt_id: "implementation_prompt"
    unit_primitives: []
    prompt_template:
      system: |
        You are an expert full-stack developer specializing in travel booking platforms, specifically Cheapflights.

        Your task is to:
        1. Extract the issue IID from the goal (look for "Issue IID: XX")
        2. Use get_issue with project_id={{project_id}} and issue_iid to retrieve issue details
        3. Analyze the requirements for the flight search feature
        4. Review the existing codebase using list_repository_tree, find_files, and get_repository_file
        5. Design and implement the solution following Cheapflights best practices
        6. Create all necessary code files using create_file (call multiple times for multiple files)
        7. Commit the changes using create_commit
        8. Create a merge request using create_merge_request
        9. Post a summary comment to the issue using create_issue_note with the MR link

        Cheapflights Domain Expertise:
        - Flight search and booking systems (Amadeus, Sabre, Skyscanner APIs)
        - Fare comparison and pricing strategies
        - Real-time availability and inventory management
        - Travel industry UX patterns
        - Performance optimization for high-traffic flight searches

        Code Standards:
        - Clean, maintainable code (TypeScript/JavaScript/Python/React)
        - Proper state management for React components
        - RESTful API endpoints with comprehensive error handling
        - Mobile-first responsive design
        - Proper timezone handling (use moment-timezone or date-fns-tz)
        - WCAG 2.1 accessibility compliance

        Flight-Specific Best Practices:
        - Accurate fare calculations (base fare + taxes + fees + surcharges)
        - Flight duration calculations across timezones
        - Search filter logic (price range, number of stops, airlines, departure/arrival times)
        - Sort algorithms (best value, fastest, cheapest)
        - Handle edge cases: date line crossing, daylight saving time, red-eye flights
        - Currency amounts use proper decimal handling (avoid floating point errors)
        - Dates use ISO 8601 format
        - Flight codes follow IATA standards (3-letter airport codes)

        Implementation Requirements:
        - No TODOs or placeholder comments
        - All functions must be fully implemented
        - Include proper TypeScript types or Python type hints
        - Add JSDoc/docstring comments for all functions
        - Comprehensive error handling and input validation
        - Basic unit tests for critical functions
        - Performance considerations for handling large result sets

        CRITICAL - Your final comment on the issue MUST include:
        - **Implementation Summary**: Brief description of what was implemented
        - **Files Created/Modified**: List of all files with descriptions
        - **Key Features**: Bullet points of main functionality
        - **Technical Approach**: Brief explanation of architecture/patterns used
        - **Testing Notes**: How to test the implementation
        - **Merge Request Link**: Direct link to the created MR (format: [View Merge Request](MR_URL))

        IMPORTANT TOOL USAGE:
        - Extract the issue IID from the goal first (e.g., "Issue IID: 12" means issue_iid=12)
        - Use get_issue with project_id={{project_id}} and issue_iid=<extracted_iid>
        - Create multiple files by calling create_file multiple times (once per file)
        - Use create_commit to commit all files together with a descriptive commit message
        - Use create_merge_request to create the MR and capture the MR URL from the response
        - Use create_issue_note with project_id={{project_id}}, noteable_id=<issue_iid>, and body=<your complete summary with MR link>
        - Make sure to include the MR link in the comment body so users can easily access it

      user: |
        Goal: {{user_goal}}
        Project ID: {{project_id}}

        Please complete the following steps:
        1. Extract the issue IID and retrieve full issue details
        2. Analyze the requirements thoroughly
        3. Review the existing codebase structure and patterns
        4. Implement the feature with production-ready code
        5. Create all necessary files (components, APIs, tests, documentation)
        6. Commit all changes with a clear commit message
        7. Create a merge request
        8. Post a detailed summary comment to the issue including the MR link

      placeholder: history
    params:
      timeout: 300

routers:
  - from: "implement_feature"
    to: "end"

flow:
  entry_point: "implement_feature"

    

Was dieser Flow macht: Dieser Flow orchestriert einen KI-Agenten, um automatisch ein Feature zu implementieren, indem er Issue-Anforderungen analysiert, die Codebasis überprüft, produktionsreifen Code mit Domain-Expertise schreibt und einen Merge Request mit einem detaillierten Summary-Kommentar erstellt.

Für vollständige Dokumentation und Beispiele siehe:

• Custom Flows Dokumentation
• Flow Registry Framework (YAML Schema)

Flow-Ausführung

Flows laufen auf GitLab-Plattform-Compute. Wenn sie durch ein Event (Mention, Assignment oder Button-Click) ausgelöst werden, wird eine Session erstellt und der Flow beginnt mit der Ausführung.

Verfügbare Umgebungsvariablen

Flows haben Zugriff auf Umgebungsvariablen, die Kontext über den Trigger und das GitLab-Objekt bereitstellen:

• AI_FLOW_CONTEXT – JSON-serialisierter Kontext inklusive MR-Diffs, Issue-Beschreibungen, Kommentaren und Discussion-Threads
• AI_FLOW_INPUT – Der Prompt- oder Kommentartext des Nutzers, der den Flow ausgelöst hat
• AI_FLOW_EVENT – Der Event-Typ, der den Flow ausgelöst hat (mention, assign, assign_reviewer)

Diese Variablen ermöglichen es deinem Flow zu verstehen, was ihn ausgelöst hat, und auf relevante GitLab-Daten zuzugreifen, um seine Aufgabe zu erfüllen.

Multi-Agent-Flows

Custom Flows können mehrere Agent-Komponenten enthalten, die sequenziell zusammenarbeiten. Die YAML-Konfiguration des Flows definiert:

• Components: Ein oder mehrere Agenten (AgentComponent) oder deterministische Schritte
• Routers: Definieren den Flow zwischen Komponenten (z.B. von Komponente A zu Komponente B zu Ende)
• Prompts: Konfigurieren das Verhalten und Modell jedes Agenten

Beispielsweise könnte ein Code-Review-Flow einen Security Agent, dann einen Quality Agent, dann einen Approval Agent haben, mit Routern, die sie sequenziell verbinden.

Flow-Ausführung überwachen

Um Flows anzuzeigen, die für dein Projekt laufen:

1. Navigiere zu Automate → Sessions.
2. Wähle eine beliebige Session aus, um mehr Details zu sehen.
3. Der Details-Tab zeigt einen Link zu den CI/CD-Job-Logs.

Sessions zeigen detaillierte Informationen inklusive Schritt-für-Schritt-Fortschritt, Tool-Aufrufe, Reasoning und Entscheidungsprozess.

Wann Flows verwenden

• Komplexe mehrstufige Aufgaben
• Hintergrund-Automatisierung
• Event-gesteuerte Workflows
• Multi-File-Änderungen
• Zeitaufwändige Aufgaben
• Automatisierte Reviews/Checks

Was kommt als Nächstes?

Du verstehst jetzt Flows, wie man sie erstellt und wann man sie im Vergleich zu Agenten verwendet. Als Nächstes lerne, wie du Agenten und Flows über deine Organisation hinweg entdecken, erstellen und teilen kannst in Teil 5: AI Catalog. Erkunde den AI Catalog, um verfügbare Flows und Agenten zu durchsuchen, sie zu deinen Projekten hinzuzufügen und deine eigenen Agenten und Flows zu veröffentlichen.

Ressourcen

• GitLab Duo Agent Platform Flows
• Foundational Flows Dokumentation
• Custom Flows Dokumentation
• Flow Execution Konfiguration
• GitLab CI/CD Variables Guide
• Service Accounts

Nächster: Teil 5: AI Catalog

Vorheriger: Teil 3: Agenten verstehen