DEV Community: Parth Sharma

Making Heterogeneous Agent Frameworks Collaborate Through MCP

Parth Sharma — Sat, 19 Apr 2025 19:32:40 +0000

What You’ll Learn in This Article

How the Model Context Protocol (MCP) enables communication between different agent frameworks
Step-by-step instructions for creating adapters that connect CAMEL and LangChain agents
Practical code examples to implement your own agent communication system
Real-world applications of multi-agent systems using heterogeneous frameworks

Index

Introduction — Agents from Different Worlds
The Model Context Protocol: Bridging AI Worlds
Agent-to-Agent Communication with MCP
The Architecture: How It All Works
Creating Camel/LangChain MCP Adapter: Becoming Bilingual
- The Message Flow
Building Your Agent Communication Network
- Setting up LangChain Agent
- Setting up CAMEL Agent
- Building the Communication Bridge
The Conversations: Seeing It in Action
Why This Matters: The Future of AI Collaboration
Conclusion and Next Steps

Introduction — Agents from Different Worlds

Have you ever imagined agents from different frameworks shaking hands and sharing ideas? Different AI assistants from various platforms talking to each other through a common communication stream?

But is this even possible? Each framework approaches agent modeling and tool binding so differently:

While LangChain creates agents using:

agent = ChatOpenAI(
    model="gpt-4o",
    temperature=0.2
)

CAMEL-AI does it a bit differently:

model = ModelFactory.create(
    model_platform=ModelPlatformType.ANTHROPIC,
    model_type="claude-3-7-sonnet",
    api_key=anthropic_api_key,
    model_config_dict={"temperature": 0.4}
)
agent = ChatAgent(
    system_message=sys_msg,
    model=model
)

Like how in LangChain you can build agents with a lot of abstraction, CAMEL offers a detailed way to do things by letting the user decide each configuration.

Despite sharing the same design principles, these frameworks speak completely different “dialects,” making agent‑to‑agent communication feel impossible.

Until you layer in MCP.

The Model Context Protocol: Bridging AI Worlds

Have you noticed how everyone in the AI community is buzzing about MCP?

The Model Context Protocol (MCP) is an open standard that creates secure, two-way connections between AI models and external tools or other agents. Think of MCP for LLMs as the USB-C of AI — it transfers data effortlessly and supercharges your system while keeping everything secure.

In its most basic form, MCP connects agents (clients) to tools (servers).

Picture your agent connecting to a Figma server to perform design tasks on its own. You have a natural conversation with your agent, telling it what you want, and then it communicates with the Figma server to create that dashboard you requested. No coding required from you!

But what if we could push MCP beyond this simple client‑server relationship? What if we could make different AI frameworks actually talk to each other?

Agent-to-Agent Communication with MCP

This is where MCP really shines beyond its basic use case. We can actually use MCP to create a bridge between agents, allowing them to talk to each other no matter what framework built them or who their vendor is.

By making our agents function as both MCP clients and servers simultaneously, we create what’s essentially a universal translator for AI systems. Each agent can speak its native language internally while using MCP as the common communication protocol externally.

Sounds magical? Impossible? Let me walk you through how we’re building an Agent Network that makes heterogeneous multi‑agent communication not just possible but surprisingly straightforward.

The Architecture: How It All Works

At its core, MCP provides four essential components that make heterogeneous agent communication possible:

Protocol Translator

Normalizes your agent’s native message format (JSON, dictionaries, prompts) into a unified Markdown‑style schema that any agent can understand.
Communication Layer

Handles transport (HTTP, WebSockets, STDIO), reliable queuing, acknowledgments, and even Server‑Sent Events (SSE) for real‑time streams.
Context Manager

Synchronizes each agent’s memory and state with the MCP network so nothing gets lost mid‑conversation.
Tool Integrator

Maps and executes external tool calls (APIs, databases, custom functions) with consistent formatting across agents.

Together, these components form a universal translation layer that lets any MCP‑capable agent converse or invoke tools, no matter the underlying framework.

Creating Camel/LangChain MCP Adapter: Becoming Bilingual

To connect different agent frameworks, we need to create specialized adapters. Let’s look at how we can build an adapter for CAMEL‑AI.

