MCP Servers

DeepFellow can run and proxy MCP servers directly from the Infra Web Panel. Three connection types are supported:

• Command — run a stdio-based server in an isolated Docker container with a built-in bridge.
• Remote URL — register a remote MCP server as a proxy endpoint.
• Custom Image — run a server from a Docker image you provide.

All three types are added through the same modal and registered as endpoints at

https://{DEEPFELLOW_HOST}/mcp/{PREFIX}/.

with available working endpoints on:

• for Streamable HTTP endpoint

  https://{DEEPFELLOW_HOST}/mcp/{PREFIX}/mcp.

• for SSE endpoints

  GET https://{DEEPFELLOW_HOST}/mcp/{PREFIX}/sse. POST https://{DEEPFELLOW_HOST}/mcp/{PREFIX}/messages.

Add an MCP Server

Open the mcp service in the Infra Web Panel, click Models, then click Add MCP Server.

Auto Import

The fastest way to add a Command or Remote URL server is Auto Import. Paste a standard mcpServers JSON config and DeepFellow fills in the form automatically.

1. Click Add MCP Server, then choose Auto import.
2. Paste a mcpServers JSON config from Claude Desktop, Cursor, or a similar client.
3. DeepFellow parses the config, selects the correct connection type, and pre-fills all fields.

Supported config formats:

• Standard command + args + env fields — switches to Command mode.
• docker run command — switches to Custom Image mode, extracting the image, the inner command, and any -v/--mount volumes as bind mounts.
• cmd /c Windows wrapper — stripped automatically.
• Proxy config (with a serverUrl or url field) — switches to Remote URL mode automatically.

Node.js (npx)

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/data"]
    }
  }
}

Python (uvx)

{
  "mcpServers": {
    "semgrep": {
      "command": "uvx",
      "args": ["mcp-server-time"]
    }
  }
}

Remote MCP (Streamable HTTP)

{
  "mcpServers": {
    "deepwiki": {
      "serverUrl": "https://mcp.deepwiki.com/mcp"
    }
  }
}

Command (stdio Bridge)

Use this type for MCP servers distributed as npx or uvx packages — the most common public MCP servers.

DeepFellow builds a Docker image that wraps the server process in a stdio-to-HTTP bridge:

• Node.js servers use supergateway.
• Python servers use mcp-proxy.

Runtime Variants

Use a *-headed variant for servers that require a browser (Playwright, Puppeteer). DeepFellow auto-detects the variant from the launch command binary. Override it manually if the detection is wrong.

Manual Setup

1. Select Command → Manual.

2. Fill in the fields:

   • Launch command — the stdio command to run inside the container. For example:

     npx -y @modelcontextprotocol/server-filesystem /data
     uvx mcp-server-git --repository /repo

   • Base image (optional) — override the default base image. Leave empty for standard npx or uvx commands.
   • Model ID — unique identifier for this server.
   • Endpoint prefix (optional) — path segment for the registered endpoint; defaults to Model ID.
   • Variant — auto-detected; override if needed.
   • Environment variables (optional).

3. Click Add. The server appears in the model list.

4. Click Install. DeepFellow builds the Docker image and streams the build log in real time.

Custom Image

Use this type for MCP servers packaged as a Docker image.

1. Select Custom Image.
2. Fill in the image spec fields. Optionally add bind mounts.
3. Click Add, then Install.

Remote URL (Proxy)

Use this type to expose a remote MCP server through DeepFellow without running it locally.

1. Select Remote URL.

2. Fill in the fields:

   • Server URL — the upstream MCP endpoint URL.
   • Name — display name.
   • Endpoint prefix (optional).
   • Transport — Streamable HTTP or SSE (auto-detected from the URL path; override if needed).
   • Request headers (optional) — forwarded to the upstream on every request.

3. Click Add. No Docker image is built. DeepFellow registers a proxy route immediately.

For SSE transport, the proxy rewrites endpoint event URLs so all client traffic routes through DeepFellow. The upstream URL is never exposed to the client.

Edit and Uninstall

Click Edit on a server card to update its configuration.

• For Command servers: DeepFellow regenerates the Dockerfile and removes the old image. Click Install after saving to apply the changes.
• For Remote URL servers: no Docker image is rebuilt, but an installed server must be uninstalled before editing.

To remove a server, click Uninstall:

• Uninstall — stops and removes the container but keeps the built image for a faster reinstall.
• Purge — removes the container, the image, and the generated Dockerfile.