Série d'entretiens IA 7 : Comment définir une compétence de manière standard

I. Concept central de la compétence

Une compétence est un ensemble d'unités de capacité exécutables encapsulées dans un Agent ou un système d'IA. Elle comprend généralement :

• Condition de déclenchement : quand elle est invoquée (par exemple, instruction utilisateur, événement système).
• Paramètres d'entrée : données ou contexte à recevoir.
• Logique d'exécution : étapes de traitement spécifiques (par exemple, appel d'API, exécution de code, interrogation d'une base de connaissances).
• Résultat de sortie : réponse ou action renvoyée à l'appelant.

II. Étapes pour définir une compétence de manière standard

1. Définir le nom et la description de la compétence

• Nom : court, unique, sémantique (par exemple, search_web, send_email).
• Description : une phrase expliquant la fonction de la compétence, facilitant la correspondance automatique par l'Agent.

2. Définir les paramètres d'entrée (Schéma d'entrée)

Utiliser JSON Schema ou un format similaire, en précisant le type de chaque paramètre, s'il est obligatoire, la valeur par défaut et les contraintes.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Mot-clé de recherche",
      "required": true
    },
    "max_results": {
      "type": "integer",
      "description": "Nombre maximal de résultats retournés",
      "default": 10
    }
  }
}

3. Écrire la logique d'exécution

• Logique déterministe : appeler directement une fonction, une API ou une base de données.
• Logique non déterministe : utiliser un LLM pour générer une réponse (fournir un modèle de prompt).
• Gestion des erreurs : définir des stratégies de timeout, de réessai, de dégradation.

4. Définir le format de sortie (Schéma de sortie)

Utiliser également JSON Schema pour décrire la structure des données retournées.

{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "title": { "type": "string" },
          "url": { "type": "string", "format": "uri" }
        }
      }
    }
  }
}

5. Métadonnées supplémentaires

• Numéro de version : pour faciliter la gestion des itérations.
• Auteur/mainteneur : attribution des responsabilités.
• Dépendances : services externes ou bibliothèques nécessaires.
• Limitations d'utilisation : par exemple, limites de fréquence, exigences d'autorisation.

III. Exemple : une définition complète de compétence

name: "weather_query"
description: "Consulter la météo actuelle pour une ville donnée"
version: "1.0.0"
author: "Équipe IA"

input:
  type: object
  properties:
    city:
      type: string
      description: "Nom de la ville, ex. 'Paris'"
      required: true
    unit:
      type: string
      enum: ["celsius", "fahrenheit"]
      default: "celsius"

execute:
  - step: "Appeler l'API météo"
    api: "https://api.weather.com/v1/current"
    method: "GET"
    params:
      city: "{input.city}"
      unit: "{input.unit}"
  - step: "Formater le résultat"
    format: "Actuellement à {city}, la température est de {temperature}°{unit}"

output:
  type: object
  properties:
    temperature:
      type: number
    condition:
      type: string
    humidity:
      type: number

IV. Bonnes pratiques

• Responsabilité unique : chaque compétence ne fait qu'une chose, éviter un couplage excessif.
• Autonome : autant que possible, ne pas dépendre d'un état global externe, entrée = sortie.
• Testable : fournir des données simulées ou un environnement sandbox pour les tests unitaires.
• Documenté : rédiger des instructions d'utilisation et des exemples pour chaque compétence.

En suivant ces méthodes, une compétence définie peut être à la fois planifiée dynamiquement par un Agent IA et intégrée directement par les développeurs dans le système, réalisant ainsi un effet de réutilisation "écrire une fois, utiliser partout".