Improving the selection of tools from multiple MCP Servers

[grll]

Now that we can handle multiple MCP servers, users will likely want to have an easy way to select the tools they want to use from each MCP servers.

Here is the latest point discuss for context:

I am definitly open to change the interface even though it might be a breaking change. In particular thinking of this point from Aymeric on the HF smolagents repo: huggingface/smolagents#1179 (comment)

We need a simpler way to pick the tools we want to use.

I am usually not a huge fan of named tuples I would use a dataclass or a pydantic model instead if the dict is not sufficient, what kind of interface were you thinking @sysradium ?

[sysradium]

Just to clarify, by mentioning the "interface" I was talking more about these https://github.com/grll/mcpadapt/blob/main/src/mcpadapt/core.py#L169-L170 being replaced by something else, for example self._mcps. so that instead of:

return [
    self.adapter.async_adapt(partial(session.call_tool, tool.name), tool)
    for session, tools in zip(self.sessions, self.mcp_tools)
    for tool in tools
]

You could do something like:

return [
    self.adapter.async_adapt(partial(mcp.session.call_tool, tool.name), tool)
    for m in self._mcps
    for tool in m.tools
]

To avoid the zip-ing.

However maybe even better in pull adapter somewhere, i.e.:

class  MCPSomething:
    def __init__(self, adapter, params):
         pass

   def tools():
         pass

   def atools():
         pass

Such that it boils down to:

return chain.from_iterable([
    mpc.tools()    
    for mcp in self._mcps
]

Overall the idea of:

with MCPClient(server_a, server_b) as client:
     tools = client.get_tools()
     picked_tools = tools[...]
     agent = CodeAgent(model=model, tools=picked_tools)

Looks ok to me (what was suggested in the comment). This should be still usable without a contextmaner, with:

client = MCPClient(server_a, server_b)
client.conect() # or start?
tools = client.get_tools()
picked_tools = tools[...]
agent = CodeAgent(model=model, tools=picked_tools)
...
client.stop()

However it is a big weird that "client" kind of both starts a server and then connects to it :)

[joejoe2]

Another suggestion: the MCP server can dynamically update tools by sending a list change event. For now, let's ignore that event, but tools() must always return the latest tools. So the external framework can invoke .tools() to refresh.

[sysradium]

So what's the way to go now? Any work to parallelise/take over?