Concevoir des agents IA à l’aide du Kit de développement logiciel (SDK) GitHub Copilot

  • 7 minutes

Vous avez exploré ce que les agents IA peuvent faire. Considérez maintenant comment concevoir le système qui les fait fonctionner. Quel que soit le scénario spécifique, les agents IA partagent un blueprint architectural commun. Cette unité couvre les composants fondamentaux ( le modèle IA, les outils, le planificateur, la mémoire et les garde-fous) requis par chaque système d’agent. La compréhension de ce blueprint vous permet d’implémenter des agents plus efficacement lorsque vous travaillez avec le Kit de développement logiciel (SDK) GitHub Copilot.

Composants principaux d’un système d’agent IA

Chaque agent IA, qu’il gère le support client ou surveille l’infrastructure informatique, est créé à partir du même ensemble de blocs de construction architecturaux.

Moteur de raisonnement IA

Au cœur de l’agent est un modèle de langage volumineux (LLM), tel que GPT-5, qui interprète des instructions et génère des réponses. Ce LLM est le composant qui « réfléchit » et décide de ce qu'il faut faire à chaque étape. La formation générale du LLM lui donne la compréhension du langage et les connaissances générales, tandis que le framework de l’agent lui donne la possibilité d’agir sur ce raisonnement.

Dans le Kit de développement logiciel (SDK) GitHub Copilot, vous sélectionnez le modèle lorsque vous configurez une session. Différents modèles offrent différents compromis entre la vitesse, le coût et la capacité de raisonnement, et le SDK prend en charge le basculement de modèles entre les sessions.

Tools

Les outils sont des fonctions externes ou des API que l’agent peut appeler pendant son processus de raisonnement. Chaque outil représente une action spécifique que l’agent peut effectuer : recherche d’un enregistrement de base de données, appel d’une API REST, envoi d’un e-mail ou exécution d’une commande de diagnostic. Les outils sont la façon dont l’agent se déplace au-delà de la génération de texte et interagit réellement avec les systèmes réels.

La conception de l’ensemble approprié d’outils est une décision essentielle. Vous voulez donner à l’agent suffisamment d’outils pour être utile, mais pas tant qu’il ne devienne confus ou surchargé. Chaque outil doit bien faire une chose, avec un nom clair et une description qui aide le modèle IA à comprendre quand l’utiliser.

Planificateur et contrôleur

Le planificateur orchestre le raisonnement et l’outil de l’agent. Il décide quand appeler un outil, quand poser une question de clarification et quand produire une réponse finale. Les agents IA modernes utilisent des techniques comme la boucle ReAct (Reason + Act), où l’agent alterne entre la pensée (le LLM propose une étape) et l’action (appel d’un outil).

Le Kit de développement logiciel (SDK) GitHub Copilot fournit ce planificateur en tant que fonctionnalité intégrée. La boucle de l’agent du Kit de développement logiciel (SDK) gère l’orchestration : vous configurez les composants et le SDK gère le cycle d’exécution du plan, d’agir, d’observer et de répéter.

Mémoire et contexte

Contrairement à un appel d’API sans état, les agents conservent la mémoire contextuelle tout au long d’une session. La connaissance de l’agent inclut l’historique des conversations, les sorties des outils et toutes les données récupérées lors des étapes précédentes. La mémoire est ce qui permet la cohérence : lorsqu’un utilisateur dit « en fait, c’était la mauvaise couleur », l’agent sait que « il » fait référence à l’élément abordé précédemment.

Le Kit de développement logiciel (SDK) Copilot GitHub gère automatiquement la mémoire à court terme en suivant l’historique des conversations au sein d’une session. Pour les sessions susceptibles de dépasser la fenêtre contextuelle du modèle, la fonctionnalité de sessions infinies du kit SDK compacte les contextes plus anciens afin d’éviter le dépassement des jetons tout en conservant les informations essentielles.

Stratégies et garde-fous

Étant donné que les agents IA prennent des actions autonomes, vous avez besoin de contraintes pour s’assurer qu’ils fonctionnent en toute sécurité et comme prévu. Les garde-fous se répartissent en plusieurs catégories :

  • Limites d’étendue : définissez ce que l’agent peut et ne peut pas faire. Par exemple, autorisez l’agent à traiter les retours, mais exigez une approbation humaine pour les remboursements au-dessus d’un montant spécifique.
  • Contrôles d’autorisation : utilisez le hook du Kit de OnPreToolUse développement logiciel (SDK) pour intercepter les appels d’outils avant qu’ils ne s’exécutent. Le hook retourne une PermissionDecision valeur (Allow, Denyou Ask) qui contrôle si l’action se poursuit, est bloquée ou nécessite une confirmation de l’utilisateur.
  • Filtres de sécurité : demandez à l’agent (via l’invite système) de rester dans son domaine et d’éviter de révéler des informations internes.
  • Repli et escalade : concevez ce qui se passe lorsque l’agent ne peut pas résoudre une requête. Ce garde-fou implique généralement la remise à un humain du contexte que l’agent a rassemblé.

