Which integrations are available for this server?

Can be used as an LLM and embedder provider for the Graphiti knowledge graph, enabling knowledge graph operations with Google Gemini models. Can be used as an LLM and embedder provider for the Graphiti knowledge graph, enabling knowledge graph operations with local Ollama models. Can be used as an LLM and embedder provider for the Graphiti knowledge graph, enabling knowledge graph operations with OpenAI models.

How do I use Unified Dynamic MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Unified Dynamic MCP Server remember that my meeting is at 3pm" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Unified Dynamic MCP Server

by sasajib

Overview Schema Related Servers Score Discussions

Python

Local

Unified Dynamic MCP Server

Single MCP server with progressive discovery for 96-160x token reduction

Consolidates code understanding (Codanna), documentation (Context7), browser automation (Playwright), memory (Claude-mem), and knowledge graph (Graphiti+LadybugDB) into one unified server.

✨ NEW: Graphiti knowledge graph now supports Google Gemini! Use free Gemini API with embedded LadybugDB (no Docker required).

Features

✨ Progressive Discovery - 3-step pattern reduces tokens from 10,000+ to 50-200 🔧 Dynamic Tool Loading - Lazy load capabilities only when needed 🎯 5 Integrated Capabilities - Code, docs, browser, memory, knowledge graph 🚀 Git Submodules - Auto-update with git submodule update --remote ⚡ Fast - Sub-10ms symbol lookup (Codanna), embedded LadybugDB (no Docker)

Related MCP server: token-savior

Quick Start

# 1. Clone with submodules
git clone --recursive https://github.com/yourusername/unified-mcp.git
cd unified-mcp

# 2. Install dependencies (using uv - recommended)
uv pip install -r requirements.txt

# 3. Install Claude-mem plugin (required for memory capability)
# In Claude Code terminal:
/plugin marketplace add thedotmack/claude-mem
/plugin install claude-mem
# Then restart Claude Code

# 4. Add to Claude Code (replace /path/to/unified-mcp with actual path)
claude mcp add --transport stdio \
  unified-mcp \
  -- uv --directory /absolute/path/to/unified-mcp run server.py

# 5. For Graphiti + Google Gemini support (optional)
claude mcp add --transport stdio unified-mcp \
  -e GRAPHITI_ENABLED=true \
  -e GRAPHITI_LLM_PROVIDER=google_ai \
  -e GRAPHITI_EMBEDDER_PROVIDER=google_ai \
  -e GOOGLE_API_KEY=your-gemini-api-key-here \
  -e GRAPHITI_LLM_MODEL=gemini-1.5-pro \
  -e GRAPHITI_EMBEDDER_MODEL=text-embedding-004 \
  -- uv --directory /absolute/path/to/unified-mcp run server.py

# 6. Restart Claude Code and verify
# Ask Claude: "What tools do you have available?"

Manual Testing (optional):

# Run tests
pytest tests/ -v

# Start server directly
uv run server.py

Progressive Discovery Pattern

Traditional approach: Load all 20 tools upfront = 10,000 tokens

Our approach:

Search (search_tools) → Find relevant tools → ~50 tokens
Describe (describe_tools) → Get full schemas → ~200 tokens/tool
Execute (execute_tool) → Run the tool → Variable

Result: 98% token reduction 🎉

Architecture

Unified MCP Server
├── Progressive Discovery Engine
├── Dynamic Tool Registry
├── 5 Capability Modules
│   ├── Codanna (code understanding)
│   ├── Context7 (documentation)
│   ├── Playwright (browser automation)
│   ├── Claude-mem (memory)
│   └── Graphiti+LadybugDB (knowledge graph)

Installation

Requirements

Python 3.12+ (for LadybugDB)
Rust/Cargo (for Codanna) - Install Rust
Node.js 18+ (for Context7/Playwright) - Install Node
Claude Code (for Claude-mem plugin) - Install Claude Code

