TypeScript Strands Agent a MCP

Il generatore connection può connettere il tuo TypeScript Strands Agent a un server MCP (sia TypeScript che Python).

Il generatore configura tutto il cablaggio necessario in modo che il tuo agente possa scoprire e invocare gli strumenti del server MCP, sia quando viene distribuito su AWS (tramite Bedrock AgentCore) che quando viene eseguito localmente.

Prerequisiti

Prima di utilizzare questo generatore, assicurati di avere:

1. Un progetto TypeScript con un componente Strands Agent
2. Un progetto con un componente server MCP (sia ts#mcp-server che py#mcp-server)
3. Entrambi i componenti creati con computeType: BedrockAgentCoreRuntime

Utilizzo

Eseguire il Generatore

VSCode

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
6. Clicca su Generate

CLI

pnpm

pnpm nx g @aws/nx-plugin:connection

yarn

yarn nx g @aws/nx-plugin:connection

npm

npx nx g @aws/nx-plugin:connection

bun

bunx nx g @aws/nx-plugin:connection

Puoi anche eseguire una prova per vedere quali file verrebbero modificati

pnpm

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

yarn

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

npm

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

bun

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

Seleziona il tuo progetto agente come sorgente e il tuo progetto server MCP come destinazione. Se i tuoi progetti contengono più componenti, specifica le opzioni sourceComponent e targetComponent per disambiguare.

Opzioni

Parametro	Tipo	Predefinito	Descrizione
sourceProject Obbligatorio	string	-	The source project
targetProject Obbligatorio	string	-	The target project to connect to
sourceComponent	string	-	The source component to connect from (component name, path relative to source project root, or generator id). Use '.' to explicitly select the project as the source.
targetComponent	string	-	The target component to connect to (component name, path relative to target project root, or generator id). Use '.' to explicitly select the project as the target.

Output del Generatore

Il generatore crea un pacchetto condiviso agent-connection e modifica il codice del tuo agente:

• Directorypackages/common/agent-connection

  • Directorysrc

    • Directoryapp

      • <mcp-server-name>-client.ts Client di alto livello per il server MCP connesso
    • Directorycore

      • agentcore-mcp-client.ts Client MCP AgentCore di basso livello con autenticazione SigV4/JWT
    • index.ts Esporta tutti i client
  • project.json
  • tsconfig.json

Inoltre, il generatore:

• Trasforma il file agent.ts del tuo agente per importare e utilizzare gli strumenti del server MCP
• Aggiorna il target serve-local dell’agente per dipendere dal target serve del server MCP
• Installa le dipendenze richieste

Utilizzo del Server MCP Connesso

Il generatore trasforma il file agent.ts del tuo agente per utilizzare gli strumenti del server MCP:

packages/example/src/my-agent/agent.ts

import { Agent, tool } from '@strands-agents/sdk';
import { MyMcpServerClient } from ':my-scope/agent-connection';

export const getAgent = async (sessionId: string) => {
  const myMcpServerClient = await MyMcpServerClient.create(sessionId);
  return new Agent({
    systemPrompt: '...',
    tools: [myMcpServerClient],
  });
};

Il parametro sessionId viene passato dal chiamante, garantendo coerenza per Bedrock AgentCore Observability.

Infrastruttura

CDK

Dopo aver eseguito il generatore di connessione, devi concedere all’agente il permesso di invocare il server MCP:

packages/infra/src/stacks/application-stack.ts

const mcpServer = new MyMcpServer(this, 'MyMcpServer');
const myAgent = new MyAgent(this, 'MyAgent');

// Grant the agent access to bedrock models
myAgent.agentCoreRuntime.addToRolePolicy(
  new PolicyStatement({
    actions: ['bedrock:InvokeModel', 'bedrock:InvokeModelWithResponseStream'],
    resources: ['arn:aws:bedrock:*:*:foundation-model/*', 'arn:aws:bedrock:*:*:inference-profile/*'],
  }),
);

// Grant the agent permissions to invoke the MCP server
mcpServer.agentCoreRuntime.grantInvoke(myAgent.agentCoreRuntime);

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

Terraform

Dopo aver eseguito il generatore di connessione, devi concedere all’agente il permesso di invocare il server MCP nella tua configurazione Terraform:

packages/infra/src/main.tf

module "inventory_mcp_server" {
  source = "../../common/terraform/src/app/mcp-servers/inventory-mcp"
}

module "story_agent" {
  source = "../../common/terraform/src/app/agents/story-agent"
}

# Grant the agent permissions to invoke the MCP server
resource "aws_iam_policy" "agent_invoke_mcp" {
  name = "AgentInvokeMcpPolicy"
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect   = "Allow"
      Action   = "bedrock-agentcore:InvokeAgent"
      Resource = module.inventory_mcp_server.agent_core_runtime_arn
    }]
  })
}

resource "aws_iam_role_policy_attachment" "agent_invoke_mcp" {
  role       = module.story_agent.agent_core_runtime_role_arn
  policy_arn = aws_iam_policy.agent_invoke_mcp.arn
}

L’ARN del runtime AgentCore del server MCP viene automaticamente registrato nel namespace connection della Runtime Configuration dal modulo Terraform generato, in modo che l’agente possa scoprirlo a runtime.

Sviluppo Locale

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

1. Avviare automaticamente i server MCP connessi
2. Impostare SERVE_LOCAL=true in modo che il client generato utilizzi il trasporto HTTP diretto invece di AgentCore

Esegui l’agente localmente con:

pnpm

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

yarn

yarn nx <agent-name>-serve-local <project-name>

npm

npx nx <agent-name>-serve-local <project-name>

bun

bunx nx <agent-name>-serve-local <project-name>

Questo avvierà sia l’agente che tutti i server MCP connessi, con l’agente che si connette ai server MCP direttamente tramite HTTP sulle loro porte locali assegnate.