Outils de Configuration

Vous utilisez une skill qui vous guidera pour ajouter des capacités à vos agents par le biais d'outils (function calling). Votre travail consiste à identifier ce que votre agent doit faire, créer des définitions d'outils, les attacher à des variations et vérifier qu'ils fonctionnent.

Prérequis

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

Outils MCP requis :

• create-ai-tool -- créer une nouvelle définition d'outil avec un schéma
• update-ai-config-variation -- attacher des outils à une variation de configuration
• get-ai-config -- vérifier que les outils sont attachés à la variation

Outils MCP optionnels :

• list-ai-tools -- parcourir les outils existants du projet
• get-ai-tool -- inspecter le schéma d'un outil spécifique

Principes Fondamentaux

1. Commencez par les Capacités : Réfléchissez à ce que votre agent doit faire avant de créer des outils
2. Le Framework Compte : LangGraph/CrewAI génèrent souvent automatiquement les schémas ; OpenAI SDK nécessite des schémas manuels
3. Créer Avant d'Attacher : Les outils doivent exister avant de pouvoir les attacher à des variations
4. Vérifier : L'agent récupère la config pour confirmer l'attachement
5. Complétez le Workflow Entier : Lister les outils existants est une étape de découverte, pas l'objectif final. Après avoir listé, procédez toujours à la création de l'outil demandé, attachez-le et vérifiez-le. Ne vous arrêtez pas après l'exploration.

Workflow

Étape 1 : Identifier les Capacités Nécessaires

Que devrait pouvoir faire l'agent ?

• Interroger des bases de données, appeler des API, effectuer des calculs, envoyer des notifications
• Vérifier ce qui existe dans la base de code (clients API, fonctions)
• Considérez le framework : LangGraph/LangChain génèrent automatiquement les schémas ; les SDK directs nécessitent des schémas manuels

Si l'utilisateur demande de d'abord vérifier les outils existants, ou si vous n'avez pas de contexte de base de code sur les outils existants, suivez cet ordre exact :

1. list-ai-tools -- explorer ce qui existe
2. create-ai-tool -- créer le nouvel outil (avec une clé différente des clés existantes)
3. update-ai-config-variation -- l'attacher
4. get-ai-config -- vérifier

Appelez list-ai-tools comme premier appel d'outil avant toute création. Ne vous arrêtez jamais après avoir simplement listé -- procédez toujours à travers les quatre étapes.

Étape 2 : Créer des Outils

Utilisez create-ai-tool avec :