Dans le Kit de développement logiciel (SDK) Copilot GitHub, les garde-fous proviennent de trois sources : les outils que vous exposez (qui limitent intrinsèquement ce que l’agent peut faire), l’invite système (qui guide le comportement) et les contrôles au niveau du code dans vos gestionnaires d’outils et les hooks de session.

Flux de travail de l’agent dans la pratique

Lorsqu’un agent reçoit une demande, il suit un flux de travail itératif :

  1. Recevoir une entrée : l’utilisateur envoie un message ou un événement déclenche l’agent.
  2. Motif et plan : Le LLM interprète l’entrée, identifie l’objectif et décide de l’action à entreprendre en premier.
  3. Act : l’agent appelle un outil (par exemple, en recherchant une commande dans la base de données).
  4. Remarque : l’outil retourne un résultat et l’agent évalue s’il dispose de suffisamment d’informations pour répondre.
  5. Itérer ou répondre : si d’autres informations ou actions sont nécessaires, l’agent revient à l’étape 2. Une fois l’objectif atteint, il produit une réponse finale.

Ce cycle peut se répéter plusieurs fois au sein d’une demande d’utilisateur unique. Le Kit de développement logiciel (SDK) Copilot GitHub gère cette boucle automatiquement via son moteur d’exécution de l’agent.

Exemple de procédure pas à pas

Réfléchissez à la façon dont un agent de retour de commerce électronique gère une demande :

  1. Entrée de l’utilisateur : « J’ai reçu le mauvais élément, commande 12345. Je veux le retourner.
  2. Plan : l’agent identifie deux objectifs : vérifier l’ordre et lancer un retour.
  3. Appel d’outil : l’agent appelle get_order_details(12345) pour récupérer les informations de commande.
  4. Remarque : l’outil retourne les détails de la commande, confirmant l’article et la date de livraison.
  5. Appel d’outil : l’agent appelle process_return(12345) pour créer une demande de retour.
  6. Remarque : l’outil retourne un numéro de confirmation.
  7. Répondre : L’agent indique à l’utilisateur : « J’ai créé RMA-1001 pour la commande 12345 et planifié un enlèvement pour demain. Vous recevrez votre remboursement en 3 à 5 jours ouvrables.

L’agent a utilisé deux outils et a suivi plusieurs étapes, mais du point de vue de l’utilisateur, cela a semblé être une interaction fluide et unique.

Décisions de conception pour le Kit de développement logiciel (SDK) GitHub Copilot

Lors de la conception d’un agent à générer avec le Kit de développement logiciel (SDK) Copilot GitHub, concentrez-vous sur trois domaines :

  • Contexte : Quelles informations l’agent a-t-il besoin au début de chaque session ? Le contexte inclut généralement une invite système qui définit le rôle et les instructions de comportement de l’agent, ainsi que toutes les données spécifiques à l’utilisateur qui permettent des réponses personnalisées.
  • Outils : Quelles actions l’agent doit-il effectuer ? Définissez chaque outil avec un nom clair, une description et un schéma de paramètre. Implémentez la logique métier dans le gestionnaire d’outils.
  • Stratégies : Quelles règles l’agent doit-il suivre ? Encoder des stratégies sous forme d’instructions d’invite système, de validations de gestionnaire d’outils ou de logique de hook de session.

Vous devez également planifier les modes d’échec. Si un appel d'outil échoue, l’agent doit-il essayer à nouveau, envisager une autre approche ou escalader ? Ces décisions peuvent être encodées dans l’invite système (« si un outil retourne une erreur, informez l’utilisateur et proposez des alternatives ») ou gérés par programme dans les hooks de gestion des erreurs.

Résumé

La conception d’un agent IA implique de définir ses capacités de raisonnement, les outils qu’il peut utiliser, la façon dont il gère le contexte et les garde-fous qui garantissent une opération sécurisée. Le Kit de développement logiciel (SDK) GitHub Copilot fournit une infrastructure puissante pour la création d’agents avec ces composants. En concevant soigneusement l’invite système, en sélectionnant les outils appropriés et en implémentant des stratégies, vous pouvez créer des agents qui fournissent une valeur métier réelle tout en fonctionnant dans des limites définies. Dans l’unité suivante, vous verrez comment appliquer ces principes de conception dans la pratique en créant un exemple d’agent avec le Kit de développement logiciel (SDK) GitHub Copilot.