Création d'agent

17 Création d'agent

Cette section couvre la création d'agents d'IA via le générateur de flux visuel ou via le code.

Rubriques :

Systèmes multi-agents et modèles de superviseur

Un système multi-agent est une conception d'application AI dans laquelle une demande utilisateur est traitée par plusieurs agents coopérants au lieu d'un agent polyvalent.

Chaque agent a son propre rôle, des instructions, une configuration de modèle, une stratégie de mémoire et des outils autorisés. Le flux définit la façon dont la demande se déplace entre ces agents et la façon dont la réponse finale est produite.

Cette conception est utile lorsqu'un flux de travail se sépare naturellement en responsabilités spécialisées. Par exemple, un agent peut extraire des données, un autre peut appeler une API, un autre peut résumer les résultats et un superviseur peut décider quel spécialiste utiliser et combiner les résultats en une seule réponse.

Remarques :

En tant que principe de conception, il est préférable de commencer par la plus petite conception d'agent qui répond aux exigences. Ajoutez plusieurs agents lorsque la séparation des préoccupations améliore davantage la fiabilité, la sécurité, la maintenabilité ou l'observabilité qu'elle n'augmente les coûts et la complexité.

Avantages des systèmes multi-agents

Les systèmes multi-agents sont les mieux adaptés pour :

Spécialisation : attribuez à chaque agent un travail, une invite et un ensemble d'outils ciblés au lieu d'un bloc d'instructions bondé.
Gamme et décomposition : permet à un superviseur d'interpréter la demande, de la diviser en sous-tâches et de choisir le spécialiste approprié pour chaque sous-tâche.
Isolement des outils et des données : expose les outils sensibles ou à fort impact uniquement aux agents responsables de leur utilisation.
Gouvernance et dépannage : facilitent l'inspection des transferts, de la propriété des outils, des paramètres de mémoire et des points d'échec.

Quand choisir des conceptions à agent unique ou à agent multiple

Un agent unique avec plus d'outils est souvent la bonne première conception. Il est plus simple à tester, moins coûteux à exécuter et plus facile à raisonner lorsque la tâche a un objectif clair et un modèle d'autorisation. Utilisez une conception multi-agent lorsque le workflow bénéficie de rôles explicites, d'un accès limité aux outils ou d'un superviseur capable de coordonner plusieurs sorties spécialisées.

Question de conception	Utiliser des agents uniques lorsque...	Utiliser des multi-agents lorsque...
Forme de tâche	La demande a un objectif principal et un seuil de réponse.	La demande doit être décomposée, routée, vérifiée ou synthétisée dans toutes les spécialités.
Outils et données	Le même jeu d'instructions et le même modèle d'autorisation peuvent régir tous les outils en toute sécurité	Les différents agents ont besoin d'outils, de sources de données ou de limites d'accès différents.
Instructions	L'invite reste claire, même avec toutes les règles métier et toutes les instructions relatives aux outils en un seul endroit.	Les instructions sont plus faciles à gérer en tant qu'invites plus petites et spécifiques au rôle.
Coût et latence	Vous voulez que le chemin le plus court du message utilisateur réponde.	Les avantages en matière de fiabilité, de gouvernance ou de maintenabilité justifient une orchestration supplémentaire.
Dépannage	Les échecs sont simples à déboguer en une seule trace.	Vous avez besoin de transferts explicites, d'un isolement par état et d'une propriété plus claire pour chaque étape.

Modèle pris en charge : orchestrateur/superviseur

L'expérience canevas actuelle prend en charge le modèle orchestrateur/superviseur. Dans ce modèle, le déclencheur de discussion reçoit le message utilisateur, les garde-corps facultatifs évaluent l'entrée et un agent superviseur agit en tant qu'orchestrateur pour le reste du flux.

Le superviseur doit se concentrer sur la planification, l'acheminement, la délégation et la synthèse des réponses finales. Il détermine l'agent exécuteur qui doit gérer une tâche, envoie à l'exécuteur une instruction de portée, examine le résultat, puis délègue une autre étape ou renvoie la réponse finale. Les agents exécutifs doivent être des spécialistes plus étroits : ils effectuent le travail assigné, utilisent les outils qui leur sont associés et renvoient des résultats utiles au superviseur.

A propos du canevas Visual Flow

Un agent est assemblé en faisant glisser des nœuds et des modèles d'outil de la palette de gauche vers le canevas, puis en connectant les nœuds dans l'ordre dans lequel la demande doit voyager.

La sélection d'un noeud ouvre un panneau de configuration en bas de l'écran.

Canevas de générateur visuel d'agent. La palette, le sélecteur de mode et le contrôle de zoom sont étiquetés et mis en surbrillance.

Elément de canevas	Description
Déclencheur de discussion	Point d'entrée pour un message utilisateur. Dans la capture d'écran, ce noeud est étiqueté Message et se trouve généralement en haut du flux. Un noeud de déclencheur de discussion peut être connecté à un agent, un agent de superviseur ou un noeud de garde-fous. Un seul déclencheur de discussion est autorisé par canevas.
Glissières de sécurité	Couche de sécurité et de politique facultative placée avant ou après le travail du modèle. Les stratégies de garde-corps comprennent les informations d'identification personnelle, la modération du contenu et la détection d'injection rapide. Un noeud de garde-corps peut filtrer le trafic entre un déclencheur de discussion et un noeud d'agent, entre un superviseur et des agents exécutifs, ou entre des noeuds d'agent et d'outil. Nous recommandons un noeud de garde-fous unique entre le déclencheur de discussion et le noeud d'agent.
Agent superviseur	L'orchestrateur. Il reçoit la demande de l'utilisateur, décide quel agent exécuteur ou outil doit gérer chaque tâche et coordonne la réponse finale. Un seul agent superviseur est autorisé dans un canevas.
Agent	Un agent exécuteur. Chaque exécuteur doit avoir une spécialité claire, telle que la récupération de données, la consultation d'API, la synthèse ou la réponse aux questions de document. Utilisez un agent/agent exécuteur pour un système à agent unique.
Modèles d'outils	Fonctionnalités réutilisables pouvant être associées à un exécuteur individuel ou à un agent superviseur. Les modèles d'outil incluent SQL, RAG, Prompt, HTTP, Serveur MCP distant et Outil personnalisé.
Développement / Aire de jeux	Sélecteur de mode au-dessus du canevas. Le développement est utilisé lors de la modification du système agénétique ; Playground est utilisé pour lancer des sessions de test et inspecter le comportement de l'agent. Playground de test nécessite qu'un calcul d'IA soit attaché à votre agent.
Contrôle du zoom	Sélecteur de zoom de canevas. Les captures d'écran montrent des niveaux de zoom de 60 % et 90 %.

Créer un Agent

