Freedanfan MCP Server

An AI model interaction server built on FastAPI and the MCP protocol, providing standardized context interaction, modular design, and asynchronous processing capabilities, simplifying model deployment and management.

Developer tools Artificial intelligence chatbots #AI interaction #Protocol standardization #Model deployment #Asynchronous service .Python

rating : 2 points

downloads : 9

update time : 2025-04-28

What is MCP Server?

MCP Server is an AI model interaction server built on the FastAPI framework, implementing the Model Context Protocol (MCP) standard. It serves as a bridge between AI models and development environments, providing standardized interaction interfaces and simplifying the development and integration process of AI applications.

How to use MCP Server?

Using MCP Server is very simple: 1) Install and start the server. 2) Send requests through the client or API. 3) Get the response results from the AI model. The server supports two communication methods: JSON-RPC and SSE.

Applicable scenarios

MCP Server is very suitable for the following scenarios: rapid prototyping of AI applications, multi-model integration systems, AI services requiring standardized interfaces, real-time AI interaction applications, etc.

Main features

JSON-RPC 2.0 supportImplements request-response communication based on the standard JSON-RPC 2.0 protocol, ensuring interface compatibility and interoperability.

SSE real-time communicationSupports Server-Sent Events (SSE) connections, enabling real-time event push from the server to the client.

Modular designAdopts a modular architecture, facilitating function expansion and custom development to meet the needs of different scenarios.

Asynchronous high performanceBased on FastAPI and asynchronous IO, it provides high-concurrency processing capabilities, suitable for large-scale AI service deployment.

Advantages and limitations

Advantages

Standardized interface: Unifies the AI model interaction protocol, reducing integration complexity

High performance: Asynchronous architecture supports high-concurrency request processing

Easy to expand: Modular design facilitates adding new functions or integrating new models

Multi-protocol support: Provides both JSON-RPC and SSE communication methods

Limitations

Currently only supports the Python environment

Requires additional configuration to support production environment deployment

The default implementation does not include specific AI models and requires additional integration

How to use

Installation preparation

Ensure that a Python 3.7+ environment is installed, clone the project repository, and install the dependencies.

Start the server

Run the main program to start the MCP server, which listens on 127.0.0.1:12000 by default.

Run the client

Run the test client program in another terminal to interact with the server.

Usage examples

Initialize a sessionInitialize an MCP session when the client connects for the first time

Text generationSend a text prompt to the AI model to get the generated result

Frequently Asked Questions

How to modify the server listening address and port?

How to integrate an actual AI model?

What if the SSE connection fails?

Related resources

MCP Protocol Specification

Official specification document of the Model Context Protocol

FastAPI Documentation

Official documentation of the FastAPI framework

JSON-RPC 2.0 Specification

Specification of the JSON-RPC 2.0 protocol

Project GitHub Repository

Source code and latest version of MCP Server

🚀 MCP Server

This project, built on FastAPI and MCP (Model Context Protocol), enables standardized context interaction between AI models and development environments. By simplifying model deployment, providing efficient API endpoints, and ensuring consistency in input and output, it enhances the scalability and maintainability of AI applications, making it easier for developers to integrate and manage AI tasks.

🚀 Quick Start

The MCP (Model Context Protocol) is a unified context interaction protocol between AI models and development environments. This project offers a Python-based implementation of the MCP server, supporting basic MCP protocol functions such as initialization, sampling, and session management.

✨ Features

JSON-RPC 2.0: Request - response communication based on the standard JSON - RPC 2.0 protocol.
SSE Connection: Supports Server - Sent Events (SSE) connections for real - time notifications.
Modular Design: Adopts a modular architecture for easy expansion and customization.
Asynchronous Processing: Implements high - performance services using FastAPI and asynchronous IO.
Complete Client: Includes a comprehensive test client implementation.

📦 Project Structure

mcp_server/
├── mcp_server.py         # Main program of the MCP server
├── mcp_client.py         # Test program of the MCP client
├── routers/
│   ├── __init__.py       # Initialization of the router package
│   └── base_router.py    # Implementation of the basic router
├── requirements.txt      # Project dependencies
└── README.md             # Project documentation

📦 Installation

Clone the repository:

git clone https://github.com/yourusername/mcp-server.git
cd mcp-server

Install the dependencies:

pip install -r requirements.txt

💻 Usage Examples

Basic Usage

Server Startup

Run the mcp_server.py script to start the MCP server:

python mcp_server.py

By default, the server will run on port 8000. You can customize the host and port through the environment variables MCP_SERVER_HOST and MCP_SERVER_PORT.

Client Usage

After configuring the server address and other parameters in mcp_client.py, you can call relevant functions. For example:

from mcp_client import MCPClient

client = MCPClient(server_url="http://localhost:8000")
response = client.request("command", parameters)
print(response)

📚 Documentation

Refer to the docs directory in the project repository for detailed documentation, including API references, usage guides, and development instructions.