[FEATURE] Lazy connecting to MCP Server when creating a strands agent

[rliuamzn]

Problem Statement

Existing code of creating creating a strands agent with mcp client

We can see connecting to MCP Server to list tools is in the critical path of creating a strands agent to server a user prompt.

# existing code 

    http_mcp_client = MCPClient(
        lambda: streamablehttp_client(
            url="my-remote-mcp.com/mcp",
            auth=...,
            headers={},
        )
    )

    with http_mcp_client:
        # fetch latest tool list, contributing high latency !!!
        mcp_tools = http_mcp_client.list_tools_sync()

        agent = Agent(model=model, tools=filtered_tools)

        #  agent.stream_async(payload.user_prompt) ...

What we want:

Initialize Strands agents with tool spec list and mcp client. Connecting to MCP Server is not in critical path of creating strands agent. Only when a tool use is required, MCP client will be used to connect to the MCP Server.

# desired
    http_mcp_client = MCPClient(
        lambda: streamablehttp_client(
            url="my-remote-mcp.com/mcp",
            auth=...,
            headers={},
        )
    )

    with http_mcp_client:
        # hardcode a list of tool specs, so we can skip connecting to MCP server when constructing a strands agent
        # mcp client is used for calling mcp tool only when needed
        mcp_tools: list[Union[str, dict[str, str] = [
             # hardcoded tool specs + http_mcp_client
        ]

        agent = Agent(model=model, tools=mcp_tools)

        #  agent.stream_async(payload.user_prompt) ...
        # only when payload mentions tool call us needed, mcp client will be used to connect to the mcp tool

Proposed Solution

No response

Use Case

This feature request can help us build low latency agent with AgentCore. Currently connecting to mcp server to list tools is in the critical path:

app = BedrockAgentCoreApp()

@app.entrypoint
async def strands_agent_bedrock_streaming(payload):
    user_input = payload.get("prompt")
    with http_mcp_client:
        all_mcp_tools = http_mcp_client.list_tools_sync()
        agent = Agent(model=model, tools=all_mcp_tools)
        ....

Alternatives Solutions

No response

Additional Context

No response

[dbschmigelski]

Hi, this seems like this may already be possible but I'm sure there are edge cases.

So we already have MCPAgentTool which takes a tool and an MCPClient.

If we already have a cached input schema we can construct our own MCPAgentTools passing them the MCPClient and then also our stateless Tool definition we get directly from the mcp python-sdk.

So this would look something like

fun get_mcp_tools(mcp_client) -> list[AgentTool]:
    tool_definitions: list[Tool] = [...]
    return [
         MCPAgentTool(tool_definition, mcp_client)
         for tool_definition in tool_definitions
     ]


with mcp_client:
    agent = Agent(tools=[tool_a, get_mcp_tools(mcp_client)])

which should work afaict

That being said, I believe the concept of a "cached" mcp tool, supported in a more first class way in Strands, seems promising. Specifically, the concept of a hydrating tool. So perhaps the initial spec is provided, but in the background once the tool is attached to the agent we can do a background refresh which may insert new params or a partially configured tool

[signoredems]

I initially read this as a request for what I asked about in a discussion and what was previously requested in the improved DX feature. If that's the case, shouldn't the with statement be removed in the desired functionality since calling that immediately opens the connection to the MCP server rather than lazily connecting to it?

[dbschmigelski]

I agree @signoredems that the title aligns with what you're saying. Regarding #198 the PR is currently. open with a proposed design.

The example above addresses the concern of time lost to listing tools. So yes the connection is still formed, but listing is not needed.