Vous pouvez créer un agent dans un espace de travail pour lequel vous disposez de l'autorisation Gérer.

Sur la page d'accueil, accédez à votre espace de travail.
Cliquez sur Agents dans le panneau de navigation de gauche.
Cliquez sur Créer un agent ou sur Créer en haut à droite.
Indiquez le nom et la description de l'agent.
Pour Mode de rédaction de flux d'agent, sélectionnez Générateur visuel.
Facultatif : dans le menu déroulant Calcul AI, sélectionnez le calcul à utiliser pour l'agent.
Cliquez sur Créer. Commencez à créer votre agent en faisant glisser un noeud de la palette vers le canevas.

Remarques :
Démarrez votre premier build d'agent simple : un déclencheur de discussion, un agent exécuteur. Ajoutez de la complexité après une exécution réussie de votre première construction, comme des garde-corps, des outils supplémentaires ou même une conception de système multi-agents.

Ajouter un déclencheur de discussion et un agent au canevas Visual Builder

La première étape après la création d'un agent avec Visual Builder doit consister à ajouter un déclencheur de discussion et un agent superviseur.

Le déclencheur reçoit le message utilisateur. Le superviseur interprète la demande, planifie le travail et délègue les tâches aux agents exécutifs ou aux outils. Vous pouvez faire glisser des noeuds dans le canevas, les configurer et les connecter ultérieurement.

Accédez à votre agent dans votre espace de travail.
Cliquez sur un déclencheur de discussion et faites-le glisser de la palette vers le canevas. Le noeud apparaît sur le canevas sous forme de message.
Cliquez sur un agent superviseur et faites-le glisser vers le canevas.
Cliquez sur le descripteur de connecteur du noeud Déclencheur de discussion et faites-le glisser pour le connecter au noeud Agent.

Le badge Agent superviseur affiche le nombre d'agents et d'outils connectés. Dans une nouvelle version, l'agent superviseur affiche : Agents (0) Outils (0).

Déclencheur de discussion et agent superviseur sur le canevas Visual Builder. Le badge sous l'agent du superviseur indique "Agents (0) Outils (0)".

Configurer un agent superviseur

Vous devez configurer un agent de superviseur ajouté au canevas Visual Builder avec des instructions décrivant le rôle de superviseur.

Vous configurez un agent superviseur avec les champs suivants.

Le canevas du générateur visuel est affiché. L'agent superviseur est sélectionné et affiche l'onglet Configuration.

Champ	Configuration
Nom de l'agent	Indiquez un nom descriptif pour l'agent superviseur. Un bon nom descriptif sera utile lors du débogage du comportement du système via des traces et des journaux.
Description d'agent	Fournissez une description de l'objectif, du rôle et du comportement général de l'agent. Utile pour la documentation.
Région	Choisissez la région dans laquelle le modèle OCI Generative AI utilisé par l'agent superviseur est hébergé. Reportez-vous à Modèles d'IA générative par région.
Modèle	Choisissez le modèle de service OCI Generative AI utilisé par le superviseur. La liste déroulante répertorie les modèles disponibles dans la région que vous avez sélectionnée.
Instructions de l'agent	Décrire le rôle de superviseur, les règles d'acheminement, la stratégie de délégation, les attentes en matière d'utilisation des outils et le format de réponse finale.

Accédez à l'agent dans votre espace de travail.
Cliquez sur le noeud Agent superviseur sur le canevas.
Indiquez un nom et une description détaillés pour votre agent superviseur.
Entrez la région et le modèle pour le modèle de service OCI Generative AI utilisé par le superviseur.
Fournissez les instructions de l'agent pour votre agent superviseur.

Instructions suggérées pour le superviseur

Vous devez utiliser le champ Instructions d'un agent superviseur pour que ce dernier soit responsable de l'orchestration et non de toutes les tâches.

Gardez les instructions concrètes pour que les décisions de routage soient prévisibles. Pour obtenir un exemple d'ensemble d'instructions du superviseur, reportez-vous aux sections suivantes :

You are the supervisor for a multi-agent system.

Responsibilities:
- Understand the user's request and break it into subtasks.
- Select the most appropriate executor agent or tool for each subtask.
- Do not perform specialist work yourself when an executor agent is available.
- Ask for clarification only when required information is missing.
- Combine executor outputs into a concise final answer.
- Mention important assumptions, limits, or failed tool calls in the final answer.

Routing rules:
- Use the SQL agent for structured data questions.
- Use the HTTP agent/tool for external API lookups.
- Use the RAG agent/tool for document or knowledge-base questions.
- Use the prompt tool for reusable prompt-only transformations.

Configurer l'isolement de la mémoire et de l'état de l'agent du superviseur

L'onglet Mémoire d'un agent superviseur contrôle la quantité de conversation et l'historique de sortie d'outil disponibles pour le superviseur et la quantité de contexte partagée avec les agents exécutifs.

Vous configurez l'état de mémoire et d'isolement pour votre agent superviseur à l'aide des champs suivants.

Le canevas du générateur visuel est affiché. Un agent superviseur est sélectionné et l'onglet Mémoire s'affiche.

Champ	Configuration
Activer la mémoire de l'agent	Activer lorsque les utilisateurs ont besoin d'une continuité multitour. Désactiver pour les tâches isolées à usage unique. Ce champ ne peut pas être désactivé pour les agents superviseur.
Limiter l'historique des conversations	Activer pour tronquer la fenêtre de contexte LLM après l'atteinte de la limite spécifiée. Désactiver pour afficher l'historique complet.
Configuration de la troncature	Si l'option Limiter l'historique des conversations est activée, utilisez ce champ pour définir les conditions de troncation de la fenêtre de contexte. Les options disponibles sont les suivantes : Conserver les N derniers messages Budget du jeton Les deux
Limites de message maximum et budget de jeton	L'une de ces options ou les deux sont affichées, en fonction de votre choix pour Configuration de la troncature. Les valeurs par défaut sont 20 messages et 5000 jetons. Nous recommandons de commencer par des valeurs modérées et de les ajuster au besoin.
Isolation d'état pour les agents exécutifs	Sélectionnez Sans conservation de statut, Privé ou Partagé. Sans conservation de statut : chaque agent exécuteur ne voit que la tâche affectée par le superviseur. Aucun historique n'est reporté entre les appels. Sélectionnez cette option si vous souhaitez bénéficier de l'isolation la plus forte et du contexte d'agent croisé le moins important. Privé : chaque agent exécuteur ne voit que ses propres interactions passées. Il ne peut pas voir d'autres agents exécutifs de la conversation utilisateur d'origine. Sélectionnez cette option si l'exécuteur a besoin d'une continuité entre ses propres tâches, mais ne doit pas partager le contexte avec d'autres agents. Partagé : les agents exécutifs peuvent voir l'historique complet des conversations entre les agents et les utilisateurs. Tous les agents travaillent à partir d'un contexte partagé. Sélectionnez cette option si vous avez besoin d'un large partage de contexte et que vous avez examiné les risques liés à la confidentialité et à l'injection rapide.

