Skip to content
@aws/nx-plugin
Blog

Python Strands Agent to MCP

The connection generator can connect your Python Strands Agent to an MCP server (either TypeScript or Python).

The generator sets up all the necessary wiring so your agent can discover and invoke the MCP server’s tools, both when deployed to AWS (via Bedrock AgentCore) and when running locally.

Prerequisites

Section titled “Prerequisites”

Before using this generator, ensure you have:

  1. A Python project with a Strands Agent component
  2. A project with an MCP server component (either ts#mcp-server or py#mcp-server)
  3. Both components created with computeType: BedrockAgentCoreRuntime

Usage

Section titled “Usage”

Run the Generator

Section titled “Run the Generator”
  1. Install the Nx Console VSCode Plugin if you haven't already
  2. Open the Nx Console in VSCode
  3. Click Generate (UI) in the "Common Nx Commands" section
  4. Search for @aws/nx-plugin - connection
  5. Fill in the required parameters
    • Click Generate

    Select your agent project as the source and your MCP server project as the target. If your projects contain multiple components, specify the sourceComponent and targetComponent options to disambiguate.

    Options

    Section titled “Options”
    Parameter Type Default Description
    sourceProject Required string - The source project
    targetProject Required 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.

    Generator Output

    Section titled “Generator Output”

    The generator creates a shared agent_connection Python project at packages/common/agent_connection/ (if it doesn’t already exist). Per-connection client modules are generated into this shared project:

    • Directorypackages/common/agent_connection
      • Directory<scope>_agent_connection
        • __init__.py Re-exports per-connection clients
        • Directorycore
          • agentcore_mcp_client.py Core AgentCore MCP client
        • Directoryapp
          • <mcp_server_name>_client.py Per-connection client for each MCP server

    Additionally, the generator:

    • Transforms your agent’s agent.py to import and use the MCP server’s tools via a class-based client
    • Adds the agent_connection project as a workspace dependency of your agent project
    • Updates the agent’s serve-local target to depend on the MCP server’s serve target

    Using the Connected MCP Server

    Section titled “Using the Connected MCP Server”

    The generator transforms your agent’s agent.py to use the MCP server’s tools:

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

    from my_scope_agent_connection import MyMcpServerClient
    

    @contextmanager
    def get_agent(session_id: str):
        my_mcp_server = MyMcpServerClient.create(session_id=session_id)
        with (
            my_mcp_server,
        ):
            yield Agent(
                system_prompt="...",
                tools=[*my_mcp_server.list_tools_sync()],
            )

    The session_id parameter is plumbed through from the caller, ensuring consistency for Bedrock AgentCore Observability.

    Infrastructure

    Section titled “Infrastructure”

    After running the connection generator, you need to grant the agent permission to invoke the MCP server:

    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.grantInvokeAccess(myAgent.agentCoreRuntime);

    The MCP server’s AgentCore runtime ARN is automatically registered in the connection namespace of Runtime Configuration by the generated CDK construct, so the agent can discover it at runtime.

    Local Development

    Section titled “Local Development”

    The generator configures the agent’s serve-local target to:

    1. Start the connected MCP server(s) automatically
    2. Set SERVE_LOCAL=true so the generated client uses direct HTTP transport instead of AgentCore

    Run the agent locally with:

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

    This will start both the agent and all connected MCP servers, with the agent connecting to the MCP servers directly via HTTP on their assigned local ports.