stac2026 — Kevin's Personal AI Infrastructure

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

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:

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

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