MCP Server Implementation

A complete Flask-based implementation of Model Context Protocol (MCP) for enhancing Large Language Model capabilities with external tools.

Overview

This repository demonstrates how to build a server that handles Model Context Protocol (MCP), a method for extending LLM capabilities through tool invocation directly in the model's text output. Unlike function calling, MCP places tool definitions directly in the context window and parses the model's natural language responses to identify tool usage.

Features

• 🔧 Complete MCP Implementation: Full parsing, execution, and response handling
• 🌤️ Sample Tools: Weather and calculator tools with parameter validation
• 🔄 Conversation Flow: Maintains context across multiple interactions
• 🧩 Regex-Based Parsing: Flexible text parsing for tool invocations
• 🚀 Flask API: REST API endpoints for chat integration

Project Structure

Installation

1. Clone the repository:
   git clone https://github.com/yourusername/mcp-server.git cd mcp-server
2. Create a virtual environment:
   python -m venv venv source venv/bin/activate # On Windows: venv\Scripts\activate
3. Install dependencies:
   pip install -r requirements.txt
4. Set up environment variables:
   # Create a .env file with: LLM_API_KEY=your_llm_api_key_here WEATHER_API_KEY=your_weather_api_key_here FLASK_APP=app.py FLASK_ENV=development

Usage

Running the Server

Start the Flask development server:

For production:

API Endpoints

• POST /chat: Process chat messages with MCP
  curl -X POST http://localhost:5000/chat \ -H "Content-Type: application/json" \ -d '{ "messages": [ { "role": "user", "content": "What's the weather like in Boston?" } ] }'

Standalone Example

Run the example script to see MCP in action:

How It Works

1. Tool Registration: Tools are registered with their parameters and execution logic
2. Tool Definition Injection: XML-formatted tool descriptions are added to the prompt
3. LLM Response Processing: Regex patterns identify tool calls in the LLM's text output
4. Tool Execution: Parameters are parsed and passed to appropriate tool handlers
5. Result Injection: Tool execution results are inserted back into the response

MCP vs. Function Calling

Example Conversation

User: What's the weather like in Boston?

LLM:

After Processing:

Adding Your Own Tools

1. Create a new class inheriting from Tool
2. Define parameters and execution logic
3. Register with the MCP handler

Example:

MCP Configuration and Invocation Flow

1. Tool Registration:
   • MCP tools are registered with the handler
   • Each tool provides its name, description, and parameter definitions
2. Tool Definition Injection:
   • Tool definitions are added to the system message
   • Format follows XML structure for MCP
3. LLM Response Processing:
   • LLM generates responses that may include tool invocations
   • Pattern matching identifies tool calls in the text
   • Tool parameters are parsed and passed to tool execution methods
4. Tool Execution:
   • Tools are executed with the provided parameters
   • Results are injected back into the conversation
5. Conversation Management:
   • Processed responses with tool results are added to conversation history
   • Future LLM requests include this history for context

Example Conversation

Here's an example of what a conversation might look like:

User: What's the weather like in Boston?

System: Sends prompt with MCP tool definitions to LLM

LLM Response:

MCP Handler: Parses the response, finds the tool call, and executes the weather tool

Tool Execution Result:

Processed Response (sent back to user):

User: Can you calculate the square root of 144?

LLM Response:

MCP Handler: Parses response, executes calculator tool

Tool Execution Result:

Processed Response (sent back to user):

This demonstrates the complete flow of MCP tool usage, from the LLM's text-based invocation through execution and response processing.

License

MIT

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.