哲见WISE AITHE INTELLIGENCE JOURNAL
Participer
Voir les rubriques
AWS Machine LearningPublication de la source

Découvrez des outils au moment de l'exécution avec AWS Agent Registry

La découverte au moment de l'exécution avec AWS Agent Registry peut aider à résoudre un problème que les démonstrations d'agents peuvent masquer. Des outils codés en dur fonctionnent bien en petit nombre, commencent à se dégrader à quelques dizaines et deviennent ingérables au-delà.

La découverte au moment de l'exécution avec AWS Agent Registry peut aider à résoudre un problème que les démonstrations d'agents peuvent masquer. Des outils codés en dur fonctionnent bien en petit nombre, commencent à se dégrader à quelques dizaines et deviennent ingérables au-delà. Les systèmes d'entreprise exposent des centaines d'API internes pour les prix, le support, les commandes, l'inventaire et les données clients. Dans ces systèmes, le modèle peut dépenser plus de jetons pour lever l'ambiguïté des noms d'outils que pour raisonner sur la demande de l'utilisateur. Chaque nouvelle capacité exige une modification du code de l'orchestrateur, un redéploiement et une publication coordonnée entre des équipes qui préféreraient livrer à leur propre rythme.

Ce schéma peut se présenter dans les projets logiciels d'entreprise en tant que service (SaaS) où les équipes exposent de vastes surfaces d'API internes à des consommateurs agentiques. Le câblage au moment de la construction peut devenir un goulot d'étranglement à mesure que le catalogue s'agrandit. Une approche consiste à changer la façon dont l'orchestrateur accède à ses outils : au lieu de compiler chaque outil dans l'agent, l'agent peut découvrir les outils pertinents au moment de l'exécution.

AWS Agent Registry est un service géré pour le catalogage et la découverte de serveurs Model Context Protocol (MCP), d'agents et de compétences d'agents. Les éditeurs enregistrent des descripteurs spécifiques au protocole et des descriptions consultables. Au moment de l'exécution, un orchestrateur peut rechercher des enregistrements approuvés et découvrables, et utiliser l'endpoint et le contenu du descripteur renvoyés pour construire un client. Les résultats de recherche du registre ne renvoient pas les identifiants d'invocation ni le schéma d'authentification de la capacité.

Cet article décrit la boucle Discover → Instantiate → Execute démontrée par l'exemple Python remanié. Le code déploie un serveur MCP de gestion des commandes via Amazon Bedrock AgentCore Gateway, une capacité d'Amazon Bedrock AgentCore, deux agents agent-à-agent (A2A) sur AgentCore runtime, un registre (Registry) et un orchestrateur. Le répertoire d'exemple contient le script de déploiement, l'orchestrateur, les modules d'aide et le script de nettoyage.

Vue d'ensemble de la solution : découvrir, instancier, exécuter

L'agent orchestrateur de cet exemple n'a aucune connaissance intégrée des outils ou des agents.

Figure 1 : Sans AWS Agent Registry (à gauche), les endpoints sont codés en dur et l'ajout d'un nouvel agent implique des modifications de code plus un redéploiement. Avec AWS Agent Registry (à droite), l'orchestrateur découvre les capacités par recherche sémantique et les nouvelles intégrations sont utilisables après enregistrement et approbation

Découvrir

L'orchestrateur envoie une requête en langage naturel au plan de données d'AWS Agent Registry. La réponse de recherche comprend l'identité de l'enregistrement, le nom, la description, le type d'enregistrement, le statut, la version et les descripteurs de protocole tels que les métadonnées d'un serveur MCP ou une carte d'agent A2A. Elle n'inclut pas les identifiants d'invocation. L'application doit obtenir et appliquer les identifiants appropriés via un chemin de configuration de confiance distinct.

Instancier

Pour chaque enregistrement renvoyé, l'orchestrateur construit un client à partir du type de descripteur. Dans cet exemple, le serveur MCP enregistré représente des outils qui ont d'abord été ajoutés comme cibles à Amazon Bedrock AgentCore Gateway. Le descripteur MCP pointe donc vers l'endpoint du Gateway. L'orchestrateur récupère séparément un jeton d'accès Cognito OAuth et l'utilise lors de la création du MCPClient. Les enregistrements A2A contiennent une carte d'agent dont l'URL identifie un endpoint AgentCore runtime. Le wrapper invoque ce runtime via le client de plan de données boto3 , qui signe la requête avec les identifiants AWS de l'appelant. La découverte via le registre fournit des métadonnées de connexion, pas le matériel d'authentification.

