Model Context Protocol (MCP) Integration Proposal

[madtank]

I'd like to suggest adding MCP (Model Context Protocol) support to enhance our agent capabilities. MCP is essentially a "USB for AI tools" - providing a standardized way for AI agents to discover and use different capabilities.

Benefits

• Standardized access to a growing ecosystem of tools
• Simplified tool integration through protocol standards
• Access to existing capabilities like Brave Search and filesystem operations
• Future-proof as new MCP servers become available

Implementation

I have experience implementing MCP in AutoGen Studio and would be happy to help:

• Building the MCP client integration
• Adding server configuration management
• Creating test infrastructure
• Documentation and examples

The MCP Python SDK makes this relatively straightforward to implement, and I believe it would add significant value to our toolkit.

Would love to discuss this further and contribute to making our agents more versatile through MCP integration!

[JoshuaC215]

Hey, I think it’s a great idea. Thank you for the detailed writeup!

I have looked through the MCP repo and announcement a while back though I haven’t tried building with it. A couple questions:

• Is the idea to add a hook for an agent to use a MCP server to access e.g. some external tool or context?
• Do we need to add a MCP server implementation in the repo to test and demo it effectively? (I’m slightly nervous how much scope and code that would be)
• It would work with any LLM right, not just anthropic? Are you aware of any existing examples of using it with LangGraph, for reference?

If you’re willing, it might be worth sketching out one more level of detail on how you’d propose adding it to the toolkit; if it’s easier to do a very rough PR so I can get a sense, that’s welcome too! (I just don’t want you to spend a bunch of time in a direction that I ultimately don’t want to support).

[madtank]

Hey Josh,

Thank you for your thoughtful questions about integrating the Model Context Protocol (MCP) into the toolkit. I've been working on an implementation that I believe addresses many of the concerns and opportunities you highlighted.

What is MCP?

MCP (Model Context Protocol) is essentially a "USB for AI tools" - a standardized way for AI agents to discover and use different capabilities. Created by Anthropic, it provides a secure, flexible framework for connecting AI systems to various data sources and tools.

Implementation Overview

I've developed a dynamic MCP client that provides:

• Lightweight, configuration-driven tool integration
• No need to implement a full MCP server
• Support for multiple LLMs and runtime environments

Key Features

1. Dynamic Tool Discovery

# List available servers
servers = await mcp(tool='list_available_servers')

# Discover tools for a specific server
tools = await mcp(server='brave-search', tool='tool_details')

# Execute a tool
result = await mcp(
    server='brave-search', 
    tool='brave_web_search', 
    arguments={'query': 'Latest AI developments'}
)

2. Flexible Configuration

• Supports multiple configuration file locations
• Easy to enable/disable servers
• Environment-specific settings

3. Broad Tool Support
   Integrated servers include:

• Brave Search
• Filesystem operations
• Sequential Thinking
• Potential for MongoDB, Playwright, etc.

Addressing Your Questions

1. Agent Hook: Yes, this provides a standardized way for agents to access external tools and context.

2. Server Implementation: No additional server implementation needed. The MCP Python SDK handles the complex protocol interactions.

3. LLM Compatibility: Completely LLM-agnostic. Works with any language model, not just Anthropic.

Benefits

• Standardized tool access
• Security through well-defined boundaries
• Easy expansion of agent capabilities
• Growing ecosystem of MCP servers

Technical Details

The client uses the MCP Python SDK to:

• Dynamically discover available servers
• Validate tool configurations
• Handle tool execution
• Manage system-specific path detection

Next Steps

I'd be happy to:

• Share a detailed implementation
• Demonstrate tool integration
• Discuss potential use cases in the toolkit

Would you like to dive deeper into how this could enhance the agent capabilities?

For a concrete implementation, check out the repository: https://github.com/madtank/autogenstudio-skills

Best regards,
Jake

[JoshuaC215]

Thanks! I looked through your repo, I think this is the key file you’re referring to and talking about adding to the toolkit, right?

If so - I have two potentially blocking concerns about this:

• the example servers seem to run mostly on npx (I remember seeing this before in the official MCP repo too). I don’t want to add an npx dependency or install ask to this project. Is there an example of a public tool like web search or something simple / low setup which can be run in a docker container as an example? Ideally an existing public docker image. Then it will fit in with the toolkit stack nicely.
• It seems like you implemented a moderately complex custom config json format for your client. I think it would be confusing in the toolkit and difficult to maintain. To add this I’d prefer a simple config that integrates with the existing pydantic-settings, such as 1-2 environment variables which are a list of available server addresses or commands

Let me know what you think about my concerns!

[madtank]

Hi Joshua,

Thanks for the feedback about the config format and NPX dependencies. You're absolutely right - we can simplify this significantly. Here's the proposed approach:

1. Replace Custom Config with Simple Pydantic Settings

class MCPSettings(BaseSettings):
    """MCP Server Settings"""
    MCP_SERVER_URLS: List[str] = ["http://localhost:5678"]
    MCP_ENABLED: bool = True
    
    class Config:
        env_prefix = "ASTK_"

2. Containerize MCP Servers

FROM node:slim

# Install MCP toolbox and common tools globally
RUN npm install -g @anthropic-ai/mcp-toolbox \
                  @anthropic-ai/mcp-brave-search

WORKDIR /app
EXPOSE 5678

CMD ["npx", "@anthropic-ai/mcp-brave-search"]

3. Make MCP Layer Optional

• Toolkit works without MCP by default
• When MCP_ENABLED=true, connect to configured servers
• No NPX requirement on host system
• Individual tools can be containerized separately

This gives us:

• Clean integration with existing toolkit settings
• Isolation of Node.js dependencies
• Flexibility to run MCP servers however makes sense (containers, local, remote)

I've started implementing this approach and can share more implementation details if you'd like to explore this direction further.

Let me know what you think!

[JoshuaC215]

Sounds good, this looks reasonable. Feel free to open a draft PR.

[madtank]

Sounds good, this looks reasonable. Feel free to open a draft PR.

Created a draft PR, using MCP for filesystem in docker container #164
I think it makes more sense to have MCP as optional, and running on the Dockerfile.service, that way networking is not an issue. I'm still working on minimal impact to Dockerfile.service, and conditional node install.

[JoshuaC215]

@madtank It sounds like the Anthropic team recently added Streamable HTTP and Authorization support to MCP. I didn't look too hard yet for reference implementations but maybe it makes the effort feasible now?

https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http
https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization

I also saw the new A2A protocol from Google. It seems to follow a very similar pattern to how agent-service-toolkit already works. I may take a pass at implementing that when I have some time.

[madtank]

Definitely going to look more into this HTTP streaming. I did get MCP working in my forked repo, and it is a clean integration. If you think there is demand to add MCP, I can come back and add the agent. There are a couple minor issues I thought would prevent you from wanting to merge:

1. I couldn't get the Node packages in a new image; they needed to be on the backend because most of the MCPs support only stdio, not SSE. If we had SSE MCPs or local in python, there would be no need for Node on the backend.

2. I also had to make some other changes that we'd have to do regression tests for.

There is still some work to make it enterprise-ready, but I have it working in my main branch. Let me know if you think I should pick this back up.