Praison AI

MCP Servers

Learn how to create Model Context Protocol (MCP) servers with PraisonAI agents

Creating MCP Servers

This guide demonstrates how to create Model Context Protocol (MCP) servers using PraisonAI agents. MCP is a protocol that enables AI models to use tools and communicate with external systems in a standardized way.

Quick Start

python
from praisonaiagents import Agent

# Create and launch an MCP server in one line
agent = Agent(instructions="Create a Tweet based on the topic provided")
agent.launch(port=8080, protocol="mcp")

Your MCP server will be available at http://localhost:8080

Single Agent MCP Server

The simplest way to create an MCP server is with a single agent. This approach is ideal for specialized tasks where you need just one agent with a specific capability.

  1. Install Dependencies

    Make sure you have the required packages installed:

    bash
    pip install "praisonaiagents[mcp]>=0.0.81"
  2. Create a Simple MCP Server

    Create a file named simple-mcp-server.py with the following code:

    python
    from praisonaiagents import Agent

agent = Agent(instructions="Create a Tweet based on the topic provided")
agent.launch(port=8080, protocol="mcp")
  3. Run the Server
    bash
    python simple-mcp-server.py

    Your MCP server will be available at http://localhost:8080

Multi-Agent MCP Server with Custom Tools

For more complex scenarios, you can create an MCP server with multiple agents and custom tools. This approach allows for collaborative problem-solving and specialized capabilities.

  1. Install Additional Dependencies
    bash
    pip install "praisonaiagents[mcp]" duckduckgo-search
  2. Create a Multi-Agent MCP Server

    Create a file named simple-mcp-multi-agents-server.py with the following code:

    python
    from praisonaiagents import Agent, AgentTeam
from duckduckgo_search import DDGS

def internet_search_tool(query: str):
    results = []
    ddgs = DDGS()
    for result in ddgs.text(keywords=query, max_results=5):
        results.append({
            "title": result.get("title", ""),
            "url": result.get("href", ""),
            "snippet": result.get("body", "")
        })
    return results

agent = Agent(instructions="You Search the internet for information", tools=[internet_search_tool])
agent2 = Agent(instructions="You Summarise the information")

agents = AgentTeam(agents=[agent, agent2])
agents.launch(port=8080, protocol="mcp")
  3. Run the Multi-Agent Server
    bash
    python simple-mcp-multi-agents-server.py

    Your multi-agent MCP server will be available at http://localhost:8080

Multi-Agent MCP Server (Simple)

For scenarios where you need multiple agents to collaborate without custom tools, you can create a simpler multi-agent MCP server:

python
from praisonaiagents import Agent, AgentTeam

agent = Agent(instructions="You Search the internet for information")
agent2 = Agent(instructions="You Summarise the information")

agents = AgentTeam(agents=[agent, agent2])
agents.launch(port=8080, protocol="mcp")

This approach is ideal for cases where you want agents with different specializations to work together using their built-in capabilities.

Connecting to MCP Servers

You can connect to MCP servers using various clients:

Using PraisonAI Agents

python
from praisonaiagents import Agent, MCP

client_agent = Agent(
    instructions="Use the MCP server to complete tasks",
    llm="gpt-4o-mini",
    tools=MCP("http://localhost:8080/mcp")
)

response = client_agent.start("Create a tweet about artificial intelligence")
print(response)

Using JavaScript/TypeScript

typescript
import { MCPClient } from '@modelcontextprotocol/client';

async function main() {
  const client = new MCPClient('http://localhost:8080/mcp');

  const response = await client.chat([
    { role: 'user', content: 'Create a tweet about artificial intelligence' }
  ]);

  console.log(response.choices[0].message.content);
}

main();

Advanced Configuration

Custom Port and Host

python
agent.launch(port=9000, host="127.0.0.1", protocol="mcp")  # loopback default; set "0.0.0.0" to expose (requires a token)

Authentication

python
agent.launch(port=8080, protocol="mcp", api_key="your-secret-key")

CORS Configuration

python
agent.launch(port=8080, protocol="mcp", cors_origins=["https://yourdomain.com"])

Deployment Options

For production deployments, consider:

  1. Docker Containerization:
dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8080

CMD ["python", "simple-mcp-server.py"]
  1. Cloud Deployment: Deploy to AWS, Google Cloud, or Azure using their container services.
  1. Kubernetes: For scalable deployments, use Kubernetes to manage your MCP server containers.

Security Considerations

  1. API Authentication: Always use API keys in production
  2. Rate Limiting: Implement rate limiting to prevent abuse
  3. Input Validation: Validate all incoming requests
  4. HTTPS: Use SSL/TLS for all production deployments
  5. Tool Permissions: Limit what custom tools can access

Features and Benefits

Standardized Protocol

MCP provides a standardized way for AI models to interact with tools and services.

 Custom Tools

Easily integrate custom tools like web search, database access, or API calls.

 Multi-Agent Collaboration

Create systems where multiple specialized agents collaborate on complex tasks.

 Language Agnostic

Connect to MCP servers from any programming language that supports HTTP.

Best Practices

  1. Agent Instructions: Provide clear, specific instructions for each agent
  2. Tool Documentation: Document your custom tools thoroughly
  3. Error Handling: Implement robust error handling in your tools
  4. Monitoring: Set up logging and monitoring for your MCP servers
  5. Testing: Test your MCP servers thoroughly before deployment