Accédez à l'agent dans votre espace de travail.
Cliquez sur le noeud Agent superviseur sur le canevas.
Cliquez sur l'onglet Mémoire.
Choisissez d'activer ou non Limiter l'historique des conversations. Sélectionnez une configuration de troncature et définissez des limites, si elle est activée.
Choisissez une option pour Isolement d'état pour les agents d'exécuteur.

Onglet Paramètres des modèles

L'onglet Paramètres de modèle vous permet de configurer les paramètres propres au modèle qui sont disponibles pour le modèle sélectionné.

Les paramètres de modèle peuvent être configurés séparément pour les agents superviseur et exécuteur. Les paramètres que vous pouvez utiliser incluent la température, le K supérieur, le P supérieur et la pénalité de fréquence.

Remarques :

Seul un sous-ensemble de modèles expose des paramètres configurables. En outre, les paramètres varient selon les familles de modèles.

Le canevas du générateur visuel est affiché. Un agent superviseur est sélectionné et l'onglet Paramètres du modèle s'affiche.

Ajouter des garde-corps à un agent

Vous pouvez ajouter des couches de protection supplémentaires à vos agents en ajoutant des noeuds de garde-corps à votre canevas.

Par défaut, aucun garde-corps n'est appliqué à vos systèmes agénétiques au-delà de ce que le fournisseur de modèles sélectionné offre prêt à l'emploi pour ses modèles. Des garde-corps peuvent être placés entre le déclencheur de discussion et l'agent superviseur afin que les stratégies soient appliquées avant qu'une demande n'atteigne l'agent superviseur et avant que l'agent superviseur ne renvoie une réponse à l'appelant.

Garde-fou	options	Utilisation
Informations d'identification personnelle (PII)	Onglets Entrée et Sortie Cases à cocher pour Personne, Adresse, Numéro de téléphone, E-mail	A utiliser lorsque le flux doit bloquer ou masquer les données personnelles sensibles avant ou après le traitement du modèle.
Prévention de la modération du contenu	Lignes d'entrée et de sortie avec options Bloquer, Informer et Autoriser.	Permet de définir comment le flux gère le contenu haineux, sexuel, violent, toxique, péjoratif ou harcelant.
Détection d'injection d'invite	Ligne d'entrée avec options Bloquer et Autoriser.	Permet de réduire les risques que des instructions malveillantes remplacent les instructions du système ou de l'agent.

Pour plus d'informations sur les paramètres de garde-corps, reportez-vous à la section Guardrails.

Accédez à l'agent dans votre espace de travail.
Faites glisser un noeud Guardrails de votre palette vers votre canevas. Placez-le entre le noeud Déclencheur de discussion et le noeud Agent superviseur.
Supprimez la connexion entre le déclencheur de discussion et l'agent du superviseur en survolant la connexion et en cliquant sur le X rouge.
Cliquez sur la poignée du connecteur du déclencheur de discussion et faites-la glisser vers le noeud Guardrail. Ensuite, cliquez sur le descripteur de connecteur du noeud de garde-corps et faites-le glisser vers l'agent superviseur.
Cliquez sur le noeud Guardrail pour ouvrir la page Configuration.
Configurez les garde-corps pour sélectionner l'action souhaitée pour les vérifications d'entrée et de sortie.

Ajouter des outils et des agents d'exécuteur à un agent

Vous pouvez ajouter des agents exécutifs aux outils pour effectuer un travail spécialisé pour l'agent superviseur.

Dans l'exemple ci-dessous, l'agent superviseur délègue à AGENT_1 et AGENT_2. AGENT_1 est connecté aux outils SQL_1 et HTTP_1.

Le canevas du générateur visuel est affiché. Un noeud de déclencheur de discussion est connecté à un noeud de garde-corps, qui est connecté à un noeud de superviseur. Le noeud superviseur est connecté à deux noeuds d'agent, AGENT_1 et AGENT_2. AGENT_1 est connecté à deux noeuds d'outil, SQL_1 et HTTP_1.

Accédez à l'agent dans votre espace de travail.
Faites glisser un noeud d'agent de la palette vers le canevas. Les noeuds d'agent doivent être placés sous un agent supérieur.
Faites glisser Tools de la palette vers votre canevas.
Cliquez et faites glisser la poignée de connecteur sur votre agent superviseur pour vous connecter aux noeuds d'agent.
Cliquez sur la poignée de connecteur de vos agents et faites-la glisser pour vous connecter aux noeuds d'outil.

Configuration de l'agent d'exécuteur

Les noeuds d'agent peuvent être configurés en modifiant les paramètres de leurs onglets Configuration, Mémoire et Modèle pour vous aider à définir l'objectif de chaque agent.

Les agents doivent être configurés de manière étroite, en fonction d'une fonction et d'un objectif spécifiques, afin que l'agent superviseur puisse acheminer le travail de manière fiable.
Canevas de construction visuel. Un noeud de déclencheur de discussion est connecté à un agent superviseur, qui est connecté à deux noeuds d'agent, AGENT_1 et AGENT_2. AGENT_1 est connecté à deux noeuds d'outil, SQL_1 et HTTP_1.

Tableau 17-1 Onglet Configuration de l'agent

Champ	Configuration
Nom de l'agent	La meilleure pratique consiste à nommer chaque agent exécuteur en fonction de sa spécialité, telle que SQL_AGENT, DOCUMENT_AGENT, API_AGENT ou SUMMARY_AGENT. Le nom de chaque agent exécuteur est visible par l'agent superviseur. Utilisez donc des noms descriptifs.
Description d'agent	Fournissez une description détaillée de chaque agent exécuteur. La description de chaque agent exécuteur est visible par l'agent superviseur.
Région	Choisissez la région dans laquelle le modèle OCI Generative AI utilisé par l'agent est hébergé. Reportez-vous à Modèles d'IA générative par région.
Modèle	Choisissez le modèle de service OCI Generative AI utilisé par l'agent. Le menu déroulant répertorie les modèles disponibles dans la région que vous avez sélectionnée. Sélectionnez un modèle adapté à la tâche de l'exécuteur. Les agents exécutifs n'ont pas besoin d'utiliser le même modèle que l'agent superviseur.
Instructions de l'agent	Décrivez exactement ce que l'exécuteur doit faire, quels outils il peut utiliser et quelle structure de sortie il doit renvoyer.

Onglet Mémoire de l'agent exécuteur

Dans le cas d'agents exécutifs connectés à un agent superviseur, la mémoire des exécuteurs est configurée dans le noeud superviseur et appliquée à tous les agents exécutifs.

