Agent Python vers Agent A2A

Le générateur connection peut connecter votre Agent Python à un agent A2A distant — soit TypeScript soit Python — afin que votre agent puisse déléguer à un autre agent en tant qu’outil.

Le générateur configure tout le câblage nécessaire pour que votre agent puisse découvrir et invoquer l’agent A2A distant, à la fois lorsqu’il est déployé sur AWS (via Bedrock AgentCore) et lors de l’exécution locale.

Prérequis

Avant d’utiliser ce générateur, assurez-vous d’avoir :

Un projet Python avec un composant Agent Python (Strands ou LangChain)
Un projet avec un composant Agent généré avec --protocol=a2a et --auth=iam (soit ts#agent soit py#agent)
Les deux composants créés avec infra: agentcore

Utilisation

pnpm nx g @aws/nx-plugin:connection

yarn nx g @aws/nx-plugin:connection

npx nx g @aws/nx-plugin:connection

bunx nx g @aws/nx-plugin:connection

Vous pouvez également effectuer une simulation pour voir quels fichiers seraient modifiés

pnpm nx g @aws/nx-plugin:connection --dry-run

yarn nx g @aws/nx-plugin:connection --dry-run

npx nx g @aws/nx-plugin:connection --dry-run

bunx nx g @aws/nx-plugin:connection --dry-run

Installez le Nx Console VSCode Plugin si ce n'est pas déjà fait
Ouvrez la console Nx dans VSCode
Cliquez sur Generate (UI) dans la section "Common Nx Commands"
Recherchez @aws/nx-plugin - connection
Remplissez les paramètres requis
Cliquez sur Generate

Sélectionnez votre projet d’agent hôte comme source et votre projet d’agent A2A comme cible. Si vos projets contiennent plusieurs composants, spécifiez les options sourceComponent et targetComponent pour lever l’ambiguïté.

Options

Paramètre	Type	Par défaut	Description
sourceProject Requis	string	-	Le projet source
targetProject Requis	string	-	Le projet cible auquel se connecter
sourceComponent	string	-	Le composant source depuis lequel se connecter (nom du composant, chemin relatif à la racine du projet source, ou identifiant du générateur). Utilisez '.' pour sélectionner explicitement le projet comme source.
targetComponent	string	-	Le composant cible auquel se connecter (nom du composant, chemin relatif à la racine du projet cible, ou identifiant du générateur). Utilisez '.' pour sélectionner explicitement le projet comme cible.
preferInstallDependencies	boolean	true	Indique s'il faut privilégier l'installation des dépendances après l'exécution du générateur. Définir à false pour différer l'installation lors de l'exécution de plusieurs générateurs en lot (une installation s'exécute quand même si nécessaire pour que les générateurs suivants puissent calculer le graphe de projet Nx) ; installer une seule fois à la fin.

Sortie du générateur

Le générateur crée un projet Python partagé agent_connection dans packages/common/agent_connection/ (s’il n’existe pas déjà). Les modules clients par connexion sont générés dans ce projet partagé :

Répertoirepackages/common/agent_connection
- Répertoire<scope>_agent_connection
  - __init__.py Ré-exporte les clients par connexion
  - Répertoirecore
    agentcore_endpoints.py Résolution ARN/URL indépendante du framework
    agentcore_a2a_client_config.py Configuration client A2A indépendante du framework (ClientConfig signé)
    agentcore_a2a_client_<framework>.py Client A2A encapsulant la configuration pour le framework de votre agent
    Répertoireauth/ httpx.Auth SigV4 / transfert de session indépendant du framework
    …
  - Répertoireapp
    <target_agent_name>_client_<framework>.py Client A2A par connexion pour chaque agent A2A

Le suffixe du client correspond au framework de votre agent (_strands ou _langchain). Les deux encapsulent le même ClientConfig signé indépendant du framework : le client Strands encapsule un A2AAgent Strands, tandis que le client LangChain pilote directement le SDK a2a.

De plus, le générateur :

Transforme le fichier agent.py de votre agent pour enregistrer l’agent A2A distant en tant qu’outil en utilisant @tool
Ajoute le projet agent_connection comme dépendance d’espace de travail de votre projet d’agent
Met à jour la cible dev de l’agent pour dépendre de la cible dev de l’agent cible

Utilisation de l’agent A2A connecté

Le générateur transforme le fichier agent.py de votre agent pour encapsuler l’agent A2A distant en tant qu’outil. L’agent distant est enregistré avec un délégué décoré par @tool — l’import du décorateur et le constructeur de l’agent diffèrent selon le framework :

Strands
LangChain

