Graphes d'agents de configuration

Tu utilises une skill qui te guidera dans la création et la gestion des graphes d'agents dans LaunchDarkly. Ton travail consiste à concevoir la topologie du graphe, le créer avec les bonnes arêtes et handoffs, et vérifier le routage entre les nœuds de configuration.

Prérequis

Cette skill nécessite que le serveur MCP LaunchDarkly hébergé à distance soit configuré dans ton environnement.

Outils MCP obligatoires :

• create-agent-graph -- créer un nouveau graphe avec nœuds et arêtes
• get-agent-graph -- inspecter la structure et les arêtes d'un graphe
• list-agent-graphs -- parcourir les graphes existants du projet

Outils MCP optionnels :

• update-agent-graph -- modifier les arêtes, la config racine ou la description
• delete-agent-graph -- supprimer définitivement un graphe
• get-ai-config -- inspecter les configs individuelles qui servent de nœuds
• create-ai-config -- créer de nouvelles configs à utiliser comme nœuds de graphe

Concepts clés

Qu'est-ce que les graphes d'agents ?

Un graphe d'agents est un graphe orienté où :

• Les nœuds sont des configs (chaque config est un agent avec son propre modèle, prompt et outils)
• Les arêtes définissent le routage entre configs (source -> cible)
• Les données de handoff sur les arêtes contrôlent comment le contexte est transmis entre agents
• La config racine est le point d'entrée — le premier agent qui reçoit l'entrée utilisateur

Quand utiliser les graphes d'agents

Structure du graphe

[Config racine] --arête--> [Config A] --arête--> [Config C]
                      \--arête--> [Config B]

Chaque arête a :

• key -- identifiant unique de l'arête
• sourceConfig -- la clé de config qui effectue le routage DEPUIS
• targetConfig -- la clé de config qui reçoit le routage VERS
• handoff (optionnel) -- données/instructions passées lors de la transition

Principes fondamentaux

1. Concevoir avant de construire : Cartographier d'abord les nœuds et les arêtes sur papier/tableau blanc
2. Un agent, une tâche : Chaque nœud doit avoir une responsabilité claire et ciblée
3. La config racine est le routeur : Le point d'entrée doit savoir comment dispatcher
4. Les données de handoff comptent : Définir quel contexte circule entre les agents
5. Vérifier le chemin complet : Tester que le routage fonctionne bout en bout

Workflow

Étape 1 : Concevoir le graphe

Avant de créer quoi que ce soit :

1. Identifier les agents (configs) nécessaires — chacun est un nœud du graphe
2. Mapper le routage : quel agent passe à quel autre ?
3. Définir les données de handoff : quel contexte chaque arête porte-t-elle ?
4. Identifier la config racine : quel agent reçoit l'entrée initiale ?
5. Vérifier les graphes existants avec list-agent-graphs pour éviter les doublons
6. Vérifier les configs existantes avec get-ai-config pour voir quels nœuds existent déjà

Étape 2 : S'assurer que les nœuds existent

Chaque nœud du graphe doit être une config existante. Si les configs n'existent pas encore :

1. Utiliser create-ai-config pour créer chaque config d'agent
2. Configurer les variations avec les modèles et prompts appropriés pour le rôle de chaque agent
3. Vérifier que chaque config existe avec get-ai-config

Étape 3 : Créer le graphe

Utiliser create-agent-graph avec :

• projectKey -- le projet contenant les configs
• key -- identifiant unique du graphe
• name -- nom d'affichage lisible
• description (optionnel) -- expliquer le but du graphe
• rootConfigKey -- la clé de config du point d'entrée
• edges -- tableau de connexions entre configs

{
  "projectKey": "my-project",
  "key": "support-triage-graph",
  "name": "Customer Support Triage",
  "description": "Routes customer queries to the appropriate specialist agent",
  "rootConfigKey": "triage-agent",
  "edges": [
    {
      "key": "triage-to-billing",
      "sourceConfig": "triage-agent",
      "targetConfig": "billing-specialist",
      "handoff": {"category": "billing", "priority": "normal"}
    },
    {
      "key": "triage-to-technical",
      "sourceConfig": "triage-agent",
      "targetConfig": "technical-specialist",
      "handoff": {"category": "technical", "priority": "normal"}
    }
  ]
}

Étape 4 : Vérifier

1. Utiliser get-agent-graph pour confirmer que le graphe a été créé avec la structure correcte
2. Vérifier que les arêtes connectent les bonnes configs source et cible
3. Vérifier que la clé de config racine correspond au point d'entrée prévu
4. Confirmer que les données de handoff sont présentes sur les arêtes qui en ont besoin

Rapporter les résultats :

• Graphe créé avec N nœuds et M arêtes
• Config racine définie correctement
• Toutes les arêtes vérifiées

Cas limites

Ce qu'il NE FAUT PAS faire

• Ne pas créer un graphe avant que les nœuds de config existent
• Ne pas oublier les données de handoff quand les agents ont besoin du contexte de leurs prédécesseurs
• Ne pas créer des graphes trop complexes — commencer simple et ajouter des nœuds au fur et à mesure
• Ne pas supprimer un graphe sans vérifier s'il est activement utilisé dans les workflows d'agents