MCP Connection Error Bug In Agent Factory

Aug 14, 2025 by Mireille Lambert 42 views

Bug Report: Error Connecting to mcpd When Not Needed

Hey guys, I wanted to report a bug I encountered while using the agent factory, and I think it's pretty important to address. So, let's dive straight into the details.

Issue Summary

I was trying to create an agent that could fetch a webpage from a URL and summarize its content in under 30 words. Pretty straightforward, right? I used the Chainlit UI to generate the agent, and everything seemed to go smoothly at first. However, I noticed that even though my agent didn't actually require any MCP (Mozilla Cloud Platform) servers, it was still importing the mcpd library, specifically:

from mcpd import McpdClient, McpdError

This is where the problem starts. Because this dependency is included unnecessarily, the agent attempts to connect to MCP servers when it doesn't need to. This leads to connection errors and a frustrating user experience. Imagine you're trying to quickly summarize a webpage, and you're hit with an error message about a service you don't even know you're using! This is not ideal, guys, and we need to fix it.

When I tried running the generated agent with a URL, I got the following error:

(test) ➜  ✗ python generated_workflows/30ee032b-78f5-48fc-b908-b86e34c6495d/agent.py --url https://hacks.mozilla.org/
/Users/ividal/.venvs/test/lib/python3.13/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.29.3 is exactly one major version older than the runtime version 6.31.1 at a2a.proto. Please update the gencode to avoid compatibility violations in the next runtime release.
  warnings.warn(
/Users/ividal/.venvs/test/lib/python3.13/site-packages/pydantic/_internal/_fields.py:198: UserWarning: Field name "config_type" in "SequentialAgent" shadows an attribute in parent "BaseAgent"
  warnings.warn(
Error connecting to mcpd: Could not retrieve all tool definitions: Error listing servers: HTTPConnectionPool(host='localhost', port=8090): Max retries exceeded with url: /api/v1/servers (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x16159dfd0>: Failed to establish a new connection: [Errno 61] Connection refused'))

As you can see, the agent is trying to connect to localhost:8090, which is the default address for MCP servers. Since I didn't have any MCP servers running locally (and didn't need them for this task), the connection failed. This highlights a significant issue: the agent is trying to do something it shouldn't be doing, leading to unnecessary errors and a poor user experience.

Root Cause Analysis

The root cause of this issue seems to be that the mcpd dependency is being injected into the agent's code regardless of whether it's actually needed. The agent factory appears to be including the from mcpd import McpdClient, McpdError line in the generated code by default, without checking if the agent's functionality requires it. This is like adding extra ingredients to a recipe even if they don't contribute to the final dish – it just adds unnecessary complexity and potential for errors.

In the context of agent creation, this means that even if an agent only needs to perform simple tasks like fetching and summarizing text, it's still being burdened with the overhead of the mcpd library and the attempt to connect to MCP servers. This not only makes the agent less efficient but also introduces a point of failure that can prevent the agent from working altogether.

Proposed Solution

To address this bug, we should modify the agent factory to inject the mcpd dependency only when it's truly necessary. This means that the agent factory needs to be smarter about analyzing the agent's requirements and determining whether it actually needs to interact with MCP servers. If the agent's tasks can be accomplished without MCP, then the mcpd dependency should not be included in the generated code.

Here's a breakdown of the proposed solution:

Analyze Agent Requirements: Before generating the agent's code, the agent factory should analyze the agent's requested functionalities and identify whether any of them require MCP server interaction. This could involve checking for specific tools or capabilities that rely on MCP, such as certain types of data processing or access to specific services. This analysis could be implemented as a series of checks within the agent factory's code, where each check corresponds to a particular feature or functionality that might require MCP. If none of these checks are triggered, it indicates that the agent can function independently without MCP.
Conditional Dependency Injection: Based on the analysis, the agent factory should conditionally inject the mcpd dependency. If the analysis determines that MCP is required, then the from mcpd import McpdClient, McpdError line (and any other necessary MCP-related code) should be included in the generated code. Otherwise, the mcpd dependency should be omitted. This conditional injection can be implemented using an if statement or a similar conditional construct within the agent factory's code. The condition would be based on the results of the agent requirements analysis. If the analysis indicates that MCP is needed, the code block that injects the mcpd dependency would be executed; otherwise, it would be skipped. This ensures that the agent's code only includes the dependencies it actually needs, reducing unnecessary overhead and potential errors.
Clear Error Messaging: If, for some reason, the agent attempts to use MCP functionality without the necessary dependencies, it should provide a clear and informative error message to the user. This message should explain that MCP is required for the requested operation and provide guidance on how to set up MCP or configure the agent to use it. This can be achieved by adding error-handling logic within the agent's code that specifically checks for the presence of the mcpd library or the availability of MCP servers. If the required resources are not found, an exception or warning can be raised with a descriptive message. This helps users understand the problem and take appropriate action, improving the overall user experience.

By implementing these steps, we can ensure that agents only include the dependencies they need, making them more efficient and less prone to errors. This will also improve the user experience by preventing unnecessary connection attempts and providing clearer error messages when MCP is actually required.

Impact

The impact of this bug is significant. It creates a poor user experience by generating agents that don't work out of the box, even for simple tasks. It also adds unnecessary complexity and overhead to the agent's code, making it less efficient. By fixing this, we can ensure that agents are generated correctly and only include the dependencies they need, making them more reliable and user-friendly.

This issue affects not just the specific agent I was trying to create but potentially any agent generated by the agent factory that doesn't explicitly require MCP. This means that a large number of users could be affected by this bug, especially those who are new to the agent factory and might not understand why they're seeing MCP-related errors. Therefore, fixing this bug is crucial for improving the overall usability and adoption of the agent factory.

Moreover, this bug highlights a potential architectural issue in the agent factory. The fact that dependencies are being injected unconditionally suggests that the agent generation process might not be as flexible or intelligent as it could be. Addressing this bug not only fixes the immediate problem but also provides an opportunity to improve the design of the agent factory and make it more robust and adaptable to different agent requirements. This could involve introducing a more sophisticated dependency management system or refactoring the code generation logic to be more modular and configurable.

Recommendation

I strongly recommend prioritizing this bug fix. It's a relatively straightforward issue with a significant impact on user experience and agent efficiency. By addressing this, we can make the agent factory a more reliable and user-friendly tool for everyone.

In addition to fixing the bug itself, I also recommend reviewing the agent factory's code generation process to identify other areas where we can improve dependency management and ensure that agents are generated as efficiently as possible. This could involve conducting a code audit, refactoring certain components, or introducing new testing procedures to catch similar issues in the future. The goal is to create a more robust and maintainable agent factory that can handle a wide range of agent requirements without introducing unnecessary overhead or dependencies.

Thanks for taking the time to read this, guys! Let me know if you have any questions or need more information.