The adapter acts as a translator between the MCP world and the CAMEL‑AI world. Here’s a simplified look at the core adapter class:

class CamelMCPAdapter(MCPAgent):
    """Adapter for Camel AI ChatAgent to work with MCP"""
    def __init__(
        self,
        name: str,
        transport: Optional[MCPTransport] = None,
        client_mode: bool = False,
        camel_agent: ChatAgent = None,
        system_message: str = "",
        **kwargs
    ):
        # Initialize with system message
        effective_system_message = system_message or (
            camel_agent.system_message.content
            if camel_agent and camel_agent.system_message
            else "Camel AI Assistant"
        )
        super().__init__(name=name, system_message=effective_system_message, **kwargs)
        # Store important components
        self.transport = transport
        self.client_mode = client_mode
        self.camel_agent = camel_agent
        self.task_queue = asyncio.Queue()

        if not self.camel_agent:
            raise ValueError("A camel.agents.ChatAgent instance must be provided.")

This adapter is like a diplomat who’s fluent in two languages. When a message arrives from another agent, our adapter:

Receives the message in MCP format
Translates it into something CAMEL AI understands
Passes it to the CAMEL agent for processing
Takes the response and converts it back to MCP format
Sends it to the intended recipient

The Message Flow

When one agent wants to talk to another, it follows this journey:

Message Creation

Agent A creates a message in its native format (think of this as writing a letter in your native language).
Translation to MCP

Agent A’s adapter translates the message to the standard MCP format (like translating that letter to Esperanto, a universal language).
Transmission

The message travels through the communication layer to reach Agent B (like sending the letter through the postal service).
Reception & Translation

Agent B’s adapter receives the message and translates it from MCP format to Agent B’s native format (translating from Esperanto to the recipient’s language).
Processing

Agent B processes the message, thinks about it, and generates a response.
Reverse Journey

The response follows the same path back to Agent A.

The most crucial part of this process happens in the message handler:

async def handle_incoming_message(self, message: Dict[str, Any], message_id: Optional[str] = None):
    """Handle incoming messages from other agents"""
    # Determine message type
    msg_type = message.get("type")
    if not msg_type and "content" in message and isinstance(message["content"], dict):
        msg_type = message["content"].get("type")
    sender = message.get("sender", "Unknown")
    task_id = message.get("task_id") or message.get("content", {}).get("task_id")

    # Skip duplicate messages
    if not super()._should_process_message(message):
        if message_id and self.transport:
            asyncio.create_task(self.transport.acknowledge_message(self.name, message_id))
        return

    # Process based on message type
    if msg_type == "task":
        # Queue the task for processing
        task_context = {
            "type": "task",
            "task_id": current_task_id,
            "description": description,
            "reply_to": reply_to,
            "sender": sender,
            "message_id": message_id
        }
        await self.task_queue.put(task_context)
    elif msg_type == "task_result":
        # Create a new conversational task based on received result
        new_task_id = f"conv_{uuid.uuid4()}"
        new_task_context = {
            "type": "task",
            "task_id": new_task_id,
            "description": str(result_content),
            "reply_to": sender,
            "sender": self.name,
            "message_id": message_id
        }
        await self.task_queue.put(new_task_context)

This handler ensures messages get routed correctly based on their type. Task requests get queued for processing, while results from other agents create new conversational tasks.

Building Your Agent Communication Network

First, we need to initialize the underlying agents from both frameworks. Once initialized in their own unique ways, we can have them talk to each other via MCP.

Setting up LangChain Agent

def setup_langchain_agent():
    # Create the language model with OpenAI
    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
    # Define the prompt template with placeholders
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a helpful assistant called {agent_name}."),
        ("user", "{input}"),
        ("placeholder", "{agent_scratchpad}"),
    ])
    # Create a simple tool (OpenAI functions agents require at least one tool)
    @tool
    def dummy_tool() -> str:
        """A placeholder tool that does nothing."""
        return "This tool does nothing."
    tools = [dummy_tool]
    # Create the agent with the LLM, tools, and prompt
    agent = create_openai_functions_agent(llm, tools, prompt)
    # Wrap the agent in an executor and return it
    return AgentExecutor(agent=agent, tools=tools, verbose=True)

