How to update MCP tools after starting an agent session?

[narendra-bluebash]

I’m currently working with MCP servers in my agent setup.
When creating the agent session, I pass all MCP servers like this:

# Create agent session with all components
self.session = AgentSession(
    turn_detection=turn_detection,
    stt=self.stt_service.stt_service,
    vad=silero.VAD.load(),
    llm=self.llm_service.llm_service,
    tts=self.tts_service.tts_service,
    max_tool_steps=2,
    user_away_timeout=config.agent.max_silence_duration,
    mcp_servers=active_mcp_servers
)

Now, I want to assign only the tools that are required for a specific agent, instead of passing all tools from all MCP servers.
For initialization, I’m doing this:

async def initialize_mcp_servers_for_multi_agent(
    self, agent_name: str, mcp_servers: List[mcp.MCPServerHTTP]
) -> None:

    for i, server in enumerate(mcp_servers):
        logger.debug(f"Initializing MCP server {i} ({server})...")
        if not server.initialized:
            try:
                await server.initialize()
            except Exception as e:
                logger.critical(f"[MCP initialize_mcp_servers_for_multi_agent]: {e}")
                return

This works fine if we want all mcp tools but if want only required tools to pass llm then
The problem is: once the agent session has started, I can’t update the MCP tools (e.g., add/remove tools dynamically).

1. Is there any way to pass new tools after the agent session has already started?

2. Or alternatively, what’s the best approach to handle await server.initialize()
   I noticed that if an MCP server is not running, await server.initialize() hangs and never exits.

[narendra-bluebash]

so to reslove this

  async def initialize(self) -> None:
        try:
            streams = await self._exit_stack.enter_async_context(self.client_streams())
            receive_stream, send_stream = streams[0], streams[1]
            self._client = await self._exit_stack.enter_async_context(
                ClientSession(
                    receive_stream,
                    send_stream,
                    read_timeout_seconds=timedelta(seconds=self._read_timeout)
                    if self._read_timeout
                    else None,
                )
            )
            await self._client.initialize()  # type: ignore[union-attr]
            self._initialized = True
        except Exception:
            await self.aclose()
            raise

apply timeout in await self._client.initialize() # type: ignore[union-attr]

[longcw]

similar to #3356 (comment), I think you can manage the MCP tools as regular function tools and use agent.update_tools(...) to update the tools.

for the timeout issue, doesn't the server.initialize() respect to the timeout options? but if so you can add a timeout outside with asyncio.wait_for

import asyncio

try:
    await asyncio.wait_for(server.initialize(), timeout=10)
except asyncio.TimeoutError:
    ...

[narendra-bluebash]

• The code as written won’t handle the case where the server is down.
• Instead of failing gracefully, it will get stuck and keep the server hanging.

import asyncio

try:
    await asyncio.wait_for(server.initialize(), timeout=10)
except asyncio.TimeoutError:
    ...

[longcw]

I am not sure what you mean, the wait_for will raise an error after timeout if the initialize hanging, and you can cleanup the resources in the exception block.

[narendra-bluebash]

When attempting to connect to a localhost MCP server that is not running, the system gets stuck on server.initialize().

Even when wrapping the call in asyncio.wait_for, the timeout does not trigger and the process hangs indefinitely.

Steps to Reproduce

1. Configure MCP to connect to a localhost endpoint.

2. Do not start the MCP server.

3. Run:

   await asyncio.wait_for(server.initialize(), timeout=10)

4. Observe that the call never returns and the timeout is ignored.

Expected Behavior

• The call should raise a connection error or respect the wait_for timeout.

Actual Behavior

• The process hangs indefinitely, blocking execution.

[longcw]

we can now use MCPToolset to update or filter the tools from MCP after agent session started. #5138