from contextlib import contextmanager
from strands import Agent, tool

from my_scope_agent_connection import RemoteAgentClientStrands

@contextmanager
def get_agent():
    remote_agent = RemoteAgentClientStrands.create()

    @tool
    def ask_remote_agent(prompt: str) -> str:
        """Delegate a question to the remote RemoteAgent A2A agent and return its reply."""
        return str(remote_agent(prompt))

    yield Agent(
        system_prompt="...",
        tools=[ask_remote_agent],
    )

from langchain.agents import create_agent
from langchain_aws import ChatBedrockConverse
from langchain_core.tools import tool

from my_scope_agent_connection import RemoteAgentClientLangChain

def get_agent():
    remote_agent = RemoteAgentClientLangChain.create()

    @tool
    def ask_remote_agent(prompt: str) -> str:
        """Delegate a question to the remote RemoteAgent A2A agent and return its reply."""
        return str(remote_agent(prompt))

    return create_agent(
        model=ChatBedrockConverse(model=MODEL_ID, region_name=REGION),
        system_prompt="...",
        tools=[ask_remote_agent],
    )

Les deux clients sont directement appelables, retournant la réponse de l’agent distant, et encapsulent un httpx.AsyncClient qui signe les requêtes avec SigV4 lorsqu’il est déployé sur AWS et utilise un point de terminaison http://localhost:<port>/ simple lorsque LOCAL_DEV=true. Le client Strands encapsule un A2AAgent Strands ; le client LangChain pilote directement le SDK a2a.

L’ID de session AgentCore est propagé automatiquement à l’agent distant via l’en-tête X-Amzn-Bedrock-AgentCore-Runtime-Session-Id, quel que soit le framework : le serveur d’agent lie la session de la requête entrante dans un contexte asynchrone, et le httpx.Auth signé du client de connexion l’appose sur chaque appel sortant — garantissant la cohérence pour Bedrock AgentCore Observability.

Infrastructure

Après avoir exécuté le générateur de connexion, vous devez accorder à l’agent hôte la permission d’invoquer l’agent A2A distant.

CDK
Terraform

const remoteAgent = new RemoteAgent(this, 'RemoteAgent');
const myAgent = new MyAgent(this, 'MyAgent');

// Grant the host agent permission to invoke the remote A2A agent
remoteAgent.grantInvokeAccess(myAgent);

grantInvokeAccess sur un agent A2A configure à la fois bedrock-agentcore:InvokeAgentRuntime et bedrock-agentcore:GetAgentCard — le client A2A a besoin des deux pour récupérer la carte d’agent et envoyer des messages.

L’ARN du runtime AgentCore de l’agent distant est automatiquement enregistré dans l’espace de noms agentcore de la Configuration d’exécution par la construction CDK générée, afin que l’agent hôte puisse le découvrir à l’exécution.

module "remote_agent" {
  source = "../../common/terraform/src/app/agents/remote-agent"

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn
}

module "my_agent" {
  source = "../../common/terraform/src/app/agents/my-agent"

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn
}

# Grant the host agent permission to invoke the remote A2A agent
resource "aws_iam_policy" "agent_invoke_a2a" {
  name = "AgentInvokeA2aPolicy"
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect = "Allow"
      Action = [
        "bedrock-agentcore:InvokeAgentRuntime",
        "bedrock-agentcore:GetAgentCard",
      ]
      Resource = module.remote_agent.agent_core_runtime_arn
    }]
  })
}

resource "aws_iam_role_policy_attachment" "agent_invoke_a2a" {
  role       = module.my_agent.agent_core_runtime_role_arn
  policy_arn = aws_iam_policy.agent_invoke_a2a.arn
}

L’ARN du runtime AgentCore de l’agent distant est automatiquement enregistré dans l’espace de noms agentcore de la Configuration d’exécution par le module Terraform généré, afin que l’agent hôte puisse le découvrir à l’exécution.

Développement local

Le générateur configure la cible dev de l’agent hôte pour :

Démarrer automatiquement le(s) agent(s) A2A connecté(s)
Définir LOCAL_DEV=true afin que le client généré se connecte directement à http://localhost:<port>/ au lieu d’AgentCore

Exécutez l’agent localement avec :

pnpm nx <agent-name>-dev <project-name>

yarn nx <agent-name>-dev <project-name>

npx nx <agent-name>-dev <project-name>

bunx nx <agent-name>-dev <project-name>

Cela démarrera à la fois l’agent hôte et tous les agents A2A connectés, l’agent hôte appelant les agents distants via HTTP simple sur leurs ports locaux assignés.