• key -- identifiant unique pour l'outil
• description -- description claire (le LLM l'utilise pour décider quand appeler l'outil)
• schema -- JSON Schema brut (n'utilisez PAS le wrapper OpenAI function calling) :

{
  "type": "object",
  "properties": {
    "query": {"type": "string", "description": "Search query"},
    "limit": {"type": "integer", "default": 10}
  },
  "required": ["query"]
}

Étape 3 : Attacher à une Variation

Utilisez update-ai-config-variation pour attacher les outils. Passez uniquement le champ tools. Ne regroupez pas instructions, messages, model ou parameters dans ce PATCH sauf si l'utilisateur vous a explicitement demandé de mettre à jour également ces champs. Ces champs peuvent avoir été modifiés dans l'interface LaunchDarkly depuis la création de la variation, et les inclure dans un PATCH d'attachement d'outils écrasera silencieusement les modifications de l'interface.

{
  "projectKey": "my-project",
  "configKey": "support-chatbot",
  "variationKey": "default",
  "tools": [
    {"key": "search-knowledge-base", "version": 1}
  ]
}

Si vous observez un bug clair de l'interface où l'attachement d'outils efface d'autres champs, ne contournez pas le problème en renvoyant ces champs depuis la réponse get-ai-config précédente -- cela masque le bug et peut ressusciter des valeurs obsolètes que l'utilisateur a depuis modifiées. Signalez le bug à la place.

Étape 4 : Vérifier

1. Utilisez get-ai-tool pour confirmer que l'outil existe avec un schéma valide
2. Utilisez get-ai-config pour confirmer que l'outil est attaché à la variation (vérifiez tools dans la sortie de la variation)

Rapportez les résultats :

• Outil créé avec schéma valide
• Outil attaché à la variation
• Signalez tout problème

Schéma par fournisseur au point d'appel

LaunchDarkly stocke le schéma d'outil une fois -- la forme plate {type, name, description, parameters} que vous avez passée à create-ai-tool. Votre application le récupère via config.model.parameters.tools (mode completion) ou agent_config.model.parameters.tools (mode agent), puis le convertit à la forme que le SDK du fournisseur attend. LaunchDarkly ne passe jamais l'appel du fournisseur ; votre code le fait. Les handlers qui implémentent chaque outil restent également dans le code d'application -- LaunchDarkly stocke le schéma, votre application possède le comportement.

Snippets de conversion minimale (Python) :

ld_tools = (ai_config.model.to_dict().get("parameters") or {}).get("tools", []) or []

# OpenAI Chat Completions
openai_tools = [
    {
        "type": "function",
        "function": {
            "name": t["name"],
            "description": t.get("description", ""),
            "parameters": t.get("parameters", {"type": "object", "properties": {}}),
        },
    }
    for t in ld_tools
]

# Anthropic
anthropic_tools = [
    {
        "name": t["name"],
        "description": t.get("description", ""),
        "input_schema": t.get("parameters", {"type": "object", "properties": {}}),
    }
    for t in ld_tools
]

# Bedrock Converse
bedrock_tool_config = {
    "tools": [
        {
            "toolSpec": {
                "name": t["name"],
                "description": t.get("description", ""),
                "inputSchema": {"json": t.get("parameters", {"type": "object", "properties": {}})},
            }
        }
        for t in ld_tools
    ]
}

# Gemini
gemini_tools = [
    {
        "function_declarations": [
            {
                "name": t["name"],
                "description": t.get("description", ""),
                "parameters": t.get("parameters", {"type": "object", "properties": {}}),
            }
            for t in ld_tools
        ]
    }
] if ld_tools else []

Boucle d'agent avec appels d'outils

Un agent qui utilise des outils exécute une courte boucle : appeler le fournisseur, dispatcher tous les appels d'outils, boucler à nouveau, s'arrêter quand le fournisseur retourne une réponse finale. Trois règles s'appliquent quel que soit le fournisseur :

1. Limitez la boucle. MAX_STEPS = 5 est une valeur par défaut sûre. Une boucle d'outils qui s'échappe est presque toujours un bug de prompt ou de schéma, pas un cas qui nécessite 50 itérations.
2. Suivez chaque invocation d'outil. Appelez tracker.track_tool_call(tool_name) / tracker.trackToolCall(toolName) pour chaque outil que l'agent exécute réellement. C'est ce que l'onglet Monitoring compte comme utilisation d'outil.
3. Arrêtez-vous au signal « plus d'appels d'outils » du fournisseur. Le signal exact diffère selon le fournisseur : OpenAI Chat Completions → choice.finish_reason != "tool_calls"; Anthropic → response.stop_reason != "tool_use"; Bedrock Converse → response["stopReason"] != "tool_use"; Gemini → response.function_calls vide ; OpenAI Responses API → aucun élément function_call dans response.output.

Squelette (Python, Anthropic -- les autres fournisseurs suivent la même forme avec leur propre vérification de stop-reason et formatage tool-result) :

messages = [{"role": "user", "content": initial_input}]
MAX_STEPS = 5
for _ in range(MAX_STEPS):
    response = tracker.track_metrics_of(
        anthropic_metrics,
        lambda: anthropic_client.messages.create(
            model=agent.model.name,
            system=agent.instructions,
            messages=messages,
            tools=anthropic_tools,
            **params,
        ),
    )
    if response.stop_reason != "tool_use":
        break

    messages.append({"role": "assistant", "content": response.content})

    tool_results = []
    for block in response.content:
        if block.type != "tool_use":
            continue
        if block.name not in tool_handlers:
            raise ValueError(f"Unknown tool: {block.name}")
        result = tool_handlers[block.name](**block.input)
        tracker.track_tool_call(block.name)
        tool_results.append({
            "type": "tool_result",
            "tool_use_id": block.id,
            "content": result,
        })
    messages.append({"role": "user", "content": tool_results})

Les formes de payload d'appel d'outil par fournisseur se trouvent dans les références built-in-metrics :

• openai-tracking.md -- Chat Completions + Responses API
• anthropic-tracking.md -- blocs tool_use et payloads tool_result
• bedrock-tracking.md -- format Converse toolUse / toolResult
• gemini-tracking.md -- parties functionCalls / functionResponse
• langchain-tracking.md -- la boucle d'outils LangGraph hérite de create_react_agent

Note sur l'Orchestrateur

LangGraph, CrewAI et AutoGen génèrent souvent des schémas à partir de définitions de fonction. Vous devez toujours créer des outils dans LaunchDarkly et attacher des clés aux variations pour que le SDK sache ce qui est disponible.

Cas Limites

Ce qu'il NE FAUT PAS Faire

• N'essayez pas d'attacher des outils lors de la création de config -- mettez à jour la variation après
• N'omettez pas les descriptions claires d'outils (le LLM en a besoin pour décider quand appeler)
• N'oubliez pas de vérifier l'attachement après la mise à jour de la variation
• Ne regroupez pas instructions, messages, model ou parameters dans le PATCH d'attachement d'outils. Envoyez tools seul sauf si l'utilisateur a explicitement demandé une mise à jour multi-champs -- les PATCHes regroupés écrasent silencieusement les modifications de l'interface pour les autres champs.

Skills Associées

• configs-create -- Créer config avant d'attacher des outils
• configs-variations -- Gérer les variations avec différents ensembles d'outils