Exécuter

Un agent interne éphémère est construit avec uniquement les outils découverts dynamiquement. Le grand modèle de langage (LLM) choisit le ou les bons outils pour la requête, et le résultat est synthétisé vers l'utilisateur. Une fois le tour terminé, l'agent interne et ses clients sont démantelés. La requête suivante obtient une nouvelle recherche et un nouvel ensemble d'outils.

Figure 2 : Architecture de bout en bout. Un orchestrateur unique sur Amazon Bedrock AgentCore runtime interroge AWS Agent Registry. Les serveurs MCP correspondants sont invoqués via Amazon Bedrock AgentCore Gateway, et les agents A2A correspondants sont invoqués sur Amazon Bedrock AgentCore runtime

L'architecture de référence utilisée dans l'exemple comprend AWS Agent Registry, Amazon Bedrock AgentCore Gateway, Amazon Bedrock AgentCore runtime, Amazon Bedrock, Amazon Cognito, AWS Lambda et AWS Secrets Manager.

  • AWS Agent Registry fournit le catalogue gouverné et interrogeable par l'orchestrateur. Seuls les enregistrements ayant achevé le flux de travail d'approbation configuré sont disponibles via le plan de données découvrable.
  • Amazon Bedrock AgentCore Gateway expose les outils Lambda de gestion des commandes en tant que serveur MCP. L'exemple configure Cognito JWT l'autorisation des appels entrants vers la passerelle (Gateway) et utilise le rôle IAM (AWS Identity and Access Management) de la passerelle pour invoquer la cible Lambda.
  • Amazon Bedrock AgentCore runtime héberge l'orchestrateur ainsi que les agents A2A de tarification et de support client. Les invocations d'exécution utilisent autorisé par IAM Boto3 appels.
  • Amazon Bedrock fournit le modèle de fondation (FM) utilisé par l'orchestrateur et les agents A2A. L'exemple configure actuellement un modèle Anthropic Claude Sonnet via un model ID inter-Régions. Voir Modèles pris en charge par Région AWS dans Amazon Bedrock.

Trois scénarios de démonstration exercent la boucle de découverte avec différentes combinaisons de capacités. Le premier est un appel MCP uniquement (statut de commande). Le second enchaîne MCP + A2A (tarification et remises). Le troisième teste une correspondance purement sémantique sur une intention utilisateur ambiguë : retour et remboursement, où ces mots n'apparaissent pas dans le nom de l'agent A2A correspondant.

Mise en œuvre technique

La découverte d'exécution liée échantillon déploie les dépendances, crée et remplit le Registry, vérifie la découverte, déploie l'orchestrateur et exécute trois démonstrations. orchestrator_agent.py contient la boucle de découverte par requête. utils.py analyse les descripteurs du Registry et crée des clients MCP et A2A. cleanup.py supprime des ressources.

1. Le modèle d'inscription

Un enregistrement de Registry contient une description interrogeable ainsi qu'un descripteur spécifique au protocole. L'exemple utilise le client du plan de contrôle de l'Agent Registry pour les opérations de Registry et de cycle de vie des enregistrements, et le client du plan de données de l'Agent Registry pour la découverte à l'exécution.

Création d'un registre avec approbation manuelle et autorisation IAM.

registry_client = session.client("agent-registry-control")
dp_client = session.client("agent-registry")
reg = registry_client.create_registry(
    name="OrderManagementRegistry",
    description=(
        "Registry for Order Management & Customer Service — "
        "agent discovers tools and agents via semantic search"
    ),
    approvalConfiguration={"autoApprovalRules": []},
)
REGISTRY_ARN = reg["registryArn"]
REGISTRY_ID = REGISTRY_ARN.split("/")[-1]

Le recordType est requis lors de la création d'un enregistrement. Dans cet exemple, les serveurs MCP utilisent recordType="MCP" et les agents prenant en charge A2A utilisent recordType="AGENT". Les métadonnées du protocole sont stockées sous mcpServer ou a2aAgentCard dans le descriptors objet. Un descripteur MCP contient les métadonnées du serveur et les définitions d'outils. Un descripteur A2A contient la carte de l'agent. Les descripteurs contiennent les métadonnées de connexion mais pas les identifiants qu'un consommateur doit présenter lors de l'invocation de la capacité.

