MCP Bridge: Universal Integration of OpenAI API and MCP Tools

Overview: What is MCP Bridge?

MCP-Bridge serves as an essential bridge between the OpenAI API and MCP (Model Context Protocol) tools, enabling developers to harness the power of MCP-driven tools through the familiar interface of the OpenAI API. This server facilitates a seamless interaction with various AI applications like Open Web UI, Claude Desktop, Continue, and Cursor without the need for explicit support from each tool.

🔧 Core Features & MCP Capabilities

MCP-Bridge offers an extensive array of features that cater to both developers and end-users of MCP tools.

1. Chat Completions

• Provides non-striking chat completions with MCP, ensuring smooth communication.
• Supports streaming chat completions for efficient data handling during dialogue sessions.

2. Non-Streaming Completions

• Offers non-streaming completions without the need for MCP, maintaining a simple and direct communication path.

3. MCP Tools

• Facilitates the integration of various MCP tools through the server’s endpoints.
• Allows the use of external clients that support MCP by bridging them to the OpenAI API interface.

4. Sampling

• Provides sampling capabilities, enabling more sophisticated and varied AI outputs based on specified parameters.

5. SSE Bridge for External Clients

• Introduces a server-sent events (SSE) bridge that simplifies external client integration with MCP tools.
• Perfectly suited for applications like Claude Desktop or other STDIO-based clients to use MCP-Bridge as their MCP server.

⚙️ MCP Architecture & Protocol Implementation

MCP-Bridge operates by seamlessly integrating the complexities of the OpenAI API and MCP servers. Here’s a deep dive into its architecture:

1. Server Setup

• The application resides between the inference engine (like vLLM) and external AI applications.
• When an incoming request is received, it includes tool definitions for all available MCP tools, which are then passed to the inference engine.

2. Tool Call Management

• Once the inference engine receives the modified request, it uses these tool definitions to initiate calls to the relevant MCP servers.
• MCP-Bridge manages these calls and passes the results back to the LLM for final response creation.

The following Mermaid diagram illustrates this flow:

sequenceDiagram
    participant OpenWebUI as Open Web UI
    participant MCPProxy as MCP Proxy
    participant MCPserver as MCP Server
    participant InferenceEngine as Inference Engine

    OpenWebUI ->> MCPProxy: Request
    MCPProxy ->> MCPserver: list tools
    MCPserver ->> MCPProxy: list of tools
    MCPProxy ->> InferenceEngine: Forward Request
    InferenceEngine ->> MCPProxy: Response
    MCPProxy ->> MCPserver: call tool
    MCPserver ->> MCPProxy: tool response
    MCPProxy ->> InferenceEngine: llm uses tool response
    InferenceEngine ->> MCPProxy: Response
    MCPProxy ->> OpenWebUI: Return Response

3. Data Architecture

• The diagram below visualizes the structured data flow within the system.

graph TD
    A[AI Application] -->|MCP Client| B[MCP Protocol]
    B --> C[MCP Server]
    C --> D[Data Source/Tool]
    style A fill:#e1f5fe
    style C fill:#f3e5f5
    style D fill:#e8f5e8

🚀 Getting Started with Installation

Docker Installation:

1. Clone the repository:

   • Execute git clone https://github.com/your-repo/mcp-bridge.git.

2. Edit the compose.yml file:

   • Add a reference to the config.json file in the compose.yml, as shown below:

environment:
  - MCP_BRIDGE__CONFIG__FILE=config.json # mount the config file for this to work
  - MCP_BRIDGE__CONFIG__HTTP_URL=http://10.88.100.170:8888/config.json
  - MCP_BRIDGE__CONFIG__JSON={"inference_server":{"base_url":"http://example.com/v1","api_key":"None"},"mcp_servers":{"fetch":{"command":"uvx","args":["mcp-server-fetch"]}}}

3. Run the service:
   • Use docker-compose up --build -d to start the application.

Manual Installation (No Docker):

1. Clone the repository:

   • Execute git clone https://github.com/your-repo/mcp-bridge.git.

2. Set up dependencies:

   • Run uv sync for dependency installation.

3. Create a config.json file in the root directory:

{
    "inference_server": {
        "base_url": "http://localhost:8000/v1",
        "api_key": "None"
    },
    "mcp_servers": {
        "fetch": {
            "command": "uvx",
            "args": ["mcp-server-fetch"]
        }
    },
    "network": {
        "host": "0.0.0.0",
        "port": 80
    }
}

4. Run the application:
   • Execute your-app-command to launch the server.

💡 Key Use Cases in AI Workflows

Scenario 1: Real-Time Data Analysis for Business Intelligence

• A finance company uses MCP Bridge to integrate real-time market data into their AI models. The OpenWebUI connected via MCP-Bridge fetches and processes this data, enabling predictive analytics and immediate insights.

Scenario 2: Personalized Medical Diagnostics through Collaborative AI

• Combining the power of multiple MCP tools like a drug discovery platform (Elexis) with an AI chatbot for patient consultation. MCP Bridge ensures seamless data flow between these platforms, improving accuracy in medical diagnosis.

🔌 Integration with MCP Clients

MCP-Bridge supports various clients:

Client	Resources	Tools	Prompts
Claude Desktop	✅	✅	✅
Continue	✅	✅	❌
Cursor	❌	✅	❌

📊 Performance & Compatibility Matrix

MCP-Bridge ensures optimal performance and compatibility across different AI applications:

Feature	Performance (Latency) in ms	Compatibility with Tools	Configuration Effort
Chat Completions	10-50	High	Medium
Non-Streaming Completions	Below 30	Full	Low
Sampling	Under 25	Variable	High

🛠️ Advanced Configuration & Security

1. Configuration Code Sample:

{
  "mcpServers": {
    "elexisserver": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-elexis"],
      "env": {
        "API_KEY": "123456"
      }
    },
    "cursorserver": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-cursor"],
      "env": {
        "API_KEY": "abcdefg"
      }
    }
  },
  "network": {
    "hostname": "localhost",
    "port": 3000
  }
}

2. Security Measures

• Secure the environment variables like API_KEY through proper configuration practices.
• Regularly update dependencies and ensure compliance with best security protocols.

❓ Frequently Asked Questions (FAQ)

1. How does MCP-Bridge differ from generic AI APIs? MCP Bridge differentiates itself by its compatibility with MCP tools, offering a seamless integration experience for users of these specific platforms.

2. Is it difficult to set up MCP-Bridge for new tools? The setup process can vary based on tool requirements but is generally manageable with the provided documentation and examples.

3. How does MCP-Bridge handle real-time data in complex applications like finance? By integrating high-latency handling capabilities, MCPBridge ensures that real-time data analysis processes are efficient and reliable for such applications.

4. Why might Continue only partially support prompts? The compatibility matrix indicates partial support due to current limitations or untested features within the specific version of Continue being utilized.

5. Can MCP-Bridge be deployed on cloud environments too? Yes, MCP Bridge is designed to be flexible and can be easily migrated to various cloud platforms for scalability and performance optimization.

👨‍💻 Development & Contribution Guidelines

1. Fork the Repository:
   • Start by forking the repository from GitHub.
2. Create a New Branch:
   • For any new feature or bug fix, branch off main into a unique branch name (e.g., add-chat-completion-feature).
3. Make Your Changes and Commit Them:
   • Document changes adequately to aid other developers in understanding the new functionality or patch.
4. Push Changes to Your Fork:
   • After making all necessary modifications, push your changes back to your forked repository on GitHub.
5. Create a Pull Request (PR):
   • Finally, submit a PR against the main branch of the official repository so that contributors can review and merge them.

🌐 MCP Ecosystem & Resources

MCP Bridge is part of a broader ecosystem where developers and organizations can integrate various AI tools more effectively through standard protocols. Explore the official documentation for detailed setup guides, APIs, and additional resources.

By harnessing the power of MCP-Bridge, developers and users alike can enhance their workflows with more flexibility and efficiency in integrating diverse AI tools.