Yisu201506 MCP Server

🚀 MCP Server Implementation Explanation

The MCP (Model Context Protocol) server is a project based on the Flask framework. Its aim is to enhance the capabilities of large language models, enabling them to interact with external tools. By injecting tool definitions into system messages and parsing and processing the LLM's responses, this protocol allows users to call tools in text form.

✨ Features

• Full MCP Implementation: Supports the complete process from tool registration to execution.
• Flask Interface: Provides a RESTful API for interacting with the server.
• Tool Definition Injection: Injects tool definitions into system messages in XML format.
• Regex-based Parsing: Can recognize tool calls in the LLM's responses and extract parameters.
• Tool Execution: Calls the corresponding tools based on the extracted parameters and processes the results.

📦 Project Structure

mcp_server/
├── server.py              # Flask application entry point
├── tools/                # Tool directory
│   ├── weather.py        # Weather query tool
│   └── calculator.py     # Calculator tool
└── config.py             # Configuration file

📦 Installation

Environment Requirements

• Python 3.6+
• pip

Install Dependencies

pip install flask

Initialize the Database (Optional)

If you need to use the database functionality, run:

python init_db.py

💻 Usage Examples

Start the Server

python server.py

It runs on http://localhost:5000 by default.

Call Tools

Weather Query Example

curl -X POST http://localhost:5000/api/weather \
  -H "Content-Type: application/json" \
  -d '{"location": "Boston, MA", "unit": "fahrenheit"}'

Calculator Example

curl -X POST http://localhost:5000/api/calculator \
  -H "Content-Type: application/json" \
  -d '{"expression": "sqrt(144)"}'

📚 Adding Custom Tools

Define a Tool Class

Create a new tool class, for example:

class CustomTool:
    def __init__(self, name):
        self.name = name

    def execute(self, param1):
        # Tool logic implementation
        return {"result": f"Processed {param1}"}

Register the Tool

Register the tool in server.py:

from tools.custom import CustomTool

# Register in the app route
@app.route('/api/custom', methods=['POST'])
def custom_tool():
    tool = CustomTool("custom")
    data = request.json
    result = tool.execute(data['param1'])
    return jsonify(result)

📚 MCP Configuration and Call Flow

Tool Registration

• Add tool definitions to system messages in XML standard format.

Tool Definition Injection

• Add the XML description of tools to the context of LLM requests, so that the model is aware of available tools.

LLM Response Processing

• Parse the LLM's response text, recognize tool call instructions, and extract parameters.

Tool Execution

• Call the corresponding tool methods based on the recognized tool names and parameters, and obtain the results.

Conversation Management

• Record the results of tool execution in the conversation history for subsequent requests to use context information.

📚 Example Conversation Flow

User: What's the weather like in Boston? System: Send a prompt containing MCP tool definitions to the LLM. LLM Response:

Let me check.

Call get_weather(location="Boston, MA", unit="fahrenheit").

MCP Processor: Parse the response, recognize the tool call, and execute the weather query tool. Tool Execution Result:

Result of get_weather:
{
  "location": "Boston, MA",
  "temperature": 72,
  "unit": "fahrenheit",
  "condition": "Sunny"
}

📚 Comparative Analysis

📚 Configuration Instructions

Example of Tool XML Definition

<tool name="weather">
    <description>Get weather information</description>
    <parameters>
        <parameter name="location" type="string">City</parameter>
        <parameter name="unit" type="string">Temperature unit (Celsius/Fahrenheit)</parameter>
    </parameters>
</tool>

Request Example

{
  "messages": [
    {
      "role": "system",
      "content": "<tools>...</tools>"
    },
    {
      "role": "user",
      "content": "Query the weather in Boston."
    }
  ]
}

📚 Conclusion

Through the MCP protocol, users can flexibly call various tools in text form, significantly enhancing the system's scalability and flexibility while reducing maintenance complexity. This method provides an effective solution for building intelligent conversation systems.