Pydantic-AI: Direct MCP Tool Calls From Client-Side Code
In the realm of AI-driven applications, the pydantic-ai library stands as a powerful tool for building intelligent systems. However, current implementations of pydantic-ai.mcp require tool calls to be routed through an agent. This approach, while useful in many scenarios, invariably involves LLM orchestration, resulting in agentic overhead. This becomes particularly problematic when dealing with MCP server tools or functions that generate substantial outputs, such as retrieving a complete MySQL database schema. In such instances, the agent/LLM pathway can rapidly exhaust token/context constraints or introduce undesirable latency.
The Challenge with Current MCP Tool Call Implementations
The existing architecture of pydantic-ai.mcp mandates that all tool calls be mediated through an agent. While this design facilitates complex interactions and decision-making processes, it introduces significant overhead, especially when dealing with tools that produce large outputs. The reliance on LLM orchestration means that every tool call must be processed by a language model, which can be resource-intensive and time-consuming. For tasks that require deterministic tool output, such as schema caching or initial data loading, this approach is far from ideal.
The primary issue arises from the fact that the agent/LLM pathway is not optimized for handling large volumes of data. When a tool returns a substantial amount of information, such as a complete MySQL database schema, the agent must process this data, which can quickly lead to token exhaustion or context limit breaches. This is because language models have a finite capacity for processing input, and exceeding these limits can result in errors or truncated output. Furthermore, the latency introduced by the agentic processing can be a significant bottleneck, especially in high-throughput workflows.
Consider a scenario where an application needs to fetch and cache the schema of a large MySQL database at startup. With the current implementation, this would require an agent to call the appropriate MCP tool, process the schema information, and then return the result. This process is not only inefficient but also prone to failure due to the size of the schema. The agent may run into token limits or take an unacceptably long time to complete the task. This limitation hinders the ability to efficiently initialize and maintain applications that rely on large datasets or complex schemas.
The Need for Direct MCP Tool Calls
To address these limitations, it is imperative to enable direct calls to MCP tools from Python client code. This would bypass the agent and LLM processing, allowing developers to efficiently fetch and utilize large data without incurring the overhead associated with agentic orchestration. Direct tool calls would be particularly beneficial in scenarios where deterministic output is required, such as at startup for schema caching.
Direct MCP tool calls would provide several key advantages. First and foremost, they would eliminate the token and context limit issues that arise when using the agent/LLM pathway. By bypassing the language model, developers could retrieve large datasets without worrying about exceeding the input capacity of the model. This would enable them to work with larger and more complex datasets without encountering errors or limitations.
Secondly, direct tool calls would significantly reduce latency. By removing the agentic processing step, developers could retrieve data much faster, leading to improved performance and responsiveness. This is particularly important in high-throughput workflows where speed is critical. Direct tool calls would allow applications to quickly access and process data, enabling them to handle a greater volume of requests in a shorter amount of time.
Finally, direct tool calls would provide developers with greater control over how data is processed. By bypassing the agent, developers could work with the raw output from the server function, allowing them to perform custom processing and formatting as needed. This would enable them to tailor the data to their specific requirements, without being constrained by the limitations of the agent.
Proposed Solution: Direct Invocation of MCP Tools
To overcome the limitations of the current agent-mediated approach, a direct invocation API for MCP tools is proposed. This would allow developers to call registered tools directly from client-side Python, bypassing the agent and LLM processing. The key requirements for this API are as follows:
- Direct Invocation: The API should allow developers to directly invoke registered tools from client-side Python, without involving the agent or LLM processing.
- Raw Output: The tool return values should be passed directly as native Python objects or dictionaries, without any serialization or post-processing.
- Documentation: The API should be well-documented, with clear usage examples and options for developers who need raw access to MCP functions.
By implementing these features, the direct invocation API would provide developers with a powerful tool for efficiently accessing and utilizing MCP tools. This would enable them to overcome the limitations of the current agent-mediated approach and build more robust and scalable AI-driven applications.
Benefits of Direct MCP Tool Invocation
The introduction of direct MCP tool invocation would bring about several significant benefits, particularly in scenarios where large data handling and deterministic outputs are crucial.
Efficiency in Handling Large Data
Direct tool calls circumvent the limitations imposed by LLM context windows, which can be restrictive when dealing with substantial datasets such as complete database schemas. By bypassing the agentic layer, the system can directly retrieve and process the required information, optimizing resource utilization and minimizing the risk of exceeding token limits.
Reduced Latency
Eliminating the agentic processing step translates to a notable reduction in latency. Direct tool invocation allows for quicker data retrieval and processing, enhancing the overall performance and responsiveness of applications, especially in high-throughput environments.
Enhanced Control and Flexibility
Developers gain greater control over data processing by directly accessing the raw output from MCP tools. This facilitates custom formatting and manipulation, enabling developers to tailor data to their specific requirements without being constrained by predefined agentic workflows.
Simplified Startup and Schema Caching
Direct tool calls streamline tasks such as schema caching at startup, making the process more efficient and less prone to errors. Developers can easily fetch and format schema information without relying on complex agentic interactions.
Example Scenario: Fetching MySQL Schema
Consider the scenario of working with a MySQL MCP server and the need to fetch complete schema information by default at startup for formatting and caching purposes. Currently, this process relies on an agent, which can be prone to failure or limitations when dealing with large schemas. With direct client tool calls, this task becomes trivial and highly efficient. The ability to directly invoke the tool and retrieve the schema as a native Python object eliminates the overhead associated with agentic processing, resulting in a streamlined and reliable workflow.
Conclusion
The addition of an API to pydantic-ai.mcp that enables direct invocation of registered tools from client-side Python represents a significant enhancement to the library. By bypassing agent and LLM processing, developers can efficiently fetch and utilize large data, avoid token limit errors, and use agent orchestration only when genuinely needed. This would unlock new possibilities for building robust and scalable AI-driven applications. To learn more about Pydantic and its capabilities, you can visit the official Pydantic documentation. This external resource provides comprehensive information and examples of how to effectively use Pydantic in your projects.