Claude-Mem Setup (Memory Capability)

Important: Claude-mem is a separate MCP server that runs as a Claude Code plugin. It must be installed before the unified-mcp memory capability will work.

Installation Steps:

Install via Claude Code Plugin Marketplace:

# In Claude Code terminal
/plugin marketplace add thedotmack/claude-mem
/plugin install claude-mem

Restart Claude Code - The plugin auto-starts the HTTP API on http://localhost:37777

Verify Installation:

# Check the service is running
curl http://localhost:37777

# Or visit the web UI
open http://localhost:37777

Troubleshooting:

# Use the built-in troubleshooting skill
/claude-mem:troubleshoot

What Gets Installed:

HTTP API service on port 37777 (auto-managed by Bun)
SQLite database at ~/.claude-mem/claude-mem.db
Web UI for browsing stored memories
5 lifecycle hooks for automatic memory capture
Vector search via Chroma for semantic queries

Architecture:

The unified-mcp server connects to claude-mem's HTTP API
No direct npm installation needed - plugin handles all dependencies
Auto-starts when Claude Code is running
Stores observations across sessions with semantic search

For more details, see the claude-mem documentation.

Install Dependencies

# Python dependencies
pip install -r requirements.txt

# Codanna (code understanding)
cargo install codanna --all-features

# Git submodules (for Context7 and Playwright only - claude-mem is a plugin)
git submodule update --init --recursive
cd capabilities/context7 && npm install
cd ../playwright-mcp && npm install
# Note: claude-mem is installed as a Claude Code plugin (see above), not via npm

Codanna Auto-Indexing:

The server automatically creates and manages Codanna indexes:

✅ Automatic indexing on first run (indexes src, lib, handlers, core directories)
✅ No manual setup required - just install Codanna and start the server
🔄 Optional file watching - enable watch_changes: true in config/catalog.yaml to auto-reindex on file changes

To customize auto-indexing, edit config/catalog.yaml:

code_understanding:
  auto_index: true  # Auto-create index if missing
  watch_changes: false  # Watch files and re-index (requires watchdog)
  index_dirs:  # Directories to index
    - src
    - lib
    - your-custom-dir

Usage

Start Server

python server.py

Server runs on stdio (MCP protocol).

Configure with Claude Code

Option 1: Using claude mcp add (Recommended)

Replace /absolute/path/to/unified-mcp with your actual installation path.

Basic Configuration (No Graphiti):

claude mcp add --transport stdio \
  unified-mcp \
  -- uv --directory /absolute/path/to/unified-mcp run server.py

With Graphiti + Google Gemini:

claude mcp add --transport stdio unified-mcp \
  -e GRAPHITI_ENABLED=true \
  -e GRAPHITI_LLM_PROVIDER=google_ai \
  -e GRAPHITI_EMBEDDER_PROVIDER=google_ai \
  -e GOOGLE_API_KEY=your-gemini-api-key-here \
  -e GRAPHITI_LLM_MODEL=gemini-1.5-pro \
  -e GRAPHITI_EMBEDDER_MODEL=text-embedding-004 \
  -- uv --directory /absolute/path/to/unified-mcp run server.py

With Graphiti + OpenAI:

claude mcp add --transport stdio unified-mcp \
  -e GRAPHITI_ENABLED=true \
  -e GRAPHITI_LLM_PROVIDER=openai \
  -e GRAPHITI_EMBEDDER_PROVIDER=openai \
  -e OPENAI_API_KEY=sk-your-openai-key-here \
  -e GRAPHITI_LLM_MODEL=gpt-4o \
  -e GRAPHITI_EMBEDDER_MODEL=text-embedding-3-small \
  -- uv --directory /absolute/path/to/unified-mcp run server.py

With Graphiti + Anthropic Claude + Voyage Embeddings:

claude mcp add --transport stdio unified-mcp \
  -e GRAPHITI_ENABLED=true \
  -e GRAPHITI_LLM_PROVIDER=anthropic \
  -e GRAPHITI_EMBEDDER_PROVIDER=voyage_ai \
  -e ANTHROPIC_API_KEY=sk-ant-your-key-here \
  -e VOYAGE_API_KEY=pa-your-voyage-key-here \
  -e GRAPHITI_LLM_MODEL=claude-3-5-sonnet-20241022 \
  -e GRAPHITI_EMBEDDER_MODEL=voyage-3 \
  -- uv --directory /absolute/path/to/unified-mcp run server.py

With Graphiti + Local Ollama (Free):

claude mcp add --transport stdio unified-mcp \
  -e GRAPHITI_ENABLED=true \
  -e GRAPHITI_LLM_PROVIDER=ollama \
  -e GRAPHITI_EMBEDDER_PROVIDER=ollama \
  -e OLLAMA_BASE_URL=http://localhost:11434 \
  -e GRAPHITI_LLM_MODEL=llama3.1 \
  -e GRAPHITI_EMBEDDER_MODEL=nomic-embed-text \
  -- uv --directory /absolute/path/to/unified-mcp run server.py

Full Configuration Example (All Options):

claude mcp add --transport stdio unified-mcp \
  -e CODANNA_INDEX_DIR=.codanna \
  -e CLAUDE_MEM_API_URL=http://localhost:37777 \
  -e GRAPHITI_ENABLED=true \
  -e GRAPHITI_LLM_PROVIDER=google_ai \
  -e GRAPHITI_EMBEDDER_PROVIDER=google_ai \
  -e GOOGLE_API_KEY=your-gemini-api-key-here \
  -e GRAPHITI_LLM_MODEL=gemini-1.5-pro \
  -e GRAPHITI_EMBEDDER_MODEL=text-embedding-004 \
  -e GRAPHITI_DB_PATH=.graphiti/ladybug.db \
  -- uv --directory /absolute/path/to/unified-mcp run server.py

Option 2: Manual Configuration

Add to your MCP settings file (~/.config/claude/mcp_settings.json):

{
  "mcpServers": {
    "unified-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/unified-mcp",
        "run",
        "server.py"
      ],
      "env": {
        "CODANNA_INDEX_DIR": "${workspaceFolder}/.codanna",
        "CLAUDE_MEM_API_URL": "http://localhost:37777",
        "GRAPHITI_ENABLED": "true",
        "GOOGLE_API_KEY": "your-gemini-api-key-here"
      }
    }
  }
}

With Graphiti + Google Gemini (Full Configuration):

{
  "mcpServers": {
    "unified-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/unified-mcp",
        "run",
        "server.py"
      ],
      "env": {
        "CODANNA_INDEX_DIR": "${workspaceFolder}/.codanna",
        "CLAUDE_MEM_API_URL": "http://localhost:37777",
        "GRAPHITI_ENABLED": "true",
        "GRAPHITI_LLM_PROVIDER": "google_ai",
        "GRAPHITI_EMBEDDER_PROVIDER": "google_ai",
        "GOOGLE_API_KEY": "your-gemini-api-key-here",
        "GRAPHITI_LLM_MODEL": "gemini-1.5-pro",
        "GRAPHITI_EMBEDDER_MODEL": "text-embedding-004"
      }
    }
  }
}

Environment Variables:

Variable	Required	Default	Description
`CODANNA_INDEX_DIR`	No	`.codanna`	Codanna index directory
`CLAUDE_MEM_API_URL`	No	`http://localhost:37777`	Claude-mem API endpoint
`GRAPHITI_ENABLED`	No	`false`	Enable Graphiti knowledge graph
`GRAPHITI_LLM_PROVIDER`	No	`openai`	LLM provider: `openai`, `anthropic`, `azure_openai`, `ollama`, `google_ai`
`GRAPHITI_EMBEDDER_PROVIDER`	No	`openai`	Embedder: `openai`, `voyage_ai`, `azure_openai`, `ollama`, `google_ai`
`GRAPHITI_LLM_MODEL`	No	(varies)	Model name (e.g., `gemini-2.5-flash`, `gpt-4o`, `claude-3-5-sonnet-20241022`)
`GRAPHITI_EMBEDDER_MODEL`	No	(varies)	Embedder model (e.g., `text-embedding-004`, `text-embedding-3-small`)
`GRAPHITI_RERANKER_MODEL`	No	`gemini-2.5-flash-lite`	Reranker model (Gemini only)
`GOOGLE_API_KEY`	If using Gemini	-	Google AI API key for Gemini
`OPENAI_API_KEY`	If using OpenAI	-	OpenAI API key
`ANTHROPIC_API_KEY`	If using Claude	-	Anthropic API key

Playwright Browser Configuration:

Browser automation runs with headless=false by default (shows browser window). Configure in config/catalog.yaml:

browser_automation:
  headless: false  # Set to true to run browser in background

Restart Claude Code to load the server.

Verify it's working:

Ask Claude: "What tools do you have available?"
You should see tools like search_tools, describe_tools, execute_tool, etc.

Configuration

Edit config/catalog.yaml:

capabilities:
  code_understanding:
    enabled: true  # Toggle capabilities
    tools: [search_code, get_call_graph, ...]

Tools Available

Progressive Discovery (Meta-tools):

search_tools(query) - Find relevant tools
describe_tools([names]) - Get full schemas
execute_tool(name, args) - Run a tool

Capability Management:

list_capabilities() - See all capabilities
enable_capability(name) - Enable at runtime
disable_capability(name) - Disable at runtime

Code Understanding (Codanna - Phase 2):

search_code - Semantic code search
get_call_graph - Function relationships
find_symbol - Symbol lookup (sub-10ms)
find_implementations - Find implementations

Documentation (Context7 - Phase 3):

resolve_library_id - Resolve library name
get_library_docs - Fetch documentation

Browser Automation (Playwright - Phase 3):

playwright_navigate - Navigate to URL
playwright_screenshot - Take screenshot
playwright_click - Click element
playwright_fill - Fill form field
playwright_evaluate - Execute JavaScript

Memory (Claude-mem - Phase 4):

mem_search - Search observations
mem_get_observation - Get by ID
mem_recent_context - Recent sessions
mem_timeline - Timeline view

Knowledge Graph (Graphiti - Phase 4):

store_insight - Store knowledge
search_insights - Search insights
query_graph - Cypher queries
add_episode - Add episode

Development

Run Tests

# All tests
pytest tests/ -v

# Unit tests only
pytest tests/unit/ -v

# With coverage
pytest tests/ --cov=. --cov-report=term-missing

# Skip slow tests
pytest tests/ -m "not slow"

Project Structure

unified-mcp/
├── server.py              # Main MCP server
├── config/
│   └── catalog.yaml       # Capability configuration
├── core/
│   ├── dynamic_registry.py
│   ├── progressive_discovery.py
│   └── capability_loader.py
├── handlers/             # Capability handlers
├── capabilities/         # Git submodules
├── tests/               # Comprehensive test suite
└── docs/                # Documentation

Implementation Status

✅ Phase 1: Foundation (Dynamic registry, progressive discovery)
✅ Phase 2: Codanna integration (4 code understanding tools)
✅ Phase 3: Context7 + Playwright (7 tools: docs + browser automation)
✅ Phase 4: Claude-mem + Graphiti (8 tools: memory + knowledge graph)
✅ Phase 5: Comprehensive testing (Unit + Integration + E2E, 80%+ coverage, CI/CD)
✅ Phase 6: Documentation (Complete)

License

Apache 2.0

References

This server cannot be installed

license - permissive license

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly
Lightport: Open-Sourcing Glama's AI Gateway
By punkpeye on April 27, 2026.
OpenAI
open source

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/sasajib/unified-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server