Comprendre les flows : workflows multi-agents

Bienvenue dans la partie 4 de notre guide en huit parties, Démarrer avec GitLab Duo Agent Platform, dans laquelle vous apprendrez à maîtriser la construction et le déploiement d'agents d'IA et de workflows au sein de votre cycle de développement. Suivez des tutoriels qui vous mèneront de votre première interaction à des workflows d'automatisation prêts pour la production avec une personnalisation complète.

🎯 Essayez GitLab Duo Agent Platform dès aujourd'hui !

Introduction aux flows

Les flows sont des combinaisons d'un ou de plusieurs agents qui collaborent ensemble. Ils orchestrent des workflows multi-étapes pour résoudre des problèmes complexes et s'exécutent sur la plateforme de calcul de GitLab.

Caractéristiques clés des flows :

• Orchestration multi-agents : ils combinent plusieurs agents spécialisés.
• Intégrés : ils s'exécutent sur la plateforme de calcul, aucun environnement supplémentaire nécessaire.
• Pilotés par des événements : ils sont déclenchés par des mentions, des assignations ou peuvent être assignés en tant que relecteur.
• Asynchrones : ils s'exécutent en arrière-plan pendant que vous continuez à travailler.
• Workflows complets : ils gèrent les tâches de bout en bout, de l'analyse à l'implémentation.

Les flows sont des workflows autonomes capables de rassembler du contexte, de prendre des décisions, d'exécuter des changements et de livrer des résultats pendant que vous vous concentrez sur d'autres tâches.

Flows vs agents : quelle est la différence ?

Les agents travaillent avec vous de manière interactive. Les flows travaillent pour vous de manière autonome.

Vue d'ensemble des types de flows

Flows de base

Les flows de base sont des workflows prêts pour la production créés et maintenus par GitLab. Ils sont accessibles via des contrôles UI dédiés ou des interfaces IDE.

Flows de base actuellement disponibles

Flows personnalisables

Les flows personnalisables sont des workflows définis en YAML que vous créez pour les besoins spécifiques de votre équipe. Ils s'exécutent dans GitLab Runner et peuvent être déclenchés par des événements GitLab.

🎯 Essayez les flows : visionnez notre démo interactive des flows personnalisables pour explorer comment les créer et les configurer.

Pourquoi créer des flows personnalisés ?

Les flows personnalisables automatisent les tâches multi-étapes répétitives spécifiques au workflow de votre équipe. Contrairement aux flows de base qui servent des objectifs généraux, les flows personnalisables sont adaptés aux processus, outils et exigences de votre organisation.

Cas d'utilisation courants :

• Revue de code automatisée : processus de revue multi-étapes (scan de sécurité → vérification de qualité → validation de style)
• Vérification de la conformité : vérification des exigences réglementaires, de la conformité des licences ou des politiques de sécurité pour chaque merge request
• Génération de documentation : mise à jour automatique de la documentation API, des fichiers README ou des changelogs basée sur les modifications de code
• Gestion des dépendances : scans de sécurité hebdomadaires, mises à jour automatisées et rapports de vulnérabilité
• Tests personnalisés : suites de tests spécialisées pour votre pile technologique ou vos tests d'intégration

Exemple concret

Une entreprise fintech crée un flow de conformité qui s'exécute sur chaque merge request. Lorsqu'il est déclenché par @compliance-flow, le flow exécute les étapes suivantes :

1. L'agent Security Analyst scanne le code pour détecter les violations PCI-DSS et vérifie les données sensibles exposées.
2. L'agent Code Review vérifie que les modifications respectent les standards de codage sécurisé et les bonnes pratiques.
3. L'agent de documentation vérifie que les modifications apportées à l'API incluent une documentation mise à jour.
4. L'agent de synthèse agrège les résultats et publie un rapport de conformité avec un statut réussite/échec.

L'ensemble de la revue de conformité se déroule automatiquement en 5 à 10 minutes, avec des vérifications cohérentes sur toutes les merge requests.

Comment déclencher des flows personnalisés ?

Les flows personnalisés peuvent être déclenchés de plusieurs façons :

1. Via des mentions dans les tickets/merge requests : mentionnez le flow dans un commentaire pour le déclencher. Exemple pour un flow de génération de documentation :

      @doc-generator Generate API documentation for this feature

    

2. En assignant le flow à un ticket ou une merge request : assignez le flow en utilisant :

• L'interface utilisateur de GitLab : cliquez sur le bouton « Assigner » sur le ticket/la merge request et sélectionnez le flow.
• Commande : utilisez la commande /assign dans un commentaire. Exemple :

      /assign @doc-generator

    

3. En assignant le flow en tant que relecteur : assignez le flow comme relecteur sur une merge request en utilisant :

• L'interface utilisateur de GitLab : cliquez sur le bouton « Assigner un relecteur » sur la merge request et sélectionnez le flow.
• Commande : utilisez la commande /assign reviewer dans un commentaire. Exemple :

      /assign_reviewer @doc-reviewer

    

