MCP (Model Context Protocol) is an open protocol that standardizes how applications provide context to large language models (LLMs). Think of MCP as the "USB-C port" for AI applications, offering a unified way to connect models to various data sources and tools.
- A growing list of pre-built integrations that LLMs can directly plug into
- Flexibility to switch between different LLM providers and vendors
- Best practices for securing both local and remote data
MCP follows a client-server architecture, including:
- MCP Hosts: Programs like Claude Desktop, IDEs, or AI tools that want to access data through MCP
- MCP Clients: Protocol clients that maintain 1:1 connections with servers
- MCP Servers: Lightweight programs that expose specific capabilities through the standardized protocol
- Local Data Sources: Your computer's files, databases, and services
- Remote Services: External systems available over the internet (e.g., APIs)
- Building agents and AI workflows that integrate multiple data sources and tools
- Allowing LLMs to securely access local or remote resources via a standard protocol
- Rapidly integrating and switching between different LLMs and their capabilities
For more details, see the official MCP documentation.
OmniMCP is not just a deployment platform—it is a showcase and integration hub for the entire MCP ecosystem!
If you are a developer or user and want to add your MCP project (or any MCP you are interested in) to the OmniMCP platform, please follow these steps:
-
Prepare your project repository (on GitHub, Gitee, or any accessible code hosting platform).
-
Go to https://omnimcp.ai and submit the repository link through the platform's add-project interface.
- MCP Protocol Compliance:
- Your project must implement the MCP protocol.
- Stdio Mode Support:
- Your project must be able to start in
stdiomode (support forsseandstreamable-httpis planned for the future).
- Your project must be able to start in
- Dockerfile (Optional but Recommended):
- It is recommended to provide a
Dockerfilefor easy deployment. If you do not provide one, the platform will automatically generate a Dockerfile for deployment.
- It is recommended to provide a
By following these guidelines, your MCP project can be easily integrated and showcased on the OmniMCP platform, making it accessible to a wider audience.
OmniMCP offers a unique, industry-leading feature: Instantly convert any OpenAPI 3.0-compatible API into a fully functional MCP server—no code changes required!
- Prepare an OpenAPI 3.0 Specification
- If your API already has an OpenAPI 3.0 (Swagger) document, you can use it directly. If not, generate one for your API.
- Example OpenAPI 3.0 JSON:
{
"openapi": "3.0.0",
"info": {
"title": "Simple API",
"version": "1.0.0"
},
"servers": [
{
"url": "http://localhost:3000"
}
],
"paths": {
"/users": {
"post": {
"summary": "Create a new user",
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/User"
}
}
}
},
"responses": {
"201": {
"description": "User created"
}
}
}
}
},
"components": {
"schemas": {
"User": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"email": {
"type": "string",
"format": "email"
}
},
"required": ["name", "email"]
}
}
}
}-
Submit the OpenAPI Document Link
- Make your OpenAPI 3.0 document accessible via a public URL (e.g., GitHub raw link, web server, etc.).
- Go to https://omnimcp.ai, paste the link in the API-to-MCP submission form, and click submit.
-
Automatic Conversion and Enhancement
- After submission, the OmniMCP platform will automatically convert your API into an MCP server.
- The platform will also analyze and enhance your API documentation (e.g., API descriptions, parameter descriptions) to optimize it for AI agent usage.
Within a short time, your API will be available as an MCP server on the platform, ready for integration and use by AI agents and other clients.
These features make OmniMCP the most developer-friendly and AI-ready MCP platform available—empowering you to share, deploy, and transform your tools and APIs with unprecedented ease!
This project is a minimal fastmcp demo, using Python 3.12 and uv for dependency and process management. It provides a simple MCP service with an addition tool, and supports deployment via Docker.
- Built with fastmcp framework for MCP protocol support.
- Provides a simple addition tool (
add). - Uses
uvfor both dependency management and process running. - Exposes the service via HTTP (default:
0.0.0.0:8000/mcp).
- Python 3.12
- uv (for virtual environment, dependency, and process management)
- fastmcp (installed as a dependency)
-
Create the virtual environment and install dependencies:
uv venv --python=3.12 uv pip install -r requirements.txt
-
Activate the virtual environment:
- On Unix/macOS:
source .venv/bin/activate - On Windows:
.\.venv\Scripts\activate
After activation, you can use
uv run server.pyor other commands in the virtual environment. - On Unix/macOS:
- Define your tool function in
server.pyusing the@mcp.tool()decorator. For example:
@mcp.tool()
def add(a: int, b: int) -> int:
"""Add two numbers"""
return a + b- Start the service, and the tool will be available via MCP clients.
Activate the virtual environment (see above) and run the server using uv:
uv run server.pyThe service will be available at http://0.0.0.0:8000/sse inside the container.
Note:
- The Dockerfile installs
uvand usesuv run server.pyas the default command, ensuring consistency with local development. - If you add a
requirements.txt, Docker will use it to install dependencies viauv pip install -r requirements.txt.
To add more tools, simply extend server.py with new @mcp.tool() functions as needed.
You can specify the startup mode (transport) directly in the Dockerfile by editing the CMD instruction. For example, to use stdio mode:
CMD ["uv", "run", "server.py", "--transport", "stdio"]To use SSE mode:
CMD ["uv", "run", "server.py", "--transport", "sse"]To use streamable-http mode:
CMD ["uv", "run", "server.py", "--transport", "streamable-http"]With this setup, you can start the container with a simple command:
docker run -d -p 8000:8000 --name mcp-demo mcp-demo:latestNo extra arguments are needed at runtime. To change the mode, just edit the Dockerfile and rebuild the image.
docker build -t mcp-demo:latest .docker run -d -p 8000:8000 --name mcp-demo mcp-demo:latestThe service will be available at http://0.0.0.0:8000/sse inside the container.