Stac2026

FastMCP 3 gateway orchestrating memory, automation, knowledge, and skills as a unified MCP stack.

Architecture

Claude Code / Any MCP Client
        │
        ▼
┌──────────────────────────────────────────┐
│  gateway.py  (Python FastMCP 3.0.0b2)    │
│  create_proxy — stdio transport          │
│  Auto-namespaces all child tools         │
├──────────────────────────────────────────┤
│                                          │
│  ┌─────────┐ ┌─────────┐ ┌───────────┐  │
│  │ memory  │ │   n8n   │ │ memoria   │  │
│  │ (Node)  │ │ (Node)  │ │  (Node)   │  │
│  └────┬────┘ └────┬────┘ └─────┬─────┘  │
│       │           │             │        │
│  ┌────┴────┐ ┌────┴────┐ ┌─────┴─────┐  │
│  │  lotus  │ │ skills  │ │ seq-think │  │
│  │ (npx)   │ │(Python) │ │  (npx)    │  │
│  └─────────┘ └─────────┘ └───────────┘  │
│                                          │
└──────────────────────────────────────────┘

sequential-thinking runs as a standalone MCP server (not proxied through gateway).

Servers

Server	Runtime	What it does	Tools/Data
memory	Node.js (openmemory)	Persistent memory store — store, search, recall	SQLite memory.sqlite
n8n	Node.js (n8n-mcp v2.27.2)	Workflow automation — trigger/manage n8n workflows	n8n API at 100.117.118.7:5678 (Tailscale)
memoria	Node.js (in-memoria)	Contextual project knowledge — learns codebases	SQLite in-memoria.db
lotus	npx (lotus-wisdom-mcp)	Wisdom/knowledge retrieval	GitHub-hosted, stateless
skills	Python (skills_server.py)	Skill discovery — 97 SKILL.md files as MCP Prompts	Scans ~/.claude/skills/, plugin caches

File Layout

D:\projects\.mcp-global\
├── gateway.py              # FastMCP 3 proxy hub (~25 lines)
├── skills_server.py        # Skill discovery + 3 management tools
├── openmemory\             # Memory MCP server (Node.js)
│   ├── server.js           # Entry point
│   ├── memory.js           # Core memory operations
│   ├── database.js         # SQLite adapter
│   └── memory.sqlite       # Persistent memory DB
├── n8n-mcp-kevin\          # n8n workflow MCP (Node.js)
│   └── dist\mcp\index.js   # Entry point
├── in-memoria\             # Contextual knowledge MCP (Node.js)
│   ├── dist\index.js       # Entry point
│   └── in-memoria.db       # Knowledge DB
└── in-memoria.db           # Root-level copy (legacy)

Configuration

Claude Code settings at C:\Users\kevin\.claude\settings.json:

{
  "mcpServers": {
    "mcp-gateway": {
      "command": "python",
      "args": ["D:\\projects\\.mcp-global\\gateway.py"]
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

Gateway starts on Claude Code session launch (stdio transport). All child servers spawn as subprocesses.

Skills System

skills_server.py scans 4 directories for SKILL.md files:

Directory	Source
~/.claude/skills/	User custom skills
~/.claude/plugins/cache/claude-plugins-official/	Official plugins
~/.claude/plugins/cache/claude-code-plugins-plus/	Community plugins
~/.claude/plugins/cache/claude-skills/	Skill packs

Each SKILL.md becomes an MCP Prompt (LLM-consumable). Three management tools:

• list_skills — enumerate all discovered skills
• get_skill — retrieve full content by name
• add_skill — create new SKILL.md in user skills dir

FastMCP 3 Capabilities (Available, Not Yet Used)

The gateway currently uses create_proxy — roughly 5% of what FastMCP 3 offers.

Composition

• mount() — nest servers hierarchically with namespacing
• import_server() — merge another server's tools into yours
• Replace flat proxy config with structured composition tree

OpenAPI Bridge

• FastMCP.from_openapi(spec, client) — any OpenAPI spec becomes MCP tools automatically
• FastMCP.from_fastapi(app) — wrap a FastAPI app as MCP in one line
• Zero-code integration for any REST API with an OpenAPI/Swagger spec

Middleware

• Rate limiting — throttle tool calls
• Logging — track what gets called, by whom
• Timing — latency monitoring per tool
• Error handling — structured error responses

Authentication

• OAuth2 — full OAuth server/client support
• JWT Bearer — token-based auth for remote access

Transport

• stdio — current (local only)
• SSE — server-sent events
• Streamable HTTP — production remote transport with custom headers
• Enables access from other machines, mobile, cloud

Context & DI

• Inject shared state (user prefs, session data) into any tool/resource/prompt
• Dependency injection across the server tree

Resource Templates

• Dynamic URI-based resources: memory://search/{query}, project://{name}/status
• Structured data access for LLMs

Tags

• Filter tools/resources per client or task context
• Serve different tool sets to different consumers

Client SDK

• Programmatic MCP client for building agents
• Agents that orchestrate tools across servers

Network

• n8n instance accessible via Tailscale at 100.117.118.7:5678
• Gateway runs locally (stdio) — no remote access yet
• Future: Streamable HTTP transport + bearer auth for remote access

Dependencies

Component	Version	Install
Python	3.12+	System
fastmcp	3.0.0b2	pip install fastmcp
Node.js	18+	System
npx	bundled with Node	—

Roadmap (stac2026)

1. Gateway v2 — composition tree + middleware (logging, timing)
2. OpenAPI bridge — auto-import n8n API, Notion API, other REST APIs as MCP tools
3. Remote access — Streamable HTTP transport + JWT auth (Tailscale + bearer token)
4. Agent layer — FastMCP client SDK for multi-agent orchestration
5. Resource layer — dynamic resources for memory, projects, context