Chacune de ces méthodes déclenche automatiquement le flow pour qu'il exécute ses tâches.

Comment créer des flows personnalisés

Les flows personnalisés sont créés via l'interface de GitLab sous Automatisation → Flows → Nouveau flow dans votre projet, ou depuis Explorer → Catalogue d'IA → Flows → Nouveau flow. Vous définissez votre flow à l'aide d'une configuration YAML qui précise les composants, les prompts, le routage et le flow d'exécution. Le schéma YAML vous permet de créer des workflows multi-agents sophistiqués avec un contrôle précis du comportement et de l’orchestration des agents.

Éléments clés d'un flow personnalisé :

• Composants : définissez les agents et les étapes de votre workflow
• Prompts : configurez le comportement et les instructions du modèle d'IA
• Routeurs : contrôlez le flow entre les composants
• Set d'outils : indiquez quels outils de l'API GitLab les agents peuvent utiliser

Exemple de flow personnalisé YAML

Contexte : cet exemple montre un flow d'implémentation de fonctionnalité pour une plateforme de réservation de voyages. Lorsqu'un développeur crée un ticket avec des exigences de fonctionnalité, il peut déclencher ce flow pour analyser automatiquement les exigences, examiner le code source, implémenter la solution et créer une merge request, le tout sans intervention manuelle.

Voici la configuration YAML :

      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"

    

Ce que fait ce flow : ce flow orchestre un agent d'IA pour implémenter automatiquement une fonctionnalité en analysant les exigences du ticket, en examinant le code source, en écrivant du code prêt pour la production avec une expertise métier, et en créant une merge request avec un commentaire de synthèse détaillé.

Pour obtenir une documentation complète et des exemples, consultez les pages suivantes :

• Documentation relative aux flows personnalisables
• Framework de dépôt des flows (schéma YAML)

Exécution des flows

Les flows s'exécutent sur le système de calcul de la plateforme GitLab. Lorsqu'ils sont déclenchés par un événement (mention, assignation ou clic sur un bouton), une session est créée et le flow commence à s'exécuter.

Variables d'environnement disponibles

Les flows ont accès à des variables d'environnement qui fournissent le contexte sur le déclencheur et l'objet GitLab :

• AI_FLOW_CONTEXT : contexte sérialisé en JSON qui inclut les diffs des merge requests, les descriptions des tickets, les commentaires et les fils de discussion
• AI_FLOW_INPUT : le texte du prompt ou du commentaire de l'utilisateur qui a déclenché le flow
• AI_FLOW_EVENT : le type d'événement qui a déclenché le flow (mention, assign, assign_reviewer)

Ces variables permettent à votre flow de comprendre ce qui l'a déclenché et d'accéder aux données GitLab pertinentes pour effectuer sa tâche.

Flows multi-agents

Les flows personnalisés peuvent inclure plusieurs composants d'agents qui travaillent ensemble de manière séquentielle. La configuration YAML du flow définit :

• Les composants : un ou plusieurs agents (AgentComponent) ou étapes déterministes
• Routeurs : définissent le flow entre les composants (par exemple, du composant A au composant B jusqu'à la fin)
• Prompts : configurent le comportement et le modèle de chaque agent

Par exemple, un flow de revue de code pourrait avoir un agent de sécurité, puis un agent de qualité, puis un agent d'approbation, avec des routeurs qui les connectent en séquence.

Surveillance de l'exécution des flows

Pour afficher les flows en cours d'exécution pour votre projet :

1. Accédez à Automatisation → Sessions.
2. Sélectionnez une session pour afficher plus de détails.
3. L'onglet Détails affiche un lien vers les logs du job CI/CD.

Les sessions affichent des informations détaillées qui incluent la progression étape par étape, les outils invoqués, le raisonnement et le processus de prise de décision.

Quand utiliser les flows

• Tâches complexes multi-étapes
• Automatisation en arrière-plan
• Workflows basés sur les événements
• Modifications multi-fichiers
• Tâches chronophages
• Revues/vérifications automatisées

Prochaines étapes

Vous connaissez maintenant les flows et savez comment les créer et quand les utiliser par rapport aux agents. Dans la Partie 5 : découvrir le catalogue d'IA, vous apprendrez à créer et à partager des agents et des flows dans votre organisation. Explorez le catalogue d'IA pour connaître les flows et agents disponibles, les ajouter à vos projets, et publier vos propres agents et flows.

Ressources

• Flows de GitLab Duo Agent Platform
• Documentation relative aux flows de base
• Documentation relative aux flows personnalisables
• Configuration d'exécution des flows
• Guide des variables CI/CD de GitLab
• Comptes de service

Article suivant : Partie 5 : découvrir le catalogue d'IA

Article précédent : Partie 3 : comprendre les agents