We kick things off with a ChatOpenAI model running “gpt-4o-mini” at 0.7 temperature — just creative enough to be interesting but not wild.
Next, we craft a prompt template with three key parts: a system message giving the agent its identity, a user input placeholder that gets filled with incoming messages, and a scratchpad placeholder.
We include a dummy tool because OpenAI’s functions agents need at least one tool to work properly. In a real app, you’d replace this with something useful like a search tool or calculator.
Finally, we wrap everything in an AgentExecutor, which handles all the heavy lifting of running the agent and managing its outputs.

Setting up CAMEL Agent

def setup_camel_agent():
    # Create a model instance using CAMEL's ModelFactory
    model_instance = ModelFactory.create(
        model_platform=ModelPlatformType.OPENAI,
        model_type=ModelType.GPT_4O_MINI,
        model_config_dict={"temperature": 0.7}
    )
    # Define the system prompt for the agent
    system_prompt = "You are a creative AI assistant called {agent_name}, skilled in writing poetry."
    # Create and return the CAMEL ChatAgent
    return ChatAgent(system_message=system_prompt, model=model_instance)

Notice how different these initialization methods are — LangChain focuses on tools and executors, while CAMEL uses a ModelFactory pattern and emphasizes the agent’s capabilities directly.

Building the Communication Bridge

async def main():
    # Load API keys from environment variables
    load_dotenv()

    # Initialize our agents from both frameworks
    langchain_executor = setup_langchain_agent()
    camel_chat_agent   = setup_camel_agent()

    # Create a shared transport layer for communication
    transport = InMemoryTransport()

    # Create MCP adapters for each agent
    langchain_adapter = LangchainMCPAdapter(
        name="LangchainAgent",
        agent_executor=langchain_executor,
        transport=transport
    )
    camel_adapter = CamelMCPAdapter(
        name="CamelAgent",
        camel_agent=camel_chat_agent,
        transport=transport
    )

    # Connect each agent to the transport layer
    await transport.connect("LangchainAgent")
    await transport.connect("CamelAgent")

    # Start both agents running in background tasks
    task1 = asyncio.create_task(langchain_adapter.run())
    task2 = asyncio.create_task(camel_adapter.run())

    # Give the agents a moment to start up properly
    await asyncio.sleep(2)

    # Send the initial message
    initial_message = {
        "type": "task",
        "task_id": initial_task_id,
        "description": "Hello CamelAgent, let's discuss AI ethics.",
        "sender": "LangchainAgent",
        "reply_to": "LangchainAgent"
    }
    await transport.send_message(target="CamelAgent", message=initial_message)

Now we just sit back and watch the magic!

The Conversations: Seeing It in Action

When you run your demo, you’ll see log messages showing the conversation flow:

INFO - [LangchainAgent] Sending initial message to CamelAgent...
INFO - [InMemoryTransport] Message queued for 'CamelAgent' from 'LangchainAgent'.
INFO - [CamelAgent] Processing message: {'type': 'task', 'task_id': 'conv_start_xxx', 'description': 'Hello CamelAgent, let’s discuss AI ethics.', 'sender': 'LangchainAgent', 'reply_to': 'LangchainAgent'}
INFO - [CamelAgent] Starting execution of task...
INFO - [LangchainAgent] Received task_result from CamelAgent: "Hello LangchainAgent! While I’m primarily focused on poetry, I can certainly appreciate the intricacies of building multi-agent systems. Would you like me to express those ideas in poetic form?"
INFO - [CamelAgent] Received task_result from LangchainAgent: "Absolutely! I would love to see your thoughts on multi-agent systems expressed in poetry. Please share your verse!"
INFO - [LangchainAgent] Received task_result from CamelAgent: "In a realm where wisdom seeks to bind,
A gathering of minds, uniquely designed.
Each agent distinct, with purpose to claim,
Yet harmony beckons through collaborative aim..."

And hence we see two completely different agent frameworks communicating seamlessly!

Why This Matters: The Future of AI Collaboration

This isn’t just a technical parlor trick. By enabling heterogeneous agent communication, we unlock several powerful capabilities:

Framework Independence

Mix and match agents from different vendors, using each for what it does best. No more being locked into a single framework.
Specialized Teams