Champ	Configuration
Activer la mémoire de l'agent	Activer lorsque les utilisateurs ont besoin d'une continuité multitour. Désactiver pour les tâches isolées à usage unique.
Limiter l'historique des conversations	Activer pour tronquer la fenêtre de contexte LLM après l'atteinte de la limite spécifiée. Désactiver pour afficher l'historique complet.
Configuration de la troncature	Si l'option Limiter l'historique des conversations est activée, utilisez ce champ pour définir les conditions de troncation de la fenêtre de contexte. Les options disponibles sont les suivantes : Conserver les N derniers messages Budget du jeton Les deux
Limites de message maximum et budget de jeton	L'une de ces options ou les deux sont affichées, en fonction de votre choix pour Configuration de la troncature. Les valeurs par défaut sont 20 messages et 5000 jetons. Nous recommandons de commencer par des valeurs modérées et de les ajuster au besoin.
Isolation d'état pour les agents exécutifs	Sélectionnez Sans conservation de statut, Privé ou Partagé. Sans conservation de statut : chaque agent exécuteur ne voit que la tâche affectée par le superviseur. Aucun historique n'est reporté entre les appels. Sélectionnez cette option si vous souhaitez bénéficier de l'isolation la plus forte et du contexte d'agent croisé le moins important. Privé : chaque agent exécuteur ne voit que ses propres interactions passées. Il ne peut pas voir d'autres agents exécutifs de la conversation utilisateur d'origine. Sélectionnez cette option si l'exécuteur a besoin d'une continuité entre ses propres tâches, mais ne doit pas partager le contexte avec d'autres agents. Partagé : les agents exécutifs peuvent voir l'historique complet des conversations entre les agents et les utilisateurs. Tous les agents travaillent à partir d'un contexte partagé. Sélectionnez cette option si vous avez besoin d'un large partage de contexte et que vous avez examiné les risques liés à la confidentialité et à l'injection rapide.

Onglet Paramètres de modèle de l'agent exécuteur

L'onglet Paramètres de modèle vous permet de configurer les paramètres propres au modèle qui sont disponibles pour le modèle sélectionné.

Remarques :

Seul un sous-ensemble de modèles expose des paramètres configurables. Les paramètres varient également entre les familles de modèles.

Des exemples de paramètres incluent la température, le top K, le top P et la pénalité de fréquence. Les paramètres de modèle peuvent être configurés séparément pour les agents superviseur et exécuteur.

Instructions de l'exécuteur suggérées

You are the SQL executor agent.

Responsibilities:
- Translate the supervisor's task into safe SQL tool usage.
- Use only the SQL tools attached to this agent.
- Return a concise answer plus any important query assumptions.
- Do not invent data. If the tool cannot answer, say what is missing.
- Return structured output with: answer, evidence, assumptions, and follow_up_needed.

Liste de contrôle pour les agents via Visual Builder

Utilisez cette liste pour vous assurer que vous avez inclus et configuré tous les composants nécessaires pour un agent créé à l'aide de Visual Builder.

Créer une liste de contrôle

L'agent a exactement un point d'entrée attendu : Déclencheur de discussion / Message.
Les garde-corps sont connectés dans la position prévue et activés si nécessaire. Nous recommandons d'insérer des garde-corps entre le message de déclenchement et l'agent.
L'agent superviseur dispose d'une région, d'un modèle et d'instructions d'orchestration sélectionnés. Pareil pour les agents exécutifs.
Configurez la mémoire du système multi-agent dans l'onglet Mémoire de l'agent superviseur. Sélectionnez l'isolement de l'état de l'exécuteur correspondant aux exigences de confidentialité et de continuité.
Chaque agent exécuteur a une spécialité claire et des instructions étroites.
Chaque outil est associé uniquement à l'agent qui doit l'utiliser.
Aucun noeud n'est déconnecté.
Un calcul d'IA est associé au système agénétique pour tester des outils individuels et pour exécuter l'expérience Playground.

Tableau 17-2 Questions communes

Problème	Cause probable	Action suggérée
Le superviseur n'appelle pas d'exécuteur	Les instructions du superviseur sont trop vagues ou aucun exécuteur n'est connecté.	Ajoutez des règles de routage explicites et vérifiez que le noeud d'exécuteur est connecté au superviseur.
L'exécuteur renvoie des réponses générales ou hors sujet	Les instructions d'exécuteur sont trop générales.	Affinez le rôle de l'exécuteur et définissez la structure de sortie requise.
L'outil n'est pas utilisé	L'outil est déconnecté ou connecté au mauvais agent.	Vérifiez la connexion à l'outil et le badge du nombre d'outils de l'agent.
Garde-corps ne tire pas	La section Guardrail est configurée mais n'est pas activée.	Ouvrez le noeud guadrails et vérifiez que la bascule de section est activée.
Fuites de contexte entre les agents	L'isolement de l'état est défini sur Partagé ou la mémoire est plus large que prévu.	Utilisez l'isolement privé ou sans état pour une séparation plus stricte.
Les questions de suivi perdent du contexte	La mémoire est désactivée ou la troncation est trop agressive.	Activez la mémoire et réglez la limite maximale de messages.

Agents par code

Vous pouvez utiliser votre propre base de code LangGraph pour les agents d'IA dans Oracle AI Data Platform Workbench ou créer un nouvel agent LangGraph directement sur la plate-forme via l'expérience de codage d'agent.

Vous pouvez utiliser la bibliothèque Python de l'utilitaire AI Data Platform Workbench aidputils pour configurer votre modèle de base et importer des outils système vers votre agent. Pour consulter la référence de l'API aidputils, reportez-vous à API Aidp-utils pour Oracle AI Data Platform Workbench.

Agent SkillsTest s'ouvre dans l'onglet Development.

Vous créez un agent via du code en téléchargeant un fichier de code existant ou en créant des fichiers de code directement dans l'agent via l'éditeur en ligne.

L'éditeur de code en ligne dans les agents prend en charge les types de fichier de code suivants :

Python (.py)
JSON
TXT
CSV
PSV
SH (Affichage)
Dossier

Vous pouvez afficher et parcourir les fichiers de code disponibles en cliquant sur la liste déroulante du sélecteur de fichiers.

Page Agent avec la liste déroulante du sélecteur de fichiers ouverte et mise en surbrillance

Fichiers d'entrée et de dépendance

Les fichiers d'entrée sont des fichiers de code qui ont la classe avec les méthodes de configuration et d'appel attendues pour un agent défini en tant que code. Oracle AI Data Platform Workbench exige que vous définissiez un fichier d'entrée pour les agents via du code.

Les fichiers de dépendance sont des fichiers qui incluent des bibliothèques tierces requises par votre agent, définies en tant que code. Les fichiers de dépendance sont généralement des fichiers requirements.txt qui contiennent la liste des bibliothèques tierces requises.