Construction des formes actuelles de descripteurs du SDK public pour les enregistrements MCP et A2A.

# MCP descriptor
mcp_descriptors = {
    "mcpServer": {
        "data": json.dumps(server_metadata),
        "dataSchemaVersion": "2025-12-11",
        "additionalData": {
            "tools": {
                "data": json.dumps({"tools": tool_schemas}),
                "dataSchemaVersion": "2025-06-18",
            }
        },
    }
}

# A2A descriptor
a2a_descriptors = {
    "a2aAgentCard": {
        "data": json.dumps(agent_card),
        "dataSchemaVersion": "0.3",
    }
}

Rédigez des descriptions dans un langage destiné aux utilisateurs qui distingue la capacité des enregistrements voisins. Le contenu du descripteur fournit les données spécifiques au protocole : serveur, outil ou carte d'agent. La qualité de la recherche doit être évaluée avec des requêtes représentatives. Ce billet ne suppose pas que la croissance du catalogue améliore automatiquement le classement.

Création d'un enregistrement Registry avec la forme actuelle du plan de contrôle.

descriptors = (
    mcp_descriptors
    if cfg["protocol"] == "MCP"
    else a2a_descriptors
)

response = registry_client.create_registry_record(
    registryId=REGISTRY_ID,
    name=name,
    description=cfg["description"],
    recordType=cfg["protocol"],
    descriptors=descriptors,
    recordVersion="1.0",
)
record_id = response["recordId"]

2. Flux de travail d'approbation

Avec autoApproval défini sur false, un nouvel enregistrement doit passer de DRAFT à PENDING_APPROVAL puis APPROVED. Les actions de soumission et de mise à jour du statut sont autorisées par IAM, ce qui permet de séparer les permissions de publication et d'approbation. Seuls les enregistrements approuvés sont renvoyés par le plan de données découvrible du Registry.

La transition d'approbation en deux étapes.

record = registry_client.get_registry_record(
    registryId=REGISTRY_ID,
    recordId=record_id,
)
if record["status"] == "DRAFT":
    registry_client.submit_registry_record_for_approval(
        registryId=REGISTRY_ID,
        recordId=record_id,
    )
    registry_client.update_registry_record_status(
        registryId=REGISTRY_ID,
        recordId=record_id,
        status="APPROVED",
        statusReason="Approved",
    )

3. La couche de découverte

Le client du plan de données prend en charge la recherche hybride par mots-clés et sémantique sur les enregistrements découvribles. Le nom de méthode le plus récent est search_discoverable_registry_records. Les résultats exposent les champs d'enregistrement normalisés et les descripteurs découvrables. Ils n'exposent pas les identifiants d'invocation de la capacité.

Recherche de enregistrements approuvés et découvrables à travers les protocoles.

response = dp_client.search_discoverable_registry_records(
    registryIds=[REGISTRY_ARN],
    searchQuery=query,
    maxResults=3,
)
records = response.get("registryRecords", [])

Dans le scénario d'exemple, une requête de retour et de remboursement récupère le Customer Support Agent parce que sa description capture cette intention. Considérez ceci comme un résultat de démonstration, et non comme une affirmation générale selon laquelle le classement s'améliore simplement parce que le catalogue est plus grand.

4. L'orchestrateur

L'orchestrateur est un agent Strands déployé sur le runtime Amazon Bedrock AgentCore. Il expose discover_and_execute, qui recherche dans le Registry, analyse chaque descripteur renvoyé, crée le client MCP ou A2A correspondant, et construit un agent interne limité à la requête à partir des seules capacités découvertes.

Figure 3 : flux par requête de l'orchestrateur. L'agent externe traduit la requête de l'utilisateur en une recherche dans le Registry. L'agent interne est assemblé à partir des résultats de la recherche et démantelé à la fin du tour

Le cœur de discover_and_execute tient dans un seul bloc de code :

La boucle découvrir/instancier/exécuter de l'orchestrateur.

