What is Webui Mcpo

webui-mcpo is a lightweight Docker image designed to launch multiple MCP servers through the MCPO framework, providing unified OpenAPI access with a simple configuration format.

Use cases

Use cases for webui-mcpo include setting up a development environment for testing multiple MCP servers, simplifying API management for applications that utilize various MCP tools, and providing a unified interface for developers.

How to use

To use webui-mcpo, pull the Docker image with ‘docker pull masterno12/webui-mcpo:latest’, create a ‘config.json’ file in a local directory, and ensure it is in the same directory as your docker-compose.yml file.

Key features

Key features of webui-mcpo include the ability to run multiple MCP tools from a single configuration, compatibility with Claude Desktop format, and automatic generation of default configuration files.

Where to use

webui-mcpo can be used in various fields such as software development, data processing, and API management where multiple MCP tools need to be integrated seamlessly.

🧠 webui-mcpo: Run Multiple MCP Tools with a Single Config on Open WebUI

Docker Hub Image: masterno12/webui-mcpo:latest

This Docker image provides a ready-to-use instance of MCPO, a lightweight, composable MCP (Model Context Protocol) server designed to proxy multiple MCP tools in one unified API server — using a simple config file in the Claude Desktop format.

🔗 What is MCP?
Learn more at the Open WebUI MCP Server docs
Supported official MCP servers: https://github.com/modelcontextprotocol/servers

💡 Why this approach?

When starting out, I found that the official Open WebUI documentation often highlights one-liner launch commands (e.g. using npx or uvx directly) and provides translations from Claude configs to one-liners.

However, I noticed two things:

• The MCP server registry (https://github.com/modelcontextprotocol/servers) nearly always gives the Claude-style JSON configuration, not the one-liners.
• MCPO, when acting as a hub, expects Claude configs directly—there is no benefit in converting them to one-liners manually.

So instead of manually translating JSON blocks to CLI commands, I embraced the Claude config format fully. This makes the setup clearer, easier to maintain, and perfectly compatible with mcpo.

🚀 Quick Start (with Docker Hub)

1. Pull the image

docker pull masterno12/webui-mcpo:latest

2. Create a config.json

You must provide a config.json in a local folder (e.g., mcpo/). If mcpo/config.json does not exist, the container will automatically generate a minimal default one.
The local folder mcpo/ must be in the same directory where docker-compose.yml is.

📄 Example config.json:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    },
    "time": {
      "command": "uvx",
      "args": [
        "mcp-server-time",
        "--local-timezone=America/New_York"
      ]
    },
    "mcp_sse": {
      "type": "sse",
      "url": "http://127.0.0.1:8001/sse"
    },
    "mcp_streamable_http": {
      "type": "streamable_http",
      "url": "http://127.0.0.1:8002/mcp"
    }
  }
}

🐳 Run with Docker Compose

services:
  mcpo:
    image: masterno12/webui-mcpo:latest
    container_name: webui-mcpo
    ports:
      - "8000:8000"
    volumes:
      - ./mcpo:/opt/mcpo
    restart: unless-stopped

Start the server:

docker-compose up -d

🔨 Build the Image from Dockerfile

Clone the repo:

git clone https://github.com/masterno12/webui-mcpo.git
cd webui-mcpo

Build the image locally:

docker build -t webui-mcpo:latest .

Then either run it directly:

docker run -d -p 8000:8000 -v "$PWD/mcpo:/opt/mcpo" webui-mcpo:latest

Or use the provided Docker Compose setup:

docker-compose up -d --build

🌐 Accessing Tools

Each tool is exposed under its own subpath, for example:

• http://localhost:8000/memory
• http://localhost:8000/time

Each path serves:

• An individual OpenAPI schema (/docs)
• A dedicated handler

Example:

• http://localhost:8000/memory/docs
• http://localhost:8000/time/docs

✅ Open WebUI Integration

To connect tools from this MCP server in Open WebUI, you must use the full subpath for each tool:

✅ Valid tool entries:

http://localhost:8000/memory
http://localhost:8000/time

🚫 Invalid:

http://localhost:8000

This ensures Open WebUI recognizes and communicates with each tool server correctly.

🛠 Notes

• If /opt/mcpo/config.json does not exist on container startup, a minimal default will be copied automatically.
• Container exposes port 8000.
• Supports npx, uvx, and custom MCP tool types.

n8n support

The sse provide by n8n work when use with supergateway

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": [
        "-y",
        "supergateway",
        "--sse",
        "<MCP_URL>"
      ]
    }
  }
}

With Authorization

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": [
        "-y",
        "supergateway",
        "--sse",
        "<MCP_URL>",
        "--header",
        "Authorization: Bearer <MCP_BEARER_TOKEN>"
      ]
    }
  }
}

But, mcpo should work with native sse (but not for me, i let it here if you want to try)

    "n8n-dev": {
      "url": "<MCP_URL>",
      "serverType": "sse"
    }   

With Authorization

 "linux_server": {
      "transport": "sse",
      "endpoint": "http://192.168.40.173:8000/sse",
      "bearertoken":"expected-token"
    }

📦 Changelog

v1.2 – Added API Key Support via ENV (2025-05-24)

• ✅ Added support for API key injection via MCPO_API_KEY environment variable.
• 🛠️ Updated entrypoint.sh to dynamically append --api-key if the variable is present.
• 📁 Keeps using config.json for server configuration.
• 📄 Improved documentation for Docker Compose usage.
• 🧪 Backward-compatible with v1.1 config files.

v1.1 – Initial Release

• 🧠 Basic Docker image for mcpo with config file support.
• 🚀 Lightweight and ready-to-use Open WebUI MCP server launcher.

🔗 Related Links

• MCPO GitHub
• Open WebUI: MCP Servers
• Model Context Protocol Servers