Remarques :

Les bibliothèques tierces sont installées lorsque vous testez votre code dans l'éditeur en cliquant sur le bouton Play ou lorsque vous testez l'agent via l'onglet Test. Nous vous recommandons d'installer des bibliothèques tierces en testant d'abord le code. Les erreurs lors de l'installation des bibliothèques sont affichées dans la cellule de sortie.

Classe d'agent

AgentBasic est une classe de modèle permettant de configurer et d'appeler un agent conversationnel simple à l'aide d'un workflow LangGraph avec conservation de statut. Il démontre la structure requise pour le développement minimal d'agents avec deux méthodes principales :

setup() : initialise le workflow d'agent et définit le graphique.
invoke(user_query, **kwargs) : exécute l'agent sur un message utilisateur et renvoie la réponse.

Il peut être exécuté et testé directement à l'aide d'une fonction main() avant l'intégration dans un système plus grand.

Définition

class AgentBasic:
    def __init__(self) -> None:
        self.graph = None
    def setup(self) -> None:
        self.graph = StateGraph(MessagesState)
        self.graph.add_node(mock_llm)
        self.graph.add_edge(START, "mock_llm")
        self.graph.add_edge("mock_llm", END)
        self.graph = self.graph.compile()
        system_prompt = "Be a helpful assistant."
    async def invoke(self, user_query: str, **kwargs):
        user_message = HumanMessage(content=user_query)
        messages = {"messages": [dict(user_message)]}
        try:
            return self.graph.invoke(messages)
        except Exception as e:
            import traceback
            logger.error(f"Exception while calling invoke {e}", exc_info=True)
            print("Stack trace:\n", traceback.format_exc())

Appel de test

Cet appel de test est idéal pour les tests fonctionnels initiaux.

Remarques :

Incluez un point d'entrée principal pour les tests autonomes.

import asyncio

async def main():
test_agent = AgentBasic()
test_agent.setup()
result = await test_agent.invoke("Hi there")
print("Agent response:", result)
if __name__ == "__main__":
   asyncio.run(main())

Fonctionnement:

Le script crée un agent, le configure et envoie un exemple de message utilisateur.
L'agent répond ({"messages" : [{"role" : "ai", "content" : "hello world"}]} dans cet exemple).

Guide d'utilisation

Créez une classe d'agent avec les méthodes Setup et Invoke.

configuration()	Initialise le workflow de l'agent	agent.setup()
appel()	Exécute l'agent avec un message utilisateur	wait agent.invoke("Votre question")

Asynchrone : invoke() est une méthode asynchrone. Utilisez-la avec await ou exécutez une boucle asynchrone.
Test : la protection main() incluse (if __name__ == "__main__":) facilite le test de l'agent avant le déploiement.

Créer un agent via du code par téléchargement

Vous pouvez créer votre application d'agent de bout en bout avec du code existant en téléchargeant votre base de code LangGraph.

Oracle AI Data Platform Workbench prend en charge LangGraph version 1.0.1.

Remarques :

Vous pouvez télécharger des fichiers et des dossiers individuels jusqu'à un maximum de 500 fichiers, chaque fichier peut avoir une taille maximale de 500 Mo. Le téléchargement est limité à une taille totale de 5 Go.

Accédez à votre agent dans votre espace de travail. Cliquez sur le nom d'agent.
Cliquez sur Charger.
Faites glisser et déposez un fichier dans le volet ou cliquez sur ce bouton pour sélectionner un fichier.
Cliquez sur Charger.

Créer un agent via du code en créant un nouveau code

Vous pouvez créer une application d'agent de bout en bout avec du code existant en créant du code directement dans l'agent via l'éditeur de code.

L'éditeur de code prend en charge les types de fichier suivants :

Python (.py)
JSON
TXT
CSV
PSV
SH (Affichage)
Dossiers

Accédez à votre agent dans votre espace de travail. Cliquez sur le nom d'agent.
Cliquez sur Ajouter un fichier.
Entrez le nom de votre fichier de code.
Sélectionnez le type de fichier dans la liste déroulante.
Cliquez sur Créer.

Définition d'un fichier d'entrée pour les agents via du code

Votre agent AI via du code nécessite un fichier d'entrée contenant la classe, la configuration et les méthodes d'appel requises pour votre agent.

Accédez à votre agent dans votre espace de travail. Cliquez sur le nom d'agent.
Dans l'onglet Editeur de code, localisez le fichier d'entrée dans le volet de navigation de gauche. Si le fichier n'existe pas, vous pouvez le télécharger vers le serveur en cliquant sur Télécharger vers le serveur ou le créer en cliquant sur Ajouter un nouveau fichier.
Cliquez avec le bouton droit de la souris sur le fichier d'entrée et cliquez sur Définir le fichier d'entrée. Vous pouvez également sélectionner le fichier et cliquer sur le bouton Définir le fichier d'entrée en haut à droite de l'éditeur de code.

Définition d'un fichier de dépendance pour les agents via du code

Vous devez définir un fichier de dépendance pour les flux d'agents via du code qui contient les bibliothèques tierces dont votre code dépend.

Accédez à votre agent dans votre espace de travail. Cliquez sur le nom d'agent.
Dans l'onglet Editeur de code, localisez le fichier de dépendance dans le panneau de navigation de gauche, généralement requirements.txt. Si le fichier n'existe pas, vous pouvez le télécharger vers le serveur en cliquant sur Télécharger vers le serveur ou le créer en cliquant sur Ajouter un nouveau fichier.
Cliquez avec le bouton droit de la souris sur le fichier de dépendances et cliquez sur Définir la dépendance. Vous pouvez également sélectionner le fichier et cliquer sur le bouton Définir le fichier de dépendances en haut à droite de l'éditeur de code.

Code agent de test

Vous pouvez tester le code utilisé pour votre agent à partir de l'onglet Test pour valider et déboguer le code.

Vous devez avoir un calcul d'IA attaché à votre agent pour effectuer le test.

Accédez à votre agent dans votre espace de travail. Cliquez sur le nom d'agent.
Cliquez sur l'onglet Playground.
Cliquez sur Lancer pour tester le fichier de code sélectionné.

Dans la moitié inférieure de la fenêtre de l'éditeur de code, une cellule de sortie affiche les sorties des instructions print ou logging dans votre code. Les erreurs sont également affichées dans la cellule de sortie.

Compétences des agents en matière de codage

Les compétences d'agent permettent à un agent de repérer et d'utiliser des instructions spécifiques aux tâches, des fichiers de référence, des modèles, des ressources et des scripts exécutables facultatifs sans coder en dur cette connaissance de domaine dans les instructions de l'agent.

