Does MCPTools refresh_connection=True cause noticeable performance overhead ?

[user1500177]

Hello — I'm evaluating the MCPTools refresh_connection option in Agno's MCP integration and want community input on performance tradeoffs.

Context:

• I connect to an MCP gateway (Streamable HTTP) that sometimes restarts or updates available tools.
• I enabled refresh_connection=True to force a reconnect and rebuild of tools per run when the gateway can be unstable.
• Example connection code:

server_params = StreamableHTTPClientParams(
    url=mcp_gateway_url,
    headers=headers,
    timeout=90.0,
)
mcp_gateway_tools = MCPTools(
    server_params=server_params,
    transport="streamable-http",
    timeout_seconds=90,
    refresh_connection=True,
)

• Agno calls build_tools() which internally does available_tools = await self.session.list_tools() and then registers each tool (creating Function objects). This happens when refresh_connection is enabled in the agent tool-loading path: (I SAW THE BLOW IN the code base of agno tht happens in th build tools fro mthe session the listing of tools happen also IS THIS addin a small overhead or A LARGE ONE?)

Excerpt (simplified):

if is_mcp_tool and tool.refresh_connection:
    is_alive = await tool.is_alive()
    if not is_alive:
        await tool.connect(force=True)
    await tool.build_tools()

My questions:

1. Does calling list_tools() and re-registering tools per-run usually cause a measurable performance hit? If so, what are typical costs (latency, CPU, memory) you’ve observed?
2. Is the overhead small enough to enable refresh_connection=True as a safe default when MCP servers occasionally restart, or should it only be used when servers are unstable?
3. If the MCP gateway frequently updates the tool list (via a gateway), is there a recommended pattern to detect changes and refresh only when necessary (e.g., cache TTL, ETag/version check, or an event-based signal)?
4. Any suggestions for minimizing impact when tools are re-registered often? (e.g., avoid rebuilding unless tool list changed; lightweight list-only check; incremental updates)

Extra info I can provide:

• Whether the gateway is fast (sub-100ms) or slow
• Frequency of runs and typical agent concurrency
• Size of tool lists (number of tools, typical input schemas)

Thanks — looking for practical experiences and recommended best practices.