Salta ai contenuti
@aws/nx-plugin
Blog

Agente Python Strands ad Agente A2A

Il generatore connection può connettere il tuo Python Strands Agent a un agente A2A remoto — sia TypeScript che Python — in modo che il tuo agente possa delegare a un altro agente come strumento.

Il generatore configura tutto il cablaggio necessario affinché il tuo agente possa scoprire e invocare l’agente A2A remoto, sia quando viene distribuito su AWS (tramite Bedrock AgentCore) che quando viene eseguito localmente.

Prerequisiti

Sezione intitolata “Prerequisiti”

Prima di utilizzare questo generatore, assicurati di avere:

  1. Un progetto Python con un componente Strands Agent (qualsiasi protocollo)
  2. Un progetto con un componente Strands Agent generato con --protocol=A2A e --auth=IAM (sia ts#strands-agent che py#strands-agent)
  3. Entrambi i componenti creati con computeType: BedrockAgentCoreRuntime

Utilizzo

Sezione intitolata “Utilizzo”

Eseguire il Generatore

Sezione intitolata “Eseguire il Generatore”
  1. Installa il Nx Console VSCode Plugin se non l'hai già fatto
  2. Apri la console Nx in VSCode
  3. Clicca su Generate (UI) nella sezione "Common Nx Commands"
  4. Cerca @aws/nx-plugin - connection
  5. Compila i parametri richiesti
    • Clicca su Generate

    Seleziona il progetto dell’agente host come sorgente e il progetto dell’agente A2A come destinazione. Se i tuoi progetti contengono più componenti, specifica le opzioni sourceComponent e targetComponent per disambiguare.

    Opzioni

    Sezione intitolata “Opzioni”
    Parametro Tipo Predefinito Descrizione
    sourceProject Obbligatorio string - Il progetto sorgente
    targetProject Obbligatorio string - Il progetto di destinazione a cui connettersi
    sourceComponent string - Il componente sorgente da cui connettersi (nome del componente, percorso relativo alla radice del progetto sorgente, o id del generatore). Usare '.' per selezionare esplicitamente il progetto come sorgente.
    targetComponent string - Il componente di destinazione a cui connettersi (nome del componente, percorso relativo alla radice del progetto di destinazione, o id del generatore). Usare '.' per selezionare esplicitamente il progetto come destinazione.

    Output del Generatore

    Sezione intitolata “Output del Generatore”

    Il generatore crea un progetto Python condiviso agent_connection in packages/common/agent_connection/ (se non esiste già). I moduli client per-connessione vengono generati in questo progetto condiviso:

    • Directorypackages/common/agent_connection
      • Directory<scope>_agent_connection
        • __init__.py Ri-esporta i client per-connessione
        • Directorycore
          • agentcore_a2a_client.py Client A2A AgentCore principale con autenticazione SigV4
        • Directoryapp
          • <target_agent_name>_client.py Client per-connessione per ogni agente A2A

    Inoltre, il generatore:

    • Trasforma il file agent.py del tuo agente per registrare l’agente A2A remoto come strumento utilizzando @tool
    • Aggiunge il progetto agent_connection come dipendenza workspace del progetto del tuo agente
    • Aggiorna il target serve-local dell’agente per dipendere dal target serve-local dell’agente di destinazione

    Utilizzo dell’Agente A2A Connesso

    Sezione intitolata “Utilizzo dell’Agente A2A Connesso”

    Il generatore trasforma il file agent.py del tuo agente per avvolgere l’agente A2A remoto come strumento:

    packages/my-project/my_module/agent/agent.py
    from contextlib import contextmanager
    from strands import Agent, tool
    

    from my_scope_agent_connection import RemoteAgentClient
    

    @contextmanager
    def get_agent(session_id: str):
        remote_agent = RemoteAgentClient.create(session_id=session_id)
    

        @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],
        )

    Il parametro session_id viene propagato dal chiamante, garantendo coerenza per Bedrock AgentCore Observability.

    Internamente, RemoteAgentClient.create(session_id=...) restituisce uno Strands A2AAgent configurato con un httpx.AsyncClient che firma le richieste con SigV4 quando distribuito su AWS, e un endpoint semplice http://localhost:<port>/ quando SERVE_LOCAL=true.

    Infrastruttura

    Sezione intitolata “Infrastruttura”

    Dopo aver eseguito il generatore di connessioni, è necessario concedere all’agente host il permesso di invocare l’agente A2A remoto.

    packages/infra/src/stacks/application-stack.ts
    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 su un agente A2A configura sia bedrock-agentcore:InvokeAgentRuntime che bedrock-agentcore:GetAgentCard — il client A2A ha bisogno di entrambi per recuperare la scheda dell’agente e inviare messaggi.

    L’ARN del runtime AgentCore dell’agente remoto viene automaticamente registrato nel namespace agentcore della Runtime Configuration dal costrutto CDK generato, in modo che l’agente host possa scoprirlo a runtime.

    Sviluppo Locale

    Sezione intitolata “Sviluppo Locale”

    Il generatore configura il target serve-local dell’agente host per:

    1. Avviare automaticamente gli agenti A2A connessi
    2. Impostare SERVE_LOCAL=true in modo che il client generato si connetta direttamente a http://localhost:<port>/ invece che ad AgentCore

    Esegui l’agente localmente con:

    Terminal window
    pnpm nx <agent-name>-serve-local <project-name>

    Questo avvierà sia l’agente host che tutti gli agenti A2A connessi, con l’agente host che chiama gli agenti remoti tramite HTTP semplice sulle loro porte locali assegnate.