Une brique est stockée en tant que dossier dans votre base de code d'agent. Chaque brique a un fichier SKILL.md requis qui décrit ce que fait la brique et comment l'agent doit l'utiliser. Une brique peut également inclure des fichiers de prise en charge tels que des schémas, des exemples, des invites, des modèles, des ressources ou des scripts.

Pour plus d'informations, reportez-vous à Présentation des briques d'agent.

Les compétences des agents soutiennent un modèle de divulgation progressive :

L'agent découvre qu'une brique existe.
L'agent active la brique uniquement lorsqu'elle est pertinente.
L'agent charge des fichiers supplémentaires à partir du dossier de brique uniquement si nécessaire.
L'agent peut exécuter un point d'entrée de brique déclaré explicitement, si la brique l'autorise.

Quand utiliser les compétences des agents

Vous devez utiliser Skills lorsque vous souhaitez packager des fonctionnalités d'agent réutilisables telles que :

Instructions propres au domaine
Workflows de codage ou d'analyse de données
Conseils de génération SQL
Livres de référence sur les processus métier
Modèles de fichier
Références du schéma
Scripts réutilisables pour des calculs, des transformations ou des recherches sécurisés

Les compétences sont utiles lorsque l'agent doit avoir accès à des connaissances spécialisées et réutilisables, mais que vous ne voulez pas placer toutes ces connaissances directement dans l'invite de l'agent.

Fonctionnement des compétences à l'exécution

Lors de l'exécution, l'application hôte détermine les répertoires de brique disponibles, tels que les dossiers de brique de niveau projet et utilisateur. La plate-forme charge les métadonnées de chaque brique à partir de SKILL.md et crée un catalogue associé à un nom de brique.

L'agent peut ensuite utiliser des outils liés aux compétences :

Outil	Description
`activate_skill(name)`	Charge les instructions de compétence de SKILL.md.
`list_skill_files(name, path)`	Répertorie les fichiers disponibles dans un dossier de brique.
`load_skill_file(name, path)`	Charge un fichier de support à partir du dossier de compétences.
`run_skill_entrypoint(name, entrypoint, args_json, timeout_seconds)`	Exécute un point d'entrée Python déclaré explicitement, si la brique l'autorise.

Certains environnements peuvent également intégrer un récapitulatif des compétences disponibles directement dans l'invite système. Dans cette configuration, l'agent peut repérer les briques disponibles à partir de l'invite, puis utiliser activate_skill lorsqu'il a besoin des instructions complètes.

Structure du dossier de compétences

Une brique utilise une présentation de dossier de type Compétences d'agent :

<skills_dir>/
	some-skill/
		SKILL.md
		references/
		...
		scripts/
		...
		assets/
		...

Seul SKILL.md est requis. Les autres dossiers sont facultatifs.

Dossier ou fichier	Obligatoire	Description
`SKILL.md`	Oui	Principales métadonnées et instructions relatives aux compétences.
`references/`	No	Documentation complémentaire, schémas, exemples ou modèles.
`scripts/`	No	Scripts Python qui peuvent être exécutés uniquement lorsqu'ils sont explicitement déclarés comme points d'entrée.
`assets/`	No	Ressources statiques utilisées par la brique.

Ecriture de SKILL.md

Chaque compétence doit inclure la matière première YAML en haut de SKILL.md, suivie des instructions de démarque.

Exemple de base

---
name: sql-helper
description: Helps the agent write safe SQL queries using project schemas.
license: internal
compatibility: "agent-platform"
metadata:
  owner: data-platform
  domain: analytics
allowed-tools: "analyzeQuery inspectSchema"
---

# SQL Helper

Use this skill when the user asks for SQL generation, query review, or schema-aware analysis.

Before writing SQL:
1. Inspect the relevant schema files in `references/`.
2. Prefer explicit column names.
3. Avoid destructive statements unless the user explicitly asks for them and the environment allows them.

Tableau 17-3 Champs de matière première pris en charge

Champ	Obligatoire	Description
name	Oui	Nom de compétence unique utilisé par le catalogue et les outils.
description	Oui	Brève description utilisée pour le repérage et le routage.
licence	No	Licence ou stratégie d'utilisation de la brique.
Compatibilité	No	Note de compatibilité pour les exécutions ou les plates-formes prises en charge.
métadonnées	No	Correspondance de métadonnées de chaîne à chaîne.
outils autorisés	No	Liste d'outils séparés par des espaces que cette brique permet.
points d'entrée	No	Liste des points d'entrée exécutables déclarés par la brique.

Ajout de fichiers annexes

Les fichiers de support permettent à une brique de conserver un contenu détaillé en dehors des instructions principales. Cela maintient SKILL.md concentré tout en donnant à l'agent l'accès à un contexte plus riche. Exemple :

skills/
	sql-helper/
		SKILL.md
		references/
			warehouse_schema.md
			query_style_guide.md
			examples.md

L'agent peut inspecter ces fichiers avec :

list_skill_files("sql-helper", "references")
load_skill_file("sql-helper", "references/warehouse_schema.md")

Utilisez des fichiers de support pour des contenus tels que :

Schémas de base de données
Exemples d'API
Modèles d'invite
Guides de style
Glossaires de domaine
Livres de jeux pas à pas
Cas de test ou exemples

Création d'une compétence exécutable

Une brique peut éventuellement exposer un comportement exécutable réutilisable via run_skill_entrypoint. Elle est destinée aux opérations contrôlées telles que les calculs, les transformations, la validation ou l'extraction de données structurées.

Les compétences exécutables doivent répondre à deux exigences :

La brique doit inclure run_skill_entrypoint dans les outils autorisés.
Le script doit être explicitement déclaré dans la section des points d'entrée de SKILL.md.

Exemple de compétence exécutable

skills/
	statistics-helper/
		SKILL.md
		scripts/
			summarize_numbers.py

SKILL.md

---
name: statistics-helper
description: Computes basic summary statistics for numeric data.
allowed-tools: "load_skill_file list_skill_files run_skill_entrypoint"
entrypoints:
  - name: summarize_numbers
    script: scripts/summarize_numbers.py
    func: run
    description: Returns count, min, max, mean, and median for a list of numbers.
---

# Statistics Helper

Use this skill when the user asks for basic descriptive statistics.
scripts/summarize_numbers.py:
from statistics import mean, median

def run(*, values: list[float]) -> dict:
    if not values:
        raise ValueError("values must not be empty")

    return {
        "count": len(values),
        "min": min(values),
        "max": max(values),
        "mean": mean(values),
        "median": median(values),
    }
Example invocation:
run_skill_entrypoint(
  name="statistics-helper",
  entrypoint="summarize_numbers",
  args_json="{\"values\": [10, 20, 30, 40]}",
  timeout_seconds=10
)
The runner returns structured output that includes exit_code, stdout, stderr, and a best-effort parsed result when the script prints or returns JSON.

Règles pour les points d'entrée exécutables

