🚀 FusionAL — Self-Hosted MCP Governance Gateway

Your team connected 10 MCP servers. Now what?
🌐 fusional.dev • 📧 jrm@fusional.com • 🗓️ Book a Call

MCP is powerful. Enterprise MCP deployment is a different problem entirely.

Every server you connect loads its full tool manifest into Claude's context window before processing a single token of your request. At 84 tools across several servers, that's 15,540 tokens consumed at session start — before your team has asked anything. At scale, that's cost, latency, and an audit surface nobody can explain to legal.

FusionAL is a self-hosted MCP governance gateway that sits between your AI clients and your tool servers. One endpoint. Central auth. Tool-level policy enforcement. Full audit trail. Deployable in a single Docker command — including on Windows, where MCP has 6 documented failure modes the official docs don't cover.

Built for teams that have already said yes to MCP and now need to run it safely:

• Token control — filter tool exposure per client so context bloat doesn't scale with your server count

• Audit-ready operations — every tool call logged with caller, input, latency, and response status

• Policy enforcement — control what tools run, for whom, and under what conditions

• Windows-hardened — 6 documented failure modes solved, none of which appear in official MCP docs

• AI-powered server generation — describe a tool in plain English, FusionAL builds and registers it

• Done-for-you option — we deploy, govern, and manage it for you

The question isn't whether to adopt MCP. It's whether your deployment will survive contact with your security team.

⚡ Quick Start (5 Minutes)

Prerequisites

• Docker Desktop (installed and running)

• Claude Desktop

• Python 3.11+

• Git

Step 1: Clone & Install

git clone https://github.com/JRM-FusionAL/FusionAL.git
cd FusionAL

python -m venv venv
source venv/bin/activate        # macOS/Linux
# venv\Scripts\activate         # Windows

pip install -r core/requirements.txt

Step 2: Start FusionAL

cd core
python -m uvicorn main:app --reload --port 8009

Verify it's running:

curl http://localhost:8009/health

Step 3: Configure Claude Desktop

Find your config file:

• Windows: C:\Users\YourName\AppData\Roaming\Claude\claude_desktop_config.json

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

• Linux: ~/.config/Claude/claude_desktop_config.json

⚠️ Windows users: Do NOT use %APPDATA% in the path — Claude Desktop won't expand it. Hardcode the full path. Example: C:\Users\YourName\AppData\Roaming\Claude\claude_desktop_config.json

Add FusionAL as an MCP server:

{
  "mcpServers": {
    "fusional-gateway": {
      "url": "http://localhost:8009/sse"
    }
  }
}

Step 4: Restart Claude Desktop & Test

Fully quit and reopen Claude Desktop. Open a new chat and try:

"Generate a Python MCP server that fetches the current weather for a given city."

FusionAL will generate, register, and run it automatically.

Related MCP server: Proofpane

🐳 Docker Deploy

Build and run the full gateway in Docker:

docker build -t fusional .
docker run -d -p 8089:8009 --name fusional fusional

Or with Docker Compose:

docker compose up -d

Gateway available at http://localhost:8089.

🏗️ Architecture

Claude Desktop / Any MCP Client
         │
         ▼  (SSE or Streamable HTTP)
  FusionAL Gateway  (:8009)
         │
   ┌─────┴──────┐
   ▼            ▼
FastAPI      MCP Transport (/mcp)
REST API     ├── execute_code
             ├── generate_and_execute
             └── generate_mcp_project
         │
         ▼
  Docker Sandbox Executor
  (network isolated, memory capped)
         │
         ▼
  MCP Server Registry (JSON)
  ├── business-intelligence-mcp  (:8101)
  ├── api-integration-hub        (:8102)
  └── content-automation-mcp     (:8103)

MCP Tools (via /mcp)

REST API

🛠️ Showcase Servers

These servers ship with the mcp-consulting-kit and are pre-registered in the FusionAL gateway:

Start the full showcase stack:

cd ../mcp-consulting-kit
docker compose up -d

🔒 Security Model

Docker Sandbox

Each code execution runs with:

• ✅ Network isolation (--network none)

• ✅ Memory limits (default 128 MB, configurable)

• ✅ Process limits (max 64 processes)

• ✅ Read-only filesystem (except /tmp)

• ✅ No privilege escalation

• ✅ Non-root user execution

API Security (optional)

When mcp-consulting-kit/showcase-servers/common/security.py is present, the gateway enables:

• API key authentication on /execute, /register, /generate

• Rate limiting

• CORS configuration

🪟 Windows-Specific Fixes

FusionAL documents and solves 6 Windows MCP failure modes not covered in official docs:

1. The 60-Second Silence — Claude Desktop times out with zero error. Caused by Docker socket init lag.
   Read the fix →

2. The BOM Trap — Notepad/VS Code injects a byte-order mark into JSON configs, silently breaking MCP.
   Fix: [System.IO.File]::WriteAllText(path, content, New-Object System.Text.UTF8Encoding($false))

3. The Backslash Trap — Windows path separators in claude_desktop_config.json break startup silently.
   Use forward slashes or escaped double backslashes.

4. %USERPROFILE% expansion — Claude Desktop does NOT expand env vars in config paths. Hardcode them.

5. Docker named pipe failure — Docker's named pipe transport fails on WSL2. Use /var/run/docker.sock.

6. Registry timeout at 8+ servers — Claude Desktop hits a timeout threshold on lower-end hardware.
   Cap your registry at 8 servers on i5/i7 7th gen and below.

🧰 Building Your Own MCP Server

Using the AI Builder (via Claude Desktop)

After connecting FusionAL, ask Claude:

"Generate an MCP server that queries our PostgreSQL database using natural language."

FusionAL generates the full project, builds it, and registers it in the gateway automatically.

Manual Server Structure

my-server/
├── Dockerfile
├── requirements.txt
├── my_server.py       ← FastMCP tools go here
└── .env

Key Rules

1. Use @mcp.tool() decorators on async functions

2. Single-line docstrings only (multi-line breaks some MCP clients)

3. Return formatted strings from all tools

4. Default parameters to "" not None

5. Log to sys.stderr

6. Run as non-root in Docker

from mcp.server.fastmcp import FastMCP
import sys

mcp = FastMCP("my-server")

@mcp.tool()
async def my_tool(query: str = "") -> str:
    """What this tool does in one line."""
    return f"✅ Result for: {query}"

if __name__ == "__main__":
    mcp.run(transport='stdio')

📚 Examples

🚀 Done-for-You Consulting

Don't want to self-manage? FusionAL offers done-for-you MCP deployments:

Book a free 15-min MCP security audit →

🤝 Contributing

Contributions welcome. Priority areas:

• New example servers

• Windows compatibility fixes

• Documentation improvements

• Test coverage

📄 License

MIT — see LICENSE

🙏 Credits

• Anthropic — Claude AI + MCP protocol

• FastAPI — API framework

• FastMCP — MCP server framework

• Docker — Container infrastructure

Built by a self-taught developer who fixed the MCP problems nobody else documented.
🌐 fusional.dev • ⭐ Star the repo if it saved you hours

🙌 Origin & Inspiration

FusionAL started with a NetworkChuck video.

If you haven't watched "you need to learn MCP RIGHT NOW!!" — go watch it first. Chuck explains the fundamentals better than anyone, and his docker-mcp-tutorial repo is the best starting point for understanding how MCP servers work with Docker.

The dice-roller example and quick-start structure in this repo are adapted from that tutorial (MIT licensed).

Where FusionAL goes further:

Chuck's tutorial shows you how to build MCP servers manually — edit a prompt template, paste it into Claude, implement the result yourself.

FusionAL removes the human from that loop entirely. Instead of a prompt file you copy-paste, generate_mcp_project is a live tool call — Claude describes what it wants built, FusionAL generates it, registers it, and runs it. No clipboard. No manual steps.

More importantly, Chuck's video covers Docker's MCP catalog — 300+ servers you can enable with a click. That's step one. FusionAL is what you need when a CTO asks:

"Great — but how do we audit what those tools are doing? How do we enforce policy? How do we make sure this doesn't become a security incident?"

That's the gap FusionAL was built to fill: governance, auditability, and operational control for teams deploying MCP at scale — especially on Windows, where the catalog alone isn't enough.