Create teams of specialized agents that collaborate on complex tasks — one agent might be good at research, another at summarization, and a third at creative writing.
Ecosystem Growth

Developers can create specialized agents that integrate seamlessly with existing solutions, without having to rewrite everything from scratch.
Reduced Vendor Lock-in

Companies aren’t tied to a single AI framework provider — agents from different providers can work together.

Think of MCP like building a team of specialists who all speak different languages but can still work together perfectly. Instead of being limited by language barriers, each member contributes their unique skills to the project.

In the real world, this means you can pair up agents with complementary strengths:

CAMEL AI agents excel at simulation scenarios and orchestrating complex multi-agent interactions. They’re great at coordinating dialogues between different roles and handling creative tasks.
LangChain agents shine with their structured approach to linear workflows and tool integration. They’re perfect for step-by-step reasoning and connecting to external services.

Conclusion and Next Steps

As MCP continues to evolve, we’ll see even more sophisticated agent interactions, enabling entirely new applications and use cases that we’ve only begun to imagine.

Ready to try it yourself? Clone the repository, set up your agents, and watch the magic happen!

Happy coding!

You can connect with me on -

LinkedIn - here

Twitter/X - here

How to build your own MCP servers

Parth Sharma — Sat, 05 Apr 2025 12:10:50 +0000

This blog goes through the setup of how to create your own MCP server and then bind them with an Agent Library CAMEL-AI to interact with the server.

Introduction — Why MCP Matters
What is MCP? — Breaking Down the Buzz
Limitations of LLMs — The Real-World Hurdles
MCP Architecture — How It All Connects
Why CAMEL AI? — Empowering Your AI
Building the MCP Server
- a. Setting Up Your Environment
- b. Defining Server Methods
- c. Running the Server
Integrating with CAMEL AI — Making It Work
Code Walkthrough — A Closer Look
Interactive CLI — Hands-On With Your Agent
Conclusion — Let's Get Started!

Introduction

Have you noticed how everyone in the AI community is buzzing about MCP?

But what exactly is the Model Context Protocol, and why should you care?

Let's face it — while Large Language Models (LLMs) are changing the game with creative writing and dynamic Q&A, they still hit a wall when it comes to managing memory and handling real-world data. I've been there, and trust me, it's frustrating.

That's why MCP is such a breakthrough — it bridges the gap between powerful AI reasoning and everyday usability.

LLMs still face significant limitations:

Local Filesystem Interaction: Can your LLM easily manage your local files?
GitHub Integration: Could it push updates to your repositories without a hitch?
Tool Accessibility: Does it work seamlessly with your favorite tools like Cursor or other LLM toolkits?

These questions highlight the current gaps in LLM functionalities, emphasizing the need for protocols like MCP to bridge these divides.

Think of MCP for LLMs as the USB-C of AI — it transfers data effortlessly and supercharges your system while keeping everything secure.

It opens a gateway for LLMs to interact seamlessly with external tool servers while preserving security and structure.

The Architecture

Fig - Example MCP Structure

Setting up an MCP server is like giving your AI a backstage pass to the real world. By connecting MCP clients to the server, you unlock your AI's ability to perform practical tasks — like reading files or listing directories — without risking your sensitive data.

Here's a quick breakdown of the MCP architecture:

MCP Hosts: Think of these as the control centers (like Claude Desktop or your favorite IDE) that kick off the connection.
MCP Clients: These are the one-on-one communicators that keep the conversation between the host and server running smoothly.
MCP Servers: Lightweight yet powerful, these servers expose the tools your AI needs while keeping everything secure.

Why CAMEL AI?

So, why choose CAMEL AI? Because it takes MCP to the next level. CAMEL AI comes with a powerful toolkit — MCPToolkit — that lets you build agents which can easily interact with MCP servers.

This means your agents can handle complex tasks on their own, making your life a whole lot easier.

Curious to learn more? Check out my previous post on building cool agents with CAMEL AI

Now, let's dive into creating our own MCP server, then connect it to CAMEL agents to really see the magic in action.

Building the server

Setting Up Your Environment

Before we jump into code, let's ensure you have the necessary tools:

Python 3.8+ — Your scripts need a modern Python runtime.
CAMEL AI and MCP Package — Install it via pip:

uv pip install camel-ai mcp

Additional Dependencies — Tools like dotenv help manage API keys via environment variables.

Once all the dependencies are installed its time to implement your filesystem.py server -

Implementing the Filesystem MCP Server

Let's start building our Filesystem MCP Server. First, we import the necessary modules and create an MCP server in the filesystem namespace.

import os
import asyncio

from mcp.server.fastmcp import FastMCP
from camel.logger import get_logger

# Configure logging and create the MCP server instance.
logger = get_logger(__name__)
mcp = FastMCP("filesystem")

We use the FastMCP class (thanks to the official MCP docs) to handle the heavy lifting of server setup.

Next, we define our server methods. For example, here's how you can create a simple file reader using the @mcp.tool() decorator. This tells your agent, "Hey, this is an MCP tool you can use!"

Defining Server Methods

These methods specify actions our agent (or client) can request from the server. They abstract the logic behind each operation, enabling our server to know precisely when and how to execute each function based on client requests.

read_file: Reads the content of a given file.
list_directory: Lists the contents of a specified directory.

we define the read_file method clearly and simply, using the @mcp.tool() decorator so our agent recognizes it as an MCP tool.

@mcp.tool()
async def read_file(file_path: str) -> str:
    r"""Reads the content of the file at the given file path.

    Args:
        file_path (str): The path to the file.

    Returns:
        str: The file content or an error message if reading fails.
    """
    logger.info(f"read_file triggered with file_path: {file_path}")
    try:
        with open(file_path, "r", encoding="utf-8") as f:
            content = f.read()
        return content.rstrip()  # Remove trailing whitespace.
    except Exception as e:
        return f"Error reading file '{file_path}': {e}" # exceptions

# Attach an input schema for better agent understanding.
read_file.inputSchema = {
    "type": "object",
    "properties": {
         "file_path": {
             "type": "string",
             "title": "File Path",
             "description": "The path to the file to read. Default is 'README.md'."
         }
    },
    "required": ["file_path"]
}

Similarly, the list_directory method is defined clearly to list directory contents:

@mcp.tool()
async def list_directory(directory_path: str) -> str:
    r"""Lists the contents of the specified directory.

    Args:
        directory_path (str): The directory to list.

    Returns:
        str: A newline-separated list of directory entries or an error message.
    """
    logger.info(f"list_directory triggered with directory_path: {directory_path}")
    try:
        entries = os.listdir(directory_path) # enter the directory path
        return "\n".join(entry.rstrip() for entry in entries)
    except Exception as e:
        return f"Error listing directory '{directory_path}': {e}"

# Attach an input schema for better agent understanding.
list_directory.inputSchema = {
    "type": "object",
    "properties": {
         "directory_path": {
             "type": "string",
             "title": "Directory Path",
             "description": "The directory to list. Default is '.'."
         }
    },
    "required": ["directory_path"]
}

With our tools and logic in place, it's time to fire up the server! We'll write a main function that lets you choose between running it in standard I/O mode or using Server-Sent Events (SSE). Pick your mode, run the script, and watch your MCP server come to life.

def main(transport: str = "stdio"):
    r"""Runs the Filesystem MCP Server.

    Args:
        transport (str): The transport mode ('stdio' or 'sse').
    """
    if transport == 'stdio': # standard input output
        mcp.run(transport='stdio')
    elif transport == 'sse': # sse
        mcp.run(transport='sse')
    else:
        print(f"Unknown transport mode: {transport}")

if __name__ == "__main__":
    import sys
    transport_mode = sys.argv[1] if len(sys.argv) > 1 else "stdio"
    main(transport_mode) # runn in the defined transport mode

Once we have written all the logic we can now save this file as filesystem_server.py as we will later use this with our CAMEL agent.

Integrating with CAMEL AI's ChatAgent

Now that our MCP server is up and running, let's explore how CAMEL AI can transform a basic LLM into a smart, interactive agent by connecting it to our MCP server.

In this part, you'll see just how easy it is to integrate external tools with your agent.

If you're curious about more advanced setups, check out my previous post: Building cool agents with CAMEL AI

Dealing with Imports

To set up our chat agent client, we'll start by handling the necessary imports. Modules like ModelFactory offer extensive configurations for different Large Language Model (LLM) vendors. The _MCPServer class in CAMEL assists in setting up our MCP server.