Les points d'entrée exécutables sont intentionnellement contraints. La plate-forme exécute uniquement les fichiers Python suivants :

Situé sous le répertoire/scripts de la brique
Déclaré dans la matière première des points d'entrée de la compétence
Autorisé par le paramètre allowed-tools de la brique

La plate-forme ne fournit pas d'exécution de script arbitraire à usage général. Les scripts qui ne sont pas déclarés dans SKILL.md ne peuvent pas être exécutés.

Le programme d'exécution de script utilise un délai d'expiration, une valeur par défaut de 10 secondes, exécute Python avec un comportement en mode isolé et applique des restrictions de chemin. Toutefois, l'exécution basée sur un sous-processus n'est pas un modèle d'environnement restreint complet du système d'exploitation. Pour une utilisation en production, une isolation plus élevée, telle que des conteneurs, des systèmes de fichiers restreints ou des contrôles réseau, doit être envisagée.

Autorisations d'outil avec allowed-tools

allowed-tools sert de point de contrôle d'accès de niveau brique. Pour une brique de type documentation uniquement, vous pouvez autoriser uniquement les outils de lecture de fichiers :

allowed-tools: "load_skill_file list_skill_files"

Pour une brique qui peut exécuter des scripts déclarés, incluez run_skill_entrypoint :

allowed-tools: "load_skill_file list_skill_files run_skill_entrypoint"

N'ajoutez pas run_skill_entrypoint sauf si la brique a réellement besoin d'un comportement exécutable.

Comment laisser vos agents découvrir et utiliser les compétences

Pour compléter l'agent par des briques, vous devez instancier un catalogue de briques, un middleware de briques et convertir les briques en outils à l'aide des objets suivants de la bibliothèque aidpUtils :

Outil	Description
`discover_skill_catalog`	Déterminer les emplacements de recherche de compétences par défaut (projet + utilisateur) Créer un catalogue de compétences à partir des répertoires repérés
`SkillMiddleware`	Ajoutez la synthèse des compétences et les règles de routage disponibles à l'invite du système. Fournissez des aides d'usine pour la construction de middleware orientés espace de travail.
`make_skill_tools`	Cette méthode renvoie les outils de repérage de briques : activate_skill, list_skill_files, load_skill_file et run_skill_entrypoint. Ces outils peuvent être utilisés par l'agent pour activer et exécuter différentes briques.

Voici un exemple de ce que votre fichier d'entrée pourrait inclure :

from aidputils.agents.skills.discovery import discover_skill_catalog
from aidputils.agents.skills.middleware import SkillMiddleware
from aidputils.agents.skills.tools.factories import make_skill_tools
...
class SchoolGradeAgentWithEmbededSkills:
	...
	def init(self) -> None: 
		...
		self.catalog = discover_skill_catalog(skill_folder_whitelist=None)
		self.skill_middleware = SkillMiddleware(self.catalog)
		self.tools = make_skill_tools(self.catalog)

Vous pouvez déboguer votre catalogue de briques en ajoutant cette instruction de journaliseur à votre code. Toutes les aptitudes repérées dans le catalogue de briques seront ainsi imprimées :

for info in self.catalog.list():
	logger.info("skill_id=%s name=%s desc=%s root=%s skill_file=%s", info.skill_id, info.name, info.description, info.root_dir, info.skill_file)

Priorité des compétences

La plate-forme peut charger des compétences à partir de plusieurs emplacements, tels que des annuaires de niveau projet et utilisateur. Le catalogue regroupe ces emplacements en une seule liste de briques avec une clé de nom.

Lorsque plusieurs magasins contiennent une brique portant le même nom, la priorité détermine laquelle est utilisée. Les magasins ultérieurs remplacent les précédents, ce qui permet à une application hôte de contrôler si les compétences de niveau utilisateur, de niveau projet ou de niveau espace de travail sont prioritaires.

Meilleures pratiques en matière de création de compétences

Garder SKILL.md concentré

Utilisez SKILL.md pour les instructions de base dont l'agent a besoin immédiatement après l'activation. Placez les schémas longs, les exemples et le matériel de référence dans les références/.

Ecrire des descriptions claires

Le champ de description est utilisé pour le repérage. Rendez-la suffisamment spécifique pour que l'agent sache quand activer la brique.

Bon:

description: Helps generate BigQuery SQL using the finance warehouse schema.

Moins utile :

description: Helps with data.

Utiliser des noms de point d'entrée explicites

Les noms des points d'entrée doivent décrire clairement l'opération :

entrypoints: 
   - name: validate_query 
   - name: summarize_numbers 
   - name: transform_csv

Évitez les noms vagues tels que :

entrypoints: 
   - name: run 
   - name: do_it

Renvoyer les résultats structurés

Les scripts exécutables doivent renvoyer des résultats sérialisables au format JSON chaque fois que cela est possible. La sortie est ainsi plus facile à inspecter et à utiliser pour l'agent.

Eviter les exécutions inutiles

Préférez les instructions et les fichiers de référence lorsque cela est possible. Utilisez des points d'entrée exécutables uniquement pour les opérations qui nécessitent réellement du code.

Ajouter une nouvelle compétence

Vous pouvez ajouter de nouvelles briques d'agent en créant un dossier dans le répertoire des briques et en ajoutant les fichiers et dossiers nécessaires.

Créez un dossier sous le répertoire des briques : .agents/skills/<skill-name>/.

Ajoutez un fichier SKILL.md avec le frontmatter requis.

---
name: <skill-name>
description: <what this skill helps the agent do>
---

Ecrivez les instructions de brique dans Markdown sous le tapis avant.
Ajoutez des fichiers annexes facultatifs sous :
```
references/
assets/
scripts/
```
Si la brique est exécutable, ajoutez run_skill_entrypoint à allowed-tools, déclarez entrypoints dans SKILL.md et placez l'implémentation Python sous scripts/.

Ajouter une nouvelle capacité exécutable à une brique existante

Vous pouvez ajouter une nouvelle opération exécutable à une brique existante pour étendre les capacités de SKILL.md.

1. Ajoutez un fichier Python dans le répertoire scripts/ de la brique.
```
.agents/skills/<skill-name>/scripts/my_operation.py 
```

2. Implémentez une fonction run(...).

def run(*, input_text: str) -> dict:
    return {
        "length": len(input_text),
        "uppercase": input_text.upper(),
    }

3. Ajoutez un point d'entrée correspondant à SKILL.md.

allowed-tools: "load_skill_file list_skill_files run_skill_entrypoint"
entrypoints:
  - name: my_operation
    script: scripts/my_operation.py
    func: run
    description: Processes input text and returns structured output.

4. Testez le point d'entrée avec un objet JSON en tant qu'arguments.
```
{
  "input_text": "hello"
}
```

Dépannage des aptitudes des agents

