# MCP Platform

> A secure platform for easy deployment of MCP servers with any tools.

- **Type:** MCP server
- **Install:** `agentstack add mcp-odzywa-mcp-platform`
- **Verified:** Pending review
- **Seller:** [odzywa](https://agentstack.voostack.com/s/odzywa)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [odzywa](https://github.com/odzywa)
- **Source:** https://github.com/odzywa/MCP-Platform

## Install

```sh
agentstack add mcp-odzywa-mcp-platform
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# MCP Platform

A self-hosted platform for creating, deploying and managing **MCP (Model Context Protocol) servers** — without writing code.

Connect AI assistants (Continue, OpenWebUI, Claude Desktop) to your infrastructure: databases, APIs, Kubernetes clusters, Linux servers — all through a visual web UI.

---

## What it does

- **Visual tool builder** — create MCP tools from a web form, not code
- **Instant deploy** — one click deploys a containerized MCP server
- **Multiple runtime types** — shell commands, HTTP APIs, custom images
- **Policy engine** — allowlist binaries, block dangerous commands, enforce read-only mode
- **OpenWebUI integration** — Tool Server (OpenAPI), Python tool import, filter pipeline
- **Continue integration** — `streamable-http` transport, auto-generated config snippets
- **Audit log** — every tool invocation logged with caller IP and model name

---

## Prerequisites

| Requirement | Version | Install |
|-------------|---------|---------|
| **Docker Engine** | 24.0+ | [docs.docker.com/engine/install](https://docs.docker.com/engine/install/) |
| **Docker Compose** | v2.20+ (plugin) | included with Docker Desktop / `apt install docker-compose-plugin` |
| **OS** | Linux (Ubuntu 22.04+ recommended) | — |
| **RAM** | 2 GB minimum, 4 GB recommended | — |
| **Disk** | 4 GB free (images + data) | — |
| **Ports** | 18100 + range 19000–19999 open | firewall / UFW |

> **Note:** Docker Desktop on macOS/Windows works for development but runtime containers may not be reachable by AI clients outside the VM. Linux is recommended for production.

### Install Docker (Ubuntu)

```bash
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker
docker --version        # Docker version 24.x.x
docker compose version  # Docker Compose version v2.x.x
```

> **Important:** Your user must be in the `docker` group, otherwise `install.sh` and all `docker` commands will fail with permission errors.
>
> ```bash
> # Add current user to docker group
> sudo usermod -aG docker $USER
>
> # Apply without logout (current session only)
> newgrp docker
>
> # Verify
> docker ps   # should work without sudo
> ```
>
> If you log out and back in, group membership is applied automatically.

---

## Installation

```bash
# 1. Install Docker (if not already installed)
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker

# 2. Clone the repository
git clone https://github.com/YOUR_USERNAME/mcp-platform.git
cd mcp-platform

# 3. Run the installer
chmod +x install.sh
./install.sh
```

Open **http://YOUR_SERVER_IP:18100** — login: `admin` / `admin`

### Updating to a newer version

```bash
git pull
docker compose up -d --build mcp-platform mcp-platform-operator
```

> **Note:** `--force-recreate` alone does **not** rebuild images from updated source code.  
> Always use `--build` after `git pull`.

### Rebuilding images manually (after local code changes)

```bash
# Rebuild control plane only
docker compose up -d --build mcp-platform

# Rebuild operator only
docker compose up -d --build mcp-platform-operator

# Rebuild runtime images (shell / http-gateway)
docker compose --profile build-only build
# Then redeploy running runtimes via the UI: Runtime → Deploy

# Rebuild everything at once
docker compose build && docker compose up -d
```

---

## Quick Start

**Requirements:** Docker 24+, Docker Compose v2, Linux

```bash
git clone https://github.com/YOUR_USERNAME/mcp-platform.git
cd mcp-platform
chmod +x install.sh
./install.sh
```

Open **http://localhost:18100** — login: `admin` / `admin`

---

## Manual Setup

```bash
# 1. Copy and edit configuration
cp .env.example .env
# Edit MCP_HOST_DATA_PATH to the absolute path of the data/ folder

# 2. Build runtime images
docker compose --profile build-only build

# 3. Start the platform
docker compose up -d

# 4. Open the UI
open http://localhost:18100
```

---

## Architecture

```
┌─────────────────────────────────────────────────┐
│                   MCP Platform UI                │
│            (FastAPI · SQLite · port 18100)        │
└────────────────────┬────────────────────────────┘
                     │ manages
         ┌───────────▼──────────┐
         │   Operator (worker)   │
         │   Docker SDK          │
         └───────────┬──────────┘
                     │ creates/stops
     ┌───────────────┼───────────────────┐
     ▼               ▼                   ▼
┌─────────┐   ┌─────────────┐   ┌──────────────┐
│ Shell   │   │ HTTP Gateway│   │ Custom Image │
│ Runtime │   │ Runtime     │   │ Runtime      │
│ /mcp    │   │ /mcp        │   │ /mcp         │
└─────────┘   └─────────────┘   └──────────────┘
     ▲               ▲
     │ calls         │ calls
┌────┴───────────────┴──────┐
│  AI Client                │
│  Continue / OpenWebUI     │
└───────────────────────────┘
```

| Component | Description |
|-----------|-------------|
| `control-plane` | Web UI + REST API — manages runtimes, tools, policies |
| `operator` | Background worker — creates/stops Docker containers |
| `runtime-shell` | Shell runtime — executes CLI commands (curl, psql, oc, ping...) |
| `runtime-http-gateway` | HTTP runtime — calls external REST APIs |

---

## Base Runtime Images

Every MCP runtime container must use one of the two platform base images (or a custom image built **on top of them**). These images contain the built-in MCP server (FastAPI + uvicorn) that handles `/mcp`, `/tools/{name}`, `/openwebui` and `/health` endpoints.

### mcp-runtime-shell:latest

Built from `runtime-shell/` during `docker compose build`.

**Base:** `python:3.12-slim` (Debian Bookworm Slim)

**Included tools:**

| Tool | Purpose |
|------|---------|
| `curl`, `jq` | HTTP requests and JSON parsing |
| `oc`, `kubectl` | OpenShift and Kubernetes CLI |
| `ping` | Network diagnostics |
| `ssh` | Remote server access |
| FastAPI + uvicorn | MCP server on port 8080 |

**Use for:** shell tools — curl, oc, kubectl, psql, ping, ssh, any CLI command

### mcp-runtime-http-gateway:latest

Built from `runtime-http-gateway/` during `docker compose build`.

**Base:** `python:3.12-slim` (Debian Bookworm Slim)

**Included:**

| Component | Purpose |
|-----------|---------|
| FastAPI + uvicorn | MCP server on port 8080 |
| httpx | Async HTTP client for calling external REST APIs |

**Use for:** HTTP tools — calling external REST APIs, webhooks, integrations

### Building a custom image

If you need tools not available in the base images (e.g. `psql`, `terraform`, `awscli`), use the **Image Builder** in the UI or write your own Dockerfile:

```dockerfile
# ALWAYS start from a platform base image — never from a raw OS image
FROM mcp-runtime-shell:latest

RUN apt-get update && apt-get install -y postgresql-client && rm -rf /var/lib/apt/lists/*
```

> **⚠️ Raw OS images will NOT work.**  
> `ubuntu:24.04`, `debian:bookworm-slim`, `alpine` etc. do not contain the MCP server.  
> The container starts with `bash`, exits immediately, and enters a restart loop.

---

## Creating your first MCP server

### Option A — Use an example package

1. Go to **Tool Packages** → **Import Package JSON**
2. Upload a file from `examples/` (e.g. `curl-http-toolkit.json`)
3. Click **Create MCP** → name it → **Deploy**
4. Copy the endpoint URL → paste into Continue or OpenWebUI

### Option B — Build from scratch

1. **Tool Packages** → **+ Generate Package**
2. Fill in name, choose runtime type (Shell or HTTP)
3. Add tools with commands/URLs and input parameters
4. Install → Create MCP Server → Deploy

See `docs/jak-stworzyc-mcp-server.md` for full step-by-step guide.

### Option C — Let AI create it for you (Platform Manager)

MCP Platform includes a built-in **Platform Manager** MCP server — a meta-MCP that lets AI models create other MCP servers automatically.

1. Go to **Quick Start** → deploy **MCP Platform Manager**
2. Add credential: `PLATFORM_URL` = `http://mcp-platform:8080`
3. Deploy → connect to your AI client
4. Tell the AI what you need:

```
"Create an MCP server for monitoring MikroTik router at 192.168.88.1 with login admin and password test123"
```

The AI will:
- Read platform instructions (`get_instructions`)
- Generate the package JSON with tools, policy, and credentials
- Call `create_mcp_server` to deploy it automatically

**Available tools in Platform Manager:**

| Tool | Description |
|------|-------------|
| `get_instructions` | Returns full documentation on how to create MCP servers |
| `create_mcp_server` | Creates + deploys a server from package JSON in one call |
| `list_servers` | Lists all running MCP servers |
| `list_packages` | Lists available template packages |
| `server_details` | Shows details of a specific server |
| `deploy_server` | Starts a stopped server |
| `stop_server` | Stops a running server |

### Built-in template packages

| Package | Tools | Description |
|---------|-------|-------------|
| `curl-http-toolkit` | 3 | HTTP GET, POST, status check via curl |
| `openshift-readonly` | 7 | oc get, describe, logs, events, status, top |
| `mikrotik-readonly` | 7 | MikroTik REST API — interfaces, DHCP, routes, firewall, logs |
| `minio-readonly` | 5 | MinIO S3 — list buckets, objects, download files |
| `mssql-readonly` | 4 | MSSQL SELECT queries, list tables/databases |
| `trino-readonly` | 5 | Trino SQL — catalogs, schemas, tables, queries |
| `git-readonly` | 6 | Git log, diff, show, status, branches, blame |
| `platform-manager` | 7 | Meta-MCP — AI creates and manages other MCP servers |

---

## Connect to Continue

```json
{
  "mcpServers": {
    "my-server": {
      "url": "http://localhost:PORT/mcp",
      "transport": "streamable-http"
    }
  }
}
```

## OpenWebUI Integration

MCP Platform has native integration with [OpenWebUI](https://github.com/open-webui/open-webui).  
Each deployed MCP server automatically exposes three integration endpoints:

### Option 1 — Tool Server (recommended, multiple tools at once)

Each runtime serves a full OpenAPI spec at `/openwebui/openapi.json`.  
OpenWebUI discovers all tools automatically.

1. OpenWebUI → **Admin Panel → Tools → Tool Servers → Add**
2. Enter URL: `http://YOUR_IP:PORT/openwebui`
3. Save — all tools from the MCP server appear instantly

> OpenWebUI automatically appends `/openapi.json` — enter the base URL only.

### Option 2 — Python Tool (import from link)

Each runtime generates a ready-to-import Python tool file.

1. Open the runtime detail page → **Podłącz** tab → copy the **Python Tool** link
2. OpenWebUI → **Workspace → Tools → Import from URL** → paste the link
3. The tool appears in your workspace with full function signatures

### Option 3 — RAGHybrid filter pipeline

If you run RAGHybrid alongside MCP Platform, use the auto-context filter:
- Automatically injects RAG context into prompts when the tool is active
- Configurable `top_k`, retrieval mode, and source filtering

---

## Example Packages

| File | Description |
|------|-------------|
| `examples/curl-http-toolkit.json` | HTTP GET, POST, status check via curl |
| `examples/psql-readonly.json` | PostgreSQL SELECT queries |
| `examples/openshift-readonly.json` | oc get / describe / logs |

---

## Configuration

| Variable | Default | Description |
|----------|---------|-------------|
| `MCP_PLATFORM_PORT` | `18100` | UI port |
| `MCP_HOST_DATA_PATH` | *(required)* | Absolute path to `data/` on host |
| `MCP_RUNTIME_PUBLIC_BASE_URL` | `http://localhost` | Base URL for runtime endpoints |
| `MCP_RUNTIME_PUBLIC_PORT_BASE` | `19000` | Starting port for runtime containers |

---

## License

Copyright (c) 2026 — All Rights Reserved.  
See [LICENSE](LICENSE) MIT

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [odzywa](https://github.com/odzywa)
- **Source:** [odzywa/MCP-Platform](https://github.com/odzywa/MCP-Platform)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-odzywa-mcp-platform
- Seller: https://agentstack.voostack.com/s/odzywa
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.