Direct tool call?

[JonWoodlief]

Hi- I have an agent with MCP and I'd like to be able to directly call some of it's tools rather than having an AI do it. Is that possible?

[jhaisley]

Yes, mostly, it wouldn't work with anything that requires sampling.

See docs/client

import asyncio
from mcp_use import MCPClient

async def call_tool_example():
    config = {
        "mcpServers": {
            # Your server definitions here
        }
    }
    client = MCPClient(config)
    await client.connect()

    session = client.get_session("filesystem_server")

    # Call a tool with arguments
    result = await session.call_tool(
        name="read_file",
        arguments={
            "path": "/path/to/file.txt",
            "encoding": "utf-8"
        }
    )

    # Handle the result
    if result.isError:
        print(f"Error: {result.content}")
    else:
        print(f"File content: {result.content}")

    await client.disconnect()

asyncio.run(call_tool_example())

[Pederzh]

@JonWoodlief I've added a comprehensive example and documentation for direct tool calling in this PR!

@jhaisley Thank you for the proposed solution, your example was really helpful in understanding what users need. I noticed some minor inconsistencies in the approach (due to an issue in our docs), so I created a complete example demonstrating the proper way to call MCP tools directly without an LLM.

Example:

"""
Direct tool calling example using MCPClient.

Notes:
- This demonstrates calling tools directly without an LLM/agent.
- This approach will not work for tools that require sampling.
"""

import asyncio

from mcp_use import MCPClient

config = {
    "mcpServers": {
        "everything": {
            "command": "npx",
            "args": ["-y", "@modelcontextprotocol/server-everything"],
        }
    }
}


async def call_tool_example() -> None:
    client = MCPClient.from_dict(config)

    try:
        # Create and initialize sessions for configured servers
        await client.create_all_sessions()

        # Retrieve the session for the "everything" server (match the server name key in the config)
        session = client.get_session("everything")

        # List available tools
        tools = await session.connector.list_tools()
        tool_names = [t.name for t in tools]
        print(f"Available tools: {tool_names}")

        # Choose a tool to call (note: do not call sampling tools because they require an LLM to complete)
        # In the example, we call the "add" tool from the "everything" server
        # Result is a CallToolResult object
        # - content is a list of ContentBlock objects
        # - structuredContent is a dictionary of the structured result of the tool call (only for non-sampling tools)
        # - isError is a boolean indicating if the tool call was successful
        result_tool_add = await session.call_tool(name="add", arguments={"a": 1, "b": 2})

        # Handle and print the result
        if getattr(result_tool_add, "isError", False):
            print(f"Error: {result_tool_add.content}")
        else:
            print(f"Tool result: {result_tool_add.content}")
            print(f"Text result: {result_tool_add.content[0].text}")

    finally:
        # Ensure we clean up resources properly
        await client.close_all_sessions()


if __name__ == "__main__":
    asyncio.run(call_tool_example())

Just opened a PR #224
The PR includes:

• A new documentation page at docs/client/direct-tool-calls.mdx with detailed examples
• Updated README with a quick example
• Links to the existing examples/direct_tool_call.py file

This should make it much easier for users to discover and use the direct tool calling functionality that's already built into mcp-use.
The example covers proper session management, error handling.

[JonWoodlief]

Wow! Thanks a ton