Si vous rencontrez des problèmes avec l'implémentation des briques d'agent, consultez cette liste pour obtenir de l'aide sur la résolution de votre problème.

L'agent ne voit pas ma brique

Vérifiez que :

Le dossier de compétences se trouve sous un répertoire de compétences configuré.
Le dossier contient SKILL.md.
SKILL.md a une matière première YAML valide.
Le frontmatter inclut à la fois le nom et la description.

L'agent active la mauvaise brique

Recherchez les noms de brique en double dans les répertoires de brique. Si deux briques portent le même nom, la priorité du catalogue détermine celle qui est utilisée.

Impossible de charger un fichier de support

Vérifiez que :

Le fichier se trouve dans le dossier de brique.
Le chemin n'inclut pas les parcours tels que ../.
Le fichier n'est pas masqué.
Le fichier n'est pas exclu, par exemple __pycache__ ou .pyc.

Un point d'entrée ne s'exécutera pas

Vérifiez que :

run_skill_entrypoint est inclus dans les outils autorisés.
Le point d'entrée est déclaré dans SKILL.md.
Le chemin du script se trouve sous scripts/.
Le script est un fichier .py.
Le nom de la fonction dans func existe dans le script.
Les arguments sont un objet JSON valide.

Un point d'entrée expire

Augmentez timeout_seconds uniquement si l'opération devrait prendre plus de temps. Pour les opérations à longue durée d'exécution ou gourmandes en ressources, envisagez de déplacer l'opération vers un service dédié ou un environnement d'exécution plus isolé.

Exemple : Compléter la compétence de l'agent

Cet exemple montre à quoi ressemblerait une brique d'agent complète après l'implémentation.

Structure de dossier

skills/
	customer-support-reply/
		SKILL.md
		references/
			tone_guide.md
			refund_policy.md
			escalation_rules.md

SKILL.md

---
name: customer-support-reply
description: Helps draft customer support replies using the company tone guide and policy references.
allowed-tools: "load_skill_file list_skill_files"
metadata:
  owner: support-operations
  domain: customer-support
---

# Customer Support Reply

Use this skill when the user asks for help drafting, reviewing, or improving a customer support response.

Workflow:

1. Identify the customer’s issue.
2. Load the relevant policy file from `references/` if needed.
3. Draft a clear, empathetic response.
4. Avoid making commitments that are not supported by policy.
5. Recommend escalation when the request matches the escalation rules.
This skill does not run code. It gives the agent structured instructions and optional policy files that can be loaded only when relevant.

Test d'agent

Vous pouvez tester vos agents pour prévisualiser et déboguer leur sortie. Vous pouvez également créer et gérer des sessions de test pour explorer différents scénarios de test pour vos agents.

La première étape pour tester un agent consiste à l'attacher à un calcul d'IA. L'action d'attachement d'un agent transmet une copie de votre agent à un calcul d'IA. Tant que votre agent est attaché à un calcul d'IA, toutes les modifications que vous avez apportées à votre agent sont propagées au calcul attaché chaque fois que vous cliquez sur le bouton Tester.

Une fois que vous avez cliqué sur le bouton Test, vous êtes redirigé vers le playground de test.

La page Agent est ouverte sur Test Playground. Les volets Discussion, Traces et étendues et Explorateur sont mis en évidence

Le terrain de jeu de test comporte les composants suivants :

Une fenêtre de discussion dans laquelle vous pouvez lancer une session et commencer à discuter avec l'agent, ou reprendre une session existante
Représentation graphique de l'agent
Panneau présentant une arborescence de traces et d'étendues générées pendant la session
Panneau de l'explorateur de traces et d'étendues qui affiche les attributs de traces et d'étendues, entrée/sortie. L'onglet Détails inclut les ID, l'heure de début et de fin, l'heure d'exécution, tandis que les onglets Evénements mettent en évidence les erreurs au cours de l'exécution.

Le Playground vous permet d'interagir et de tester chaque agent indépendamment si vous le souhaitez. Par défaut, l'agent superviseur est sélectionné, mais vous pouvez choisir de discuter avec chaque agent exécuteur et de le tester indépendamment. Vous pouvez ainsi simuler le comportement d'un agent superviseur émettant des demandes aux agents exécutifs. Pour ce faire, sélectionnez l'agent à tester dans le menu déroulant de la fenêtre de discussion.

Les traces et les étendues sont affichées dans le panneau central dès que vous créez votre premier message. Chaque tâche correspond à un message utilisateur différent. Vous pouvez cliquer sur le curseur de gauche pour développer la trace et inspecter les étendues.

Tester les agents dans le terrain de jeu

Vous pouvez tester le générateur visuel et les agents basés sur LangGraph à partir du terrain de jeu Test pour valider et déboguer vos agents.

Vous devez avoir un calcul d'IA attaché à votre agent pour effectuer le test. Vous pouvez ajouter un nouveau cluster de calcul d'IA en suivant Création d'un cluster d'IA pour un agent ou en attachant un cluster de calcul d'IA existant en suivant Attachement d'un cluster d'IA existant à un agent.

Accédez à votre agent dans votre espace de travail. Cliquez sur le nom d'agent.
En haut du canevas, cliquez sur Plan d'accès. La transmission de l'agent vers le calcul associé peut prendre plusieurs secondes.

Votre agent est affiché dans le terrain de test.

Créer une session de test d'agent

Vous pouvez créer une session de test pour lancer une nouvelle conversation avec votre agent.

Toutes les sessions créées dans la cible de terrain de test sur laquelle l'agent est hébergé sur le calcul associé. Une fois qu'une session est créée, elle peut être reprise ultérieurement.

Accédez à votre agent dans votre espace de travail. Cliquez sur le nom d'agent.
En haut du canevas, cliquez sur Playground.
Dans le sélecteur de session, cliquez sur Créer une session.
Démarrez une boîte de dialogue avec votre agent en saisissant une requête dans la zone de discussion.

Reprendre une session de test d'agent

Vous pouvez reprendre les sessions de test d'agent que vous avez précédemment créées.

Remarques :

Vous ne pouvez reprendre que les sessions que vous avez créées.

Accédez à votre agent dans votre espace de travail. Cliquez sur le nom d'agent.
En haut du canevas, cliquez sur Playground (Terrain de lecture).
Dans la liste déroulante Session, sélectionnez une session précédente.
Reprenez la boîte de dialogue avec votre agent en saisissant une requête dans la zone de discussion.

Supprimer une session de test d'agent

Vous pouvez supprimer les sessions de test pour les agents hébergés sur le calcul AI attaché et les sessions qui ont été créées sur un agent déployé.

Accédez à votre agent dans votre espace de travail.
Cliquez sur l'onglet Sessions.
En regard de la session à supprimer, cliquez sur Actions, puis sur Supprimer.
Cliquez sur Supprimer.