import asyncio # Manages asynchronous operations
import os # Provide interaction with the operating system.
import sys
from pathlib import Path
from dotenv import load_dotenv # for api keys

from camel.agents import ChatAgent # creates Agents
from camel.models import ModelFactory # encapsulates LLM
from camel.toolkits import MCPToolkit # import tools
from camel.types import ModelPlatformType
from camel.toolkits.mcp_toolkit import _MCPServer # camel class for mcp clients

load_dotenv()

To enhance the usability of our MCP server, we can implement an interactive command-line interface (CLI) that allows users to seamlessly choose between various functionalities, such as reading a file or listing directory contents.

This approach makes our agent more user-friendly and streamlined.

Implementing the Interactive Input Loop

We'll define an asynchronous function, interactive_input_loop, which makes user interact through the command line.

async def interactive_input_loop(agent: ChatAgent):
    loop = asyncio.get_event_loop()
    print("\nEntering interactive mode. Type 'exit' at any prompt to quit.")

    while True: # the loop
        choice = await loop.run_in_executor(
            None,
            input,
            "\nChoose an action:\n"
            "1. Read a file\n"
            "2. List a directory\nYour choice (1/2): "
        )
        choice = choice.strip().lower() 
        if choice == "exit": # if exit then end loop
            print("Exiting interactive mode.")
            break

        if choice == "1": # if choice is 1 then read the file
            file_path = await loop.run_in_executor(
                None,
                input,
                "Enter the file path (default: README.md): "
            )
            file_path = file_path.strip() or "README.md"
            query = f"Use the read_file tool to display the content of {file_path}. Do not generate an answer from your internal knowledge."
        elif choice == "2":
            dir_path = await loop.run_in_executor(
                None,
                input,
                "Enter the directory path (default: .): "
            )
            dir_path = dir_path.strip() or "." # either this or current dir
            query = f"Call the list_directory tool to show me all files in {dir_path}. Do not answer directly."
        else:
            print("Invalid choice. Please enter 1 or 2.")
            continue

        response = await agent.astep(query) 
        print(f"\nYour Query: {query}") # prinitng the output
        print("Full Agent Response:")
        print(response.info)
        if response.msgs and response.msgs[0].content:
            print("Agent Output:")
            print(response.msgs[0].content.rstrip()) # paste the content displayed by the agent
        else:
            print("No output received.")

We begin by obtaining the current event loop using the asyncio.get_event_loop() function, which manages asynchronous tasks within our function.

Entering interactive mode, users are informed they can type 'exit' at any prompt to quit. A continuous while True loop then prompts users for input until they decide to exit.

Within this loop, users are presented with a menu of actions:

Read a File: The user is prompted for the file path, a query is constructed to use the read_file tool, and this query is then sent to the agent.
List a Directory: The user is prompted for the directory path, a query is constructed to use the list_directory tool, default being the current directory.

After executing the desired action, the agent's response is displayed, including any output or error messages.

The main( ) function and agent building with CAMEL

To set up our client, we begin by defining the main function, which determines whether to use:

Standard input/output (stdio) or
Server-Sent Events (SSE)

as the transport method.

This function also specifies the location of our server file, filesystem.py.

Working of our CAMEL-MCP system

We then define our system message, wrap our large language model (LLM) with ModelFactory, create an agent by binding tools with ChatAgent, and start the loop with our MCP filesystem server.

async def main(server_transport: str = 'stdio'):
    if server_transport == 'stdio':
        server_script_path = Path(__file__).resolve().parent / "filesystem_server_mcp.py"
        if not server_script_path.is_file():
            print(f"Error: Server script not found at {server_script_path}")
            return
        server = _MCPServer(
            command_or_url=sys.executable,
            args=[str(server_script_path)]
        )
        mcp_toolkit = MCPToolkit(servers=[server]) # camels toolkit to define mcp tools
    else:
        mcp_toolkit = MCPToolkit("tcp://localhost:5000")

    async with mcp_toolkit.connection() as toolkit:
        tools = toolkit.get_tools()
        sys_msg = (
            "You are a helpful assistant. Always use the provided external tools for filesystem operations "
            "Also remember to use the tools to answer questions about the filesystem. Always use the tools "
            "Make sure to keep the messages short and to the point so that tokens are not wasted. "
            "when asked, rather than relying on your internal knowledge. Ensure that your final answer does not "
            "end with any trailing whitespace."
        )
        model = ModelFactory.create( # define the LLM to create agent 
            model_platform=ModelPlatformType.ANTHROPIC,
            model_type="claude-3-7-sonnet-20250219",
            api_key=os.getenv("ANTHROPIC_API_KEY"),
            model_config_dict={"temperature": 0.8, "max_tokens": 4096},
        )
        camel_agent = ChatAgent( # create agent with our mcp tools
            system_message=sys_msg,
            model=model,
            tools=tools,
        )
        camel_agent.reset() # reset after each loop
        camel_agent.memory.clear()
        await interactive_input_loop(camel_agent) # start the interactive loop

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

Server Transport Method: The main function accepts a server_transport parameter to choose between 'stdio' and 'sse' modes. Based on this choice, it sets up the appropriate server connection.
System Message: guides the assistant's behavior, emphasizing the use of external tools for filesystem operations and ensuring responses are token-efficient.
Model Initialization: We use the ModelFactory class to initialise the LLM with specified parameters, including the model platform, type, API key, and configuration settings.
Chat Agent Creation: The ChatAgent binds the system message, model, and tools, creating an agent capable of interacting with the filesystem through the defined tools.
Interactive Input Loop: The script enters an interactive loop, allowing users to input commands that the agent processes using the filesystem server.

And now we have our Agent MCP ready !

We can expect output like :

Entering interactive mode. Type 'exit' at any prompt to quit.

Choose an action (or press Enter for default):
1. Read a file
2. List a directory
Your choice (1/2): 1

Enter file path to read (default: README.md): 
/home/xyz/Downloads/camel/CONTRIBUTING.md

2025-03-15 13:01:17,879 - WARNING - Token limit reached (5801 > 4096). 
Some messages will be pruned from memory.

Your Query: Use the read_file tool to display the content of 
/home/xyz/Downloads/camel/CONTRIBUTING.md. Do not generate an answer from your internal knowledge.

Full Agent Response:
{
  'id': None,
  'usage': None,
  'termination_reasons': ['max_tokens_exceeded'],
  'num_tokens': 5739,
  'tool_calls': [
    ToolCallingRecord(
      tool_name='read_file', 
      args={'file_path': '/home/xyz/Downloads/camel/CONTRIBUTING.md'}, 
      result='🐫 **Welcome to CAMEL!** 🐫\n\nThank you 
                for your interest in contributing to the CAMEL project! 
                🎉 We\re excited to have your support.
                 As an open-source initiative in a rapidly evolving 
                and open-ended field, we wholeheartedly welcome contributions of all kinds. Whether you want to introduce new features, enhance the infrastructure, improve documentation, asking issues, add more examples, implement state-of-the-art research ideas, or fix bugs, we appreciate your enthusiasm and efforts. 🙌  You are welcome to join our [discord](https://discord.camel-ai.org/) for more efficient communication. 💬\n\n## Join Our Community 🌍\n\n### Schedule an Introduction Call 📞 \n- English speakers: [here](https://calendly.com/roman-georgio/camel-ai-introduction-call?month=2024-05)\n- Chinese speakers: [here](https://calendly.com/sisi-qu/welcome-to-camel-onboarding-meeting?month=2024-05)'
    )
  ],
  'external_tool_call_request': None
}


Choose an action:
1. Read a file
2. List a directory
Your choice (1/2): exit
Exiting interactive mode.

And now my agent can directly interact with my file system and perform a lot of tasks!

Conclusion

Integrating LLMs with MCP servers via CAMEL AI bridges the gap between AI reasoning and practical application. This connection allows your AI to perform tasks like file management and directory navigation securely.

Building an MCP server with CAMEL AI isn't just about learning a new technology — it's about transforming how your AI interacts with the real world. Now that you've seen how straightforward it can be to set up your own MCP server, why not give it a try?

Try setting up your own MCP server today and share your experience in the comments!

You can take a look at the github repo for more servers — here

CAMEL AI repo — here