​​​@tool 
 def discover_and_execute(request: str) -> str: 
     records = dp_client.search_discoverable_registry_records( 
         registryIds=[REGISTRY_ARN], 
         searchQuery=request, 
         maxResults=5, 
     ).get("registryRecords", []) 
  
    # Registry returns descriptors, not invocation credentials. 
     oauth_token = fetch_oauth_token_from_config() 
     mcp_clients, a2a_tools = [], [] 
     for record in records: 
         metadata = parse_server_metadata(record) 
         if metadata["protocol"] == "MCP": 
             mcp_clients.append( 
                 create_mcp_client_from_metadata(metadata, oauth_token) 
             ) 
         elif metadata["protocol"] == "A2A": 
             a2a_tools.append( 
                 create_a2a_tool_from_metadata(metadata, session, REGION) 
             ) 
  
    return run_request_scoped_agent(request, mcp_clients, a2a_tools)​​ 

​​model = BedrockModel(model_id=MODEL_ID, region_name=REGION) 
​    started_clients = [] 
​    try: 
​        mcp_tools = [] 
​        for c in mcp_clients: 
​            c.start() 
​            started_clients.append(c) 
​            mcp_tools.extend(c.list_tools_sync()) 

​ 	    ##agent compiled in realtime within agent 
​        sub_agent = Agent( 
​            model=model, 
​            tools=mcp_tools + a2a_tools, 
​            system_prompt=( 
​                "You are an Order Management & Customer Service assistant. " 
​                "Use the RIGHT tool for each request:\\n" 
​                "- Order lookups, status, cancellations, address changes: use MCP tools\\n" 
​                "- Pricing, discounts, promo codes: use the pricing_agent tool\\n" 
​                "- Returns, refunds, complaints, escalations: use the customer_support_agent tool\\n" 
​                "Always use the most specific tool for the task." 
​            ), 
​        ) 
​        return str(sub_agent(request)) 
​    finally: 
​        for c in started_clients: 
​            try: 
​                c.stop() 
​            except Exception: 
​                pass​

L'exemple distribue plusieurs requêtes de recherche pour améliorer le rappel dans son domaine de gestion des commandes, déduplique les enregistrements et démantèle les clients MCP après la requête. Cette distribution est un choix d'orchestration spécifique à l'exemple, et non une exigence du Registry. L'authentification reste en dehors de la découverte : le jeton OAuth de la Gateway est obtenu à partir de la configuration Cognito et de Secrets Manager, tandis que les appels au runtime A2A sont signés via la session boto3 .

5. Exécution des trois démonstrations

Chaque démonstration exerce une forme différente de la boucle de découverte.

Démonstration 1 : statut de commande (MCP uniquement)

Une requête qui se résout en un seul appel d'outil MCP.

result = invoke_orchestrator(
    "What is the current status and tracking info for order 123?",
    agentcore_client, orchestrator_arn,
)

Le Registry renvoie le serveur MCP de gestion des commandes. L'orchestrateur appelle get_order_status via la Gateway, le LLM synthétise une réponse lisible par l'humain, et l'agent interne se termine. Aucune implication d'A2A lors de ce tour.

Démonstration 2 : tarification et remises (MCP + A2A)

Une requête qui se résout en une chaîne multi-protocoles.

result = invoke_orchestrator(
    "Order 123 has 2x Widget Pro at $99.98. What discount tiers or "
    "promo codes can reduce the price?",
    agentcore_client, orchestrator_arn,
)

Le Registry renvoie le serveur MCP de gestion des commandes et l'agent A2A de tarification : deux protocoles, une seule requête en langage naturel. Le LLM appelle get_order_status pour récupérer les lignes de commande, puis appelle l'agent de tarification sur le runtime pour l'analyse des remises, puis synthétise une recommandation unique.

Démo 3 : Retour et remboursement (correspondance sémantique)

Une requête dont l'intention n'est littéralement présente dans aucun nom d'outil.

result = invoke_orchestrator(
    "I want to return order 789 (Premium Headphones, delivered "
    "March 10). Am I eligible for a return and what is the refund "
    "amount?",
    agentcore_client, orchestrator_arn,
)

Cette démo montre la valeur de la découverte sémantique. L'expression « return refund » n'apparaît pas dans le nom enregistré du Customer Support Agent. La recherche hybride la classe haut parce que sa description capture l'intention. Sans Registry, l'orchestrateur aurait besoin d'une connaissance codée en dur de l'agent qui gère les retours.

6. Observabilité

Instrumentez le chemin de découverte et d'invocation à l'aide d'Amazon Bedrock AgentCore Observability et Amazon CloudWatch le cas échéant. Les signaux utiles incluent les succès et échecs de recherche du Registry, les identifiants des enregistrements sélectionnés, les erreurs de construction du client, les résultats des invocations en aval, la corrélation des traces de bout en bout et les erreurs applicatives. L'exemple accorde des permissions Amazon CloudWatch Logs, mais il ne crée pas de métriques ni de tableaux de bord personnalisés. Les équipes de production doivent définir les traces, les journaux et les alertes requis pour leur modèle opérationnel. Les déploiements de production devraient également appliquer Amazon Bedrock Guardrails en tant que contrôle standard sur les réponses des agents.

Ce que les équipes gagnent avec la découverte gouvernée au runtime

Une fois la boucle de découverte en place, plusieurs capacités auparavant couplées aux versions de l'orchestrateur deviennent indépendantes.

  • Publication découplée. Les équipes peuvent déployer et enregistrer leurs propres serveurs MCP, agents et skills. La politique d'approbation détermine le moment où un enregistrement publié devient disponible pour les consommateurs.
  • Aucune modification du code de l'orchestrateur pour les nouveaux enregistrements approuvés. Dans ce modèle, l'ajout d'un enregistrement Registry compatible et approuvé ne nécessite pas l'ajout d'un import ou d'un point de terminaison spécifique à l'outil dans l'orchestrateur. Les modifications des protocoles, de la configuration de l'authentification ou de la politique d'orchestration peuvent néanmoins nécessiter des mises à jour de code ou de configuration.
  • Découverte gouvernée. Avec l'approbation manuelle, seuls les enregistrements examinés et approuvés deviennent découvrables. Les permissions IAM peuvent séparer les éditeurs d'enregistrements des approbateurs.
  • Authentification séparée. L'autorisation du Registry peut utiliser IAM ou un JWT personnalisé. L'authentification d'invocation des capacités est distincte : l'exemple utilise Cognito OAuth pour le Gateway et la signature Boto3/IAM pour le runtime AgentCore. Les résultats de recherche ne renvoient pas ces identifiants.
  • Recherche dans le catalogue au lieu du remplissage de prompt. Avec la recherche hybride du Registry, l'orchestrateur récupère un petit ensemble de candidats au lieu de placer le catalogue complet dans le contexte du modèle. La qualité de la recherche dépend des descriptions, de la qualité des descripteurs, de la conception des requêtes et de l'évaluation.

Quand ne pas utiliser la découverte au runtime

La découverte au runtime n'est pas nécessaire pour toutes les charges de travail. Deux modèles peuvent encore favoriser un câblage explicite au moment de la construction :

  • Catalogues petits et stables. Si l’ensemble complet des capacités est petit et change rarement, un câblage explicite au moment de la construction peut être plus simple et éviter une requête de découverte supplémentaire.
  • Pipelines fixes. Lorsque les mêmes capacités s’exécutent toujours dans un ordre fixe, les implémenter sous forme de flux déterministe est plus direct et maintient le traçage ciblé.

Conclusion

La découverte des actifs depuis le Registry à l’exécution rend l’orchestrateur moins dépendant d’un catalogue fixe. Avec un AWS Agent Registry, il peut rechercher des capacités approuvées avec une recherche hybride sémantique et par mots-clés, analyser des descripteurs MCP ou A2A, et instancier des clients à la portée de la requête. La gouvernance détermine ce qui est découvrable. L’authentification reste une préoccupation explicite pour le Registry et chaque capacité invoquée.

AWS Agent Registry est généralement disponible avec des capacités qui vont au-delà de cet exemple mono-compte :

Exécutez l’ exemple de découverte à l’exécution, puis enregistrez un serveur MCP ou un agent compatible qui vous appartient. Confirmez que son descripteur, son état d’approbation, son chemin d’authentification et son comportement de recherche correspondent à vos exigences de production.

En savoir plus

À propos des auteurs

Source originale

AWS Machine Learning

À propos du contenu

La publication originale et les droits appartiennent à la source.

Traduction automatique · Consultez l’original