---
id: "docker-companion"
date: "2026-03-28"
title: "Docker Companion — local MCP servers, Ollama, and health monitoring from your browser"
summary: "A built-in Docker Compose generator that spins up local MCP servers, Ollama, and a health sidecar — all from your browser settings. Power user preview."
image: "/medias/docker.companion.jpg"
header: "Preview"
tags: ["preview", "docker", "mcp", "power-user", "infrastructure"]
---

## For the tinkerers

Most Daneel features work out of the box — install the extension, open a page, start chatting. But some of the most powerful capabilities live outside the browser: local MCP servers that expose filesystems, databases, and search APIs to your AI.

Running those servers means Docker images, port mappings, environment variables, and compose files. If you're comfortable with that, the Docker Companion gives you a GUI that generates it all — and auto-registers everything back into Daneel.

This is a beta feature for power users with Docker on their machine. If that's you, read on.

## What it does

The Docker Companion is a Compose file generator built into Daneel's settings. Toggle presets, pick MCP servers from a template catalog, configure environment variables, preview the YAML, and export — all without leaving the browser.

Three service categories:

**Companion Sidecar** (always on) — a lightweight Python/FastAPI container that monitors your stack. It mounts the Docker socket read-only, discovers containers labeled `daneel.managed`, and reports their health, ports, and status back to the extension. The settings panel polls it every 10 seconds and shows live service status.

**Ollama** (optional) — a managed Ollama instance with CORS pre-configured for Chrome extensions (`OLLAMA_ORIGINS=chrome-extension://*`), persistent model storage via a named volume, and optional NVIDIA GPU passthrough. One toggle, and you have a local LLM server that Daneel can connect to immediately.

**MCP Servers** (optional, beta) — this is the interesting part. Each server you add becomes a separate container running `supercorp/supergateway`, which bridges stdio-based MCP servers to HTTP endpoints that Daneel already understands. One container per server, sequential ports, automatic CORS.

## Nine server templates — and custom commands

The template catalog includes pre-configured MCP servers ready to deploy:

| Server | What it does | Requires |
|--------|-------------|----------|
| **Filesystem** | Read/write files on a mounted volume | Volume mount |
| **GitHub** | Repos, issues, PRs, file access | `GITHUB_TOKEN` |
| **SQLite** | Query and manage SQLite databases | Volume mount |
| **PostgreSQL** | Query PostgreSQL databases | `DATABASE_URL` |
| **Brave Search** | Web search via Brave API | `BRAVE_API_KEY` |
| **Perplexity** | Web search and reasoning via Sonar | `PERPLEXITY_API_KEY` |
| **Fetch** | Extract content from any URL | Nothing |
| **Memory** | Persistent knowledge graph | Nothing |
| **Puppeteer** | Browser automation and scraping | Nothing |

Pick a template, fill in any required environment variables (secrets are masked in the UI), and the server is added to your compose stack. Each server gets a sequential port starting from 8810: first server at `localhost:8810/mcp`, second at `localhost:8811/mcp`, and so on.

Need something not in the catalog? The "Custom" option lets you specify any arbitrary stdio command — `python -m my_server`, `npx my-private-mcp-package`, whatever your setup requires.

## The supergateway bridge

Most MCP servers speak stdio — they read JSON-RPC from stdin and write to stdout. That's great for local CLI tools, but a Chrome extension needs HTTP.

Supergateway solves this. Each MCP server container runs `supercorp/supergateway` (or the `:uvx` variant for Python packages), which spawns your stdio server as a subprocess and exposes it as a Streamable HTTP endpoint with CORS headers. The generated command:

```
--stdio "uvx mcp-server-filesystem /data" --port 8000 --cors --outputTransport streamableHttp
```

From Daneel's perspective, each container looks like a standard remote MCP server. The existing transport and tool-calling loop work unchanged — no special local-server handling needed.

## YAML preview and export

The settings panel shows a live YAML preview that updates as you toggle services and add servers. You can inspect exactly what will be generated before committing.

Two export paths: **copy to clipboard** or **download as `daneel.compose.yml`**. Then:

```bash
docker compose -f daneel.compose.yml up -d
```

All services start in the background with automatic restart policies. The companion sidecar begins discovering managed containers immediately.

## Auto-registration

Here's the workflow payoff: when you export, Daneel can **automatically register** every MCP server in its internal registry. No need to manually add `http://localhost:8810/mcp` in the MCP settings — check the "auto-register" box and each server appears in your registered server list, ready to use in conversations, agents, and vaults.

The registered servers are marked as local (`isExternal: false`), so Daneel's privacy indicators correctly show that tool calls stay on your machine.

## Live health monitoring

Once the stack is running, the Companion Status section in settings shows real-time service health. Each managed container appears with its name, exposed ports, and status badge — running, stopped, restarting, or unknown. The companion polls the Docker socket every request and the extension polls the companion every 10 seconds.

If the companion is unreachable, the panel shows the exact `docker compose` command to start it.

## What's coming

This is a preview for a reason — we're building toward a richer local infrastructure layer:

- **SearXNG preset** — a self-hosted search engine as an MCP server, giving your AI private web search with no API keys
- **Microsoft BitNet** — 1-bit inference for extreme efficiency on CPU
- **Observability stack** — Prometheus + Grafana preset for monitoring inference latency and token throughput
- **More MCP templates** — as the MCP ecosystem grows, the template catalog will track it

The Docker Companion is infrastructure-as-settings. If you run Docker, your browser just became a control plane.

---

[Read on site](https://daneel.injen.io/news/docker-companion.html?utm_source=extension_news_reader&utm_medium=extension_settings&utm_campaign=extension)