Model Context Protocol (MCP): Building AI-Powered Full-Stack Environments

MCP Basics: How It Works

To effectively use Model Context Protocol in your projects, it's important to understand the fundamental architecture and how the various components interact. In this section, we'll dive into the core concepts behind MCP and explore its underlying structure.

Client-Server Architecture

MCP follows a client-server architecture where:

• Clients: AI models (e.g., Claude, GPT) that need to access external capabilities
• Servers: Specialized programs that provide specific functionalities and expose them via the standardized MCP interface

The communication between clients and servers follows a well-defined protocol that makes it easy for any compliant client to interact with any MCP server, regardless of which company or developer created them.

// Simplified example of MCP client-server interaction
const mcpClient = new MCPClient();  // AI model as client

// Connect to a filesystem MCP server
const filesystemServer = await mcpClient.connect("filesystem", {
  path: "/path/to/directory"
});

// Request a list of files
const filesList = await filesystemServer.listFiles();

// AI can now use the file list in its reasoning

Standardized Interfaces

One of the most powerful aspects of MCP is its standardization. By defining common interfaces, it enables:

This standardization is similar to how USB revolutionized computer peripherals—rather than needing different ports for each device type, one standard supports countless types of hardware. Similarly, MCP provides a "universal port" for AI models to access external capabilities.

MCP Structure and Protocol

At a technical level, MCP defines:

• Request Format: How clients make requests to servers
• Response Format: How servers return results to clients
• Server Discovery: How clients find available MCP servers
• Authentication: How servers verify client permissions
• Error Handling: How errors are communicated and managed

The actual protocol uses a simple JSON-based format for requests and responses, making it easy to implement in any programming language.

{
  "type": "request",
  "id": "req-123",
  "server_name": "filesystem",
  "method": "list_files",
  "params": {
    "path": "/documents",
    "recursive": false
  }
}

// Response from server
{
  "type": "response",
  "id": "req-123",
  "result": {
    "files": [
      {"name": "document1.txt", "size": 1024, "type": "file"},
      {"name": "document2.txt", "size": 2048, "type": "file"},
      {"name": "images", "type": "directory"}
    ]
  }
}

MCPX: The Extensible MCP Server

Anthropic has developed MCPX, an extensible MCP server that serves as a foundation for the ecosystem. MCPX allows developers to load "servlets"—modular components that provide specific functionalities—making it easy to combine multiple capabilities into a single MCP server instance.

# Install MCPX
npm install -g @modelcontextprotocol/mcpx

# Run MCPX with filesystem and github servlets
mcpx --load @modelcontextprotocol/servlet-filesystem:/documents \
     --load @modelcontextprotocol/servlet-github

This modular approach makes MCPX highly flexible and allows developers to customize their MCP environment based on specific needs.

The MCP Ecosystem

One of the most exciting aspects of MCP is the rapidly growing ecosystem of servers, tools, and resources. Since its introduction, the community has embraced the protocol and developed hundreds of servers for various purposes.

Community & Growth

The MCP ecosystem has experienced remarkable growth, with several factors driving its rapid adoption:

• Open-Source Foundation: The core protocol is open-source, encouraging community participation
• Practical Utility: MCP solves real problems for developers working with AI
• Ease of Implementation: Creating basic MCP servers is straightforward
• Industry Support: Major AI companies have embraced the standard

This combination of factors has led to a thriving ecosystem with contributions from individual developers, startups, and established companies alike.

Finding MCP Servers: Directories & Resources

With hundreds of MCP servers available, finding the right ones for your project can be challenging. Fortunately, several community-maintained directories have emerged to catalog and organize available servers:

These directories not only help you find existing MCP servers but also provide valuable insights into best practices, popular use cases, and emerging trends in the ecosystem.

Community Engagement

Engaging with the MCP community can significantly enhance your development experience. Several active communities discuss MCP development, share resources, and provide support:

• Reddit: r/LLMDevs has a dedicated MCP discussion thread
• Discord: Official MCP Discord server with dedicated channels for different aspects of MCP development
• X/Twitter: Follow #MCPdev for the latest updates and discussions
• GitHub Discussions: The official MCP repository hosts technical discussions

Essential MCP Servers

With hundreds of MCP servers available, it can be overwhelming to determine which ones to use for your projects. In this section, we'll explore some of the most popular and useful MCP servers available today, focusing on their capabilities, use cases, and how to incorporate them into your workflows.

Filesystem MCP

The Filesystem MCP server is one of the most fundamental and widely used servers in the ecosystem. It gives AI models the ability to navigate, read, write, and organize files on your local system.

Installing and running the Filesystem MCP server is straightforward:

# Install the Filesystem MCP server
npx -y @modelcontextprotocol/server-filesystem /path/to/directory

# Or using MCPX with the filesystem servlet
mcpx --load @modelcontextprotocol/servlet-filesystem:/path/to/directory

Use cases for the Filesystem MCP include:

• Organizing and categorizing files based on content
• Processing multiple text files for analysis
• Managing project directories and documentation
• Extracting information from structured files

GitHub MCP

The GitHub MCP server provides a bridge between AI models and the GitHub platform, allowing models to interact with repositories, issues, pull requests, and other GitHub resources.

To use the GitHub MCP server, you'll need a GitHub personal access token with the appropriate permissions:

# Set up your GitHub token securely
export GITHUB_TOKEN=your_github_token

# Install and run the GitHub MCP server
npx -y @modelcontextprotocol/server-github

Typical use cases for the GitHub MCP include:

• Automating repository creation and configuration
• Generating documentation directly in repositories
• Managing issues and tracking project progress
• Assisting with code reviews and pull request management

Slack MCP

The Slack MCP server enables AI models to interact with Slack workspaces, including reading messages, posting updates, and managing channels.

Setting up the Slack MCP server requires a Slack bot token:

# Set up your Slack token securely
export SLACK_BOT_TOKEN=xoxb-your-token-here

# Install and run the Slack MCP server
npx -y @modelcontextprotocol/server-slack

Common use cases for the Slack MCP include:

• Creating an AI assistant that works within your Slack workspace
• Automating notifications and updates
• Generating reports and sharing them directly in relevant channels
• Managing team coordination and communication

Database MCPs

Various Database MCP servers enable AI models to interact with different database systems, from simple in-memory databases to complex SQL and NoSQL solutions.

Example of setting up the DuckDB MCP server:

# Install and run the DuckDB MCP server
npx -y @modelcontextprotocol/server-duckdb /path/to/data.db

Database MCPs are particularly useful for:

• Natural language queries on structured data
• Generating reports and visualizations
• Data analysis and exploration
• Managing application data through AI interfaces

Browser MCPs

Browser MCPs provide AI models with the ability to interact with web pages, either through direct navigation and content extraction or through browser automation.

Many Browser MCPs are built on top of headless browser technologies like Puppeteer:

# Install and run a Puppeteer-based Browser MCP
npx -y @modelcontextprotocol/server-browser

Browser MCPs enable use cases such as:

• Web research and information gathering
• Web testing and validation
• Content extraction and summarization
• Automated web workflows and form submission

Other Notable MCP Servers

Beyond these core MCP servers, the ecosystem includes many specialized servers for specific domains and applications:

• AWS MCP: Manage AWS resources and services
• Spotify MCP: Control music playback and playlists
• Google Drive MCP: Access and manage cloud documents
• YouTube MCP: Search, analyze, and download YouTube content
• Weather MCP: Access real-time weather data
• Calendar MCP: Manage appointments and schedules

Building a Full-Stack AI Environment

Individual MCP servers are powerful on their own, but the true potential of MCP emerges when you combine multiple servers into a cohesive full-stack environment. This integration allows AI models to interact seamlessly with various components of your technical infrastructure, from databases to user interfaces.

Figure 2: Architecture of a full-stack AI environment powered by MCP

Architecture Overview

A typical full-stack AI environment with MCP consists of several layers:

This layered architecture allows for separation of concerns, making your system more maintainable and allowing for independent scaling of different components.

Required Tools for a Full-Stack Environment

Building a comprehensive AI-powered full-stack environment with MCP typically involves the following tools and technologies:

1. MCPX (Extensible MCP Server)

MCPX serves as the foundation for your MCP layer, allowing you to load multiple servlets that provide specialized functionalities. It offers a unified interface for your AI model to access these capabilities.

# Install MCPX globally
npm install -g @modelcontextprotocol/mcpx

# Run MCPX with multiple servlets
mcpx --load @modelcontextprotocol/servlet-filesystem:/data \
     --load @modelcontextprotocol/servlet-github \
     --load @modelcontextprotocol/servlet-duckdb:/data/analytics.db \
     --load @modelcontextprotocol/servlet-browser

2. Backend Framework

Choose a backend framework that integrates well with both MCP and your preferred programming language. Popular choices include:

• Node.js with Express: Great for JavaScript developers with extensive package ecosystem
• Flask/FastAPI (Python): Excellent for data science and ML-heavy applications
• LangChain/LangGraph: Specialized frameworks for AI agent workflows

// Example of a simple Express backend with MCP integration
const express = require('express');
const { MCPClient } = require('@modelcontextprotocol/client');

const app = express();
app.use(express.json());

// Initialize MCP client
const mcpClient = new MCPClient();

app.post('/ai/query', async (req, res) => {
  try {
    // Connect to AI model (e.g., Claude API)
    const aiResponse = await queryAI(req.body.prompt);
    
    // If AI needs to access files
    if (aiResponse.needsFileAccess) {
      // Connect to Filesystem MCP
      const filesystemServer = await mcpClient.connect("filesystem", {
        path: "/data"
      });
      
      // Get file data
      const fileData = await filesystemServer.readFile(aiResponse.filePath);
      
      // Send file data back to AI for processing
      const finalResponse = await queryAI(req.body.prompt, fileData);
      res.json({ response: finalResponse });
    } else {
      res.json({ response: aiResponse });
    }
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

3. Database Integration

Depending on your application's needs, you may require various database systems. MCP servers can provide AI models with access to these databases, but your backend will also need direct connections for efficient operations.

4. Frontend Technologies

The user interface for your AI-powered application can take many forms, depending on your target audience and use case:

• Web Applications: React, Vue.js, or Angular for interactive web interfaces
• Mobile Applications: React Native or native apps for on-the-go access
• CLI Tools: Command-line interfaces for developer-focused applications
• Embedded UIs: Integration into existing software like IDEs or productivity tools

5. Deployment & DevOps

For a production-ready full-stack AI environment, consider these deployment and operational tools:

• Docker: Container platform for consistent environments and easier deployment
• Kubernetes: Container orchestration for scaling and managing distributed applications
• Cloud Platforms: AWS, GCP, or Azure for hosting and managed services
• CI/CD: GitHub Actions, Jenkins, or GitLab CI for automated testing and deployment
• Monitoring: Prometheus, Grafana, or cloud-native monitoring solutions

Real-World Architecture Example

Here's an example of how a real-world AI application might leverage MCP in a full-stack environment:

Implementation Guide: Building Your First MCP Project

Now that we understand the concepts and components of MCP, let's put this knowledge into practice by building a simple but functional MCP-powered project. This step-by-step guide will walk you through setting up MCPX, adding servlets, and integrating them with a backend application.

Setting Up MCPX

The first step is to set up MCPX, Anthropic's extensible MCP server that will serve as the foundation for our project:

# Install Node.js and npm if you haven't already
# On macOS/Linux:
# curl -fsSL https://deb.nodesource.com/setup_16.x | sudo -E bash -
# sudo apt-get install -y nodejs

# On Windows (with Chocolatey):
# choco install nodejs

# Verify installation
node --version
npm --version

# Install MCPX globally
npm install -g @modelcontextprotocol/mcpx

# Verify installation
mcpx --version

After installation, you can run MCPX without any servlets to verify it's working correctly:

# Run MCPX with default settings
mcpx

# You should see output similar to:
# MCPX server started on port 8000
# No servlets loaded

Adding Servlets to MCPX

MCPX becomes powerful when you add servlets—modular components that provide specific functionalities. Let's add some common servlets:

# Install Filesystem servlet
npm install -g @modelcontextprotocol/servlet-filesystem

# Install GitHub servlet
npm install -g @modelcontextprotocol/servlet-github

# Create a project directory
mkdir mcp-project
cd mcp-project

# Create a data directory for the Filesystem servlet
mkdir data

# Create a configuration file
touch mcpx-config.json

Now, let's create a configuration file for MCPX that specifies which servlets to load and how to configure them:

{
  "port": 8000,
  "host": "localhost",
  "servlets": [
    {
      "name": "@modelcontextprotocol/servlet-filesystem",
      "config": {
        "path": "./data",
        "readOnly": false
      }
    },
    {
      "name": "@modelcontextprotocol/servlet-github",
      "config": {
        "token": "${GITHUB_TOKEN}"
      }
    }
  ],
  "logging": {
    "level": "info"
  }
}

With this configuration file, you can start MCPX with all the specified servlets:

# Set GitHub token as an environment variable
export GITHUB_TOKEN=your_github_token

# Start MCPX with the configuration file
mcpx --config mcpx-config.json

Backend Integration

Now that we have MCPX running with servlets, let's create a simple backend application that integrates with it. We'll use Node.js with Express for this example:

# Initialize a new Node.js project
npm init -y

# Install required dependencies
npm install express axios anthropic dotenv cors

Create a .env file to store sensitive configuration:

# .env file
ANTHROPIC_API_KEY=your_anthropic_api_key
MCP_SERVER_URL=http://localhost:8000

Now, let's create a simple Express server that connects to Claude and uses MCP to access files:

// app.js
require('dotenv').config();
const express = require('express');
const axios = require('axios');
const cors = require('cors');
const { Anthropic } = require('@anthropic-ai/sdk');

const app = express();
const port = 3000;

// Middleware
app.use(cors());
app.use(express.json());

// Initialize Anthropic client
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// MCP client for communicating with the MCP server
const mcpClient = {
  async callMcpServer(serverName, method, params) {
    try {
      const response = await axios.post(`${process.env.MCP_SERVER_URL}/mcp`, {
        server_name: serverName,
        method: method,
        params: params
      });
      return response.data.result;
    } catch (error) {
      console.error('MCP error:', error.response?.data || error.message);
      throw new Error(`MCP server error: ${error.message}`);
    }
  }
};

// API endpoint for handling AI requests
app.post('/api/ask', async (req, res) => {
  try {
    const { prompt } = req.body;
    
    // Call Claude API with the prompt
    const message = await anthropic.messages.create({
      model: 'claude-3-sonnet-20240229',
      max_tokens: 1000,
      messages: [
        { role: 'user', content: prompt }
      ],
      temperature: 0.7
    });
    
    // Extract the response content
    const aiResponse = message.content[0].text;
    
    // Check if the response contains file access requests
    if (aiResponse.includes('[FILE_REQUEST]')) {
      // Extract the file path
      const filePath = extractFilePath(aiResponse);
      
      // Use MCP to access the file
      const fileContent = await mcpClient.callMcpServer('filesystem', 'readFile', {
        path: filePath
      });
      
      // Send the file content back to Claude for further processing
      const followupMessage = await anthropic.messages.create({
        model: 'claude-3-sonnet-20240229',
        max_tokens: 1000,
        messages: [
          { role: 'user', content: prompt },
          { role: 'assistant', content: aiResponse },
          { role: 'user', content: `Here's the file content: ${fileContent}` }
        ],
        temperature: 0.7
      });
      
      res.json({ response: followupMessage.content[0].text });
    } else {
      res.json({ response: aiResponse });
    }
  } catch (error) {
    console.error('Error:', error);
    res.status(500).json({ error: error.message });
  }
});

// Helper function to extract file path from AI response
function extractFilePath(response) {
  // Simple regex to extract file path between specific tags
  const match = response.match(/\[FILE_REQUEST\](.*?)\[\/FILE_REQUEST\]/);
  return match ? match[1].trim() : null;
}

// Start the server
app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

This backend handles requests from a frontend application, forwards them to Claude, and uses MCP to access files when needed. It's a simple but powerful integration that demonstrates how MCP can be used in a real-world application.

Deployment Options

There are several options for deploying your MCP-powered application, depending on your needs and resources:

1. Docker Deployment

Docker provides an easy way to package and deploy your application, including MCPX and its servlets:

# Dockerfile
FROM node:16-alpine

WORKDIR /app

# Install MCPX and servlets
RUN npm install -g @modelcontextprotocol/mcpx \
    @modelcontextprotocol/servlet-filesystem \
    @modelcontextprotocol/servlet-github

# Copy application files
COPY package*.json ./
RUN npm install
COPY . .

# Expose ports
EXPOSE 3000
EXPOSE 8000

# Create a script to start both the Node.js app and MCPX
RUN echo '#!/bin/sh\n\
mcpx --config mcpx-config.json &\n\
node app.js\n' > start.sh && chmod +x start.sh

# Start both services
CMD ["./start.sh"]

# docker-compose.yml
version: '3'
services:
  mcp-app:
    build: .
    ports:
      - "3000:3000"
      - "8000:8000"
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - GITHUB_TOKEN=${GITHUB_TOKEN}
      - MCP_SERVER_URL=http://localhost:8000
    volumes:
      - ./data:/app/data

2. Serverless Deployment

For certain MCP scenarios, you can use serverless architectures, especially if your MCP usage is occasional:

3. Cloud VPS Deployment

For applications that need to run continuously, a cloud Virtual Private Server (VPS) is often the best option:

# Example setup script for Ubuntu VPS
#!/bin/bash

# Update system packages
apt update
apt upgrade -y

# Install Node.js
curl -fsSL https://deb.nodesource.com/setup_16.x | sudo -E bash -
apt-get install -y nodejs

# Install PM2 for process management
npm install -g pm2

# Install MCPX and servlets
npm install -g @modelcontextprotocol/mcpx
npm install -g @modelcontextprotocol/servlet-filesystem
npm install -g @modelcontextprotocol/servlet-github

# Clone your application repository
git clone https://github.com/yourusername/mcp-project.git
cd mcp-project

# Install dependencies
npm install

# Create systemd service for MCPX
cat > /etc/systemd/system/mcpx.service << EOL
[Unit]
Description=MCPX Server
After=network.target

[Service]
User=ubuntu
WorkingDirectory=/home/ubuntu/mcp-project
ExecStart=/usr/bin/mcpx --config mcpx-config.json
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOL

# Enable and start the MCPX service
systemctl enable mcpx.service
systemctl start mcpx.service

# Start the Node.js application with PM2
cd /home/ubuntu/mcp-project
pm2 start app.js
pm2 save
pm2 startup

Security & Best Practices

MCP servers provide AI models with powerful capabilities to interact with your systems and data. With this power comes significant security considerations. This section explores the key security concerns and best practices for working with MCP safely and effectively.

Security Concerns

When implementing MCP in your projects, be aware of these important security considerations:

The fundamental security principle to remember is that MCP servers extend the capabilities of AI models. It's crucial to:

• Only use MCP with trusted, secure AI models
• Be aware of the potential for prompt injection attacks
• Implement content filtering and sanitization as needed
• Consider using separate MCP setups for different security contexts

Sandboxing MCP Servers

One of the most effective ways to mitigate MCP security risks is to run servers in isolated environments, or "sandboxes." Here are several approaches to sandboxing MCP servers:

1. Docker Containers

Docker provides lightweight isolation and is one of the most common sandboxing approaches:

# Run MCPX in a Docker container with limited permissions
docker run --name mcpx-sandbox \
  --rm \
  -p 8000:8000 \
  -v $(pwd)/data:/app/data:ro \
  -u 1000:1000 \
  --cap-drop=ALL \
  --security-opt no-new-privileges \
  mcpx-image

2. Restricted User Accounts

Run MCP servers under dedicated user accounts with minimal permissions:

# Create a dedicated user for running MCP servers
sudo useradd -r -s /bin/false -m -d /opt/mcp-user mcp-user

# Set up directory with appropriate permissions
sudo mkdir -p /opt/mcp-data
sudo chown mcp-user:mcp-user /opt/mcp-data

# Run MCPX as the restricted user
sudo -u mcp-user mcpx --config /etc/mcpx/config.json

3. Virtual Machines

For higher security requirements, consider running MCP servers in separate virtual machines:

Security Best Practices

In addition to sandboxing, follow these security best practices when working with MCP:

1. Principle of Least Privilege

Always provide MCP servers with the minimum permissions necessary:

• Use read-only access when write capabilities aren't needed
• Restrict filesystem access to specific directories
• Use scoped API tokens with minimal permissions
• Regularly audit and remove unnecessary permissions

{
  "servlets": [
    {
      "name": "@modelcontextprotocol/servlet-filesystem",
      "config": {
        "path": "/data",
        "readOnly": true,
        "allowedExtensions": [".txt", ".md", ".json"],
        "disallowPatterns": ["**/secrets/**", "**/.env*"]
      }
    }
  ]
}

2. Secure Credential Management

Protect API keys and other sensitive credentials:

• Use environment variables instead of hardcoding credentials
• Consider a secrets management solution (HashiCorp Vault, AWS Secrets Manager, etc.)
• Implement token rotation for long-running applications
• Use scoped tokens that expire after a reasonable time

3. Network Security

Secure network communications for MCP servers:

• Bind MCP servers to localhost by default
• Use HTTPS/TLS for all communications
• Implement access control mechanisms (API keys, JWT tokens, etc.)
• Set up a reverse proxy with proper security headers
• Use firewalls to restrict access to MCP server ports

# Example NGINX configuration for securing MCP server
server {
    listen 443 ssl;
    server_name mcp.example.com;

    ssl_certificate /etc/letsencrypt/live/mcp.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/mcp.example.com/privkey.pem;
    
    # Strong SSL settings
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
    
    # Security headers
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Content-Type-Options nosniff;
    add_header X-Frame-Options DENY;
    add_header X-XSS-Protection "1; mode=block";
    
    # Access control
    location / {
        auth_request /auth;
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
    
    # Authentication endpoint
    location = /auth {
        internal;
        proxy_pass http://localhost:8080/validate-token;
        proxy_pass_request_body off;
        proxy_set_header Content-Length "";
        proxy_set_header X-Original-URI $request_uri;
    }
}

4. Monitoring and Logging

Implement comprehensive monitoring and logging for security:

• Log all MCP server operations, especially file access and API calls
• Set up alerts for suspicious activities
• Regularly review logs for unusual patterns
• Implement rate limiting to prevent abuse
• Consider using a centralized logging system (ELK, Grafana, etc.)

5. Regular Updates and Audits

Maintain a secure environment through regular maintenance:

• Keep MCPX and all servlets updated to the latest versions
• Conduct regular security audits of your MCP setup
• Review the permissions and access controls periodically
• Stay informed about security updates and vulnerabilities

Ethical Considerations

Beyond security, consider the ethical implications of AI systems with extended capabilities:

• Ensure users understand when they're interacting with AI systems
• Be transparent about what data is being accessed and how it's used
• Consider privacy implications, especially when handling personal data
• Implement appropriate oversight for automated systems
• Design systems with "human in the loop" options for critical operations

Next Steps & Resources

Congratulations on completing this comprehensive guide to Model Context Protocol! You've learned about the fundamentals of MCP, explored the ecosystem, discovered essential MCP servers, and gained practical knowledge about building full-stack AI environments with MCP. Now, let's look at what you can do next to continue your journey.

Further Learning Resources

To deepen your understanding of MCP and related technologies, explore these valuable resources:

Project Ideas

Put your MCP knowledge into practice with these project ideas, ranging from beginner to advanced:

Building Your Own MCP Servers

Ready to contribute to the MCP ecosystem? Consider building your own custom MCP servers:

The MCP developer guide provides detailed information on creating custom MCP servers:

// Basic structure of a custom MCP server
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());

// Define server methods
const methods = {
  // Example method that echoes the input
  echo: async (params) => {
    return { message: params.message };
  },
  
  // Example method that performs a calculation
  calculate: async (params) => {
    const { operation, a, b } = params;
    let result;
    
    switch (operation) {
      case 'add':
        result = a + b;
        break;
      case 'subtract':
        result = a - b;
        break;
      case 'multiply':
        result = a * b;
        break;
      case 'divide':
        if (b === 0) throw new Error('Division by zero');
        result = a / b;
        break;
      default:
        throw new Error(`Unknown operation: ${operation}`);
    }
    
    return { result };
  }
};

// MCP endpoint handler
app.post('/mcp', async (req, res) => {
  try {
    const { id, method, params } = req.body;
    
    if (!methods[method]) {
      return res.status(400).json({
        type: 'error',
        id,
        error: {
          code: 'METHOD_NOT_FOUND',
          message: `Method '${method}' not found`
        }
      });
    }
    
    const result = await methods[method](params);
    
    res.json({
      type: 'response',
      id,
      result
    });
  } catch (error) {
    res.status(500).json({
      type: 'error',
      id: req.body.id,
      error: {
        code: 'INTERNAL_ERROR',
        message: error.message
      }
    });
  }
});

// Server info endpoint
app.get('/mcp', (req, res) => {
  res.json({
    name: 'custom-mcp-server',
    version: '1.0.0',
    methods: Object.keys(methods)
  });
});

// Start the server
const port = process.env.PORT || 8000;
app.listen(port, () => {
  console.log(`Custom MCP server running on port ${port}`);
});

Related Technologies to Explore

To enhance your MCP projects, consider exploring these related technologies:

• LangChain & LangGraph: Frameworks for building complex AI workflows
• Vector Databases: Tools like Pinecone, Weaviate, or Chroma for semantic search
• Fine-Tuning LLMs: Techniques for customizing language models for specific tasks
• Agent Orchestration: Systems for coordinating multiple AI agents
• Semantic Kernel: Microsoft's framework for AI orchestration

Conclusion

Model Context Protocol represents a significant advancement in AI integration, enabling AI models to interact with the world in powerful new ways. By standardizing the interface between AI models and external tools, MCP opens up countless possibilities for developers and users alike.

As you continue your journey with MCP, remember that we're still in the early days of this technology. Your contributions, feedback, and innovations can help shape the future of AI integration and unlock new capabilities for everyone.

Module Complete!

Mark as Complete Leave Feedback

Recommended Next Modules

Advanced AI Agent Techniques

Start Module

Building a Crypto Trading Bot

Start Module