MCP Standards - Self-Learning AI Standards System

Stop repeating yourself. MCP Standards learns from your corrections automatically and updates your AI configuration.

MIT License Python 3.10+ MCP 1.0

The Problem

You keep telling your AI assistant the same things:

"Use uv not pip"
"Use uv not pip"
"Use uv not pip"

What if it learned after the 3rd time?

The Solution

MCP Standards learns from your corrections automatically:

You correct Claude 3 times: "use uv not pip"
MCP Standards detects the pattern
Preference promoted (80% confidence)
CLAUDE.md updated automatically
Claude never makes that mistake again

Before MCP Standards

You: "Use uv not pip" Claude: *ignores, uses pip again* You: "USE UV NOT PIP" Claude: *ignores again* You: "I TOLD YOU 10 TIMES, USE UV!!!"

After MCP Standards

You: "Use uv not pip" (correction #1) You: "Use uv not pip" (correction #2) You: "Use uv not pip" (correction #3) MCP Standards: ✅ Pattern learned! Added to CLAUDE.md Claude: *uses uv from now on, forever*

Features

✨ Self-Learning (THE Killer Feature)

Automatic Pattern Detection:

Learns from corrections (3+ occurrences)
Detects workflow patterns
Promotes to preferences automatically
Updates CLAUDE.md without manual work

5 Types of Learning:

Explicit corrections: "use X not Y"
Implicit rejections: User edits within 2 minutes
Rule violations: Compare vs config files
Workflow patterns: Always run tests after code
Tool preferences: Prefer certain tools for tasks

Confidence-Based Promotion:

3 occurrences = 30% confidence (detected)
5 occurrences = 70% confidence (high)
10 occurrences = 90% confidence (very high)
95%+ = auto-apply to CLAUDE.md

🎯 Automatic Standards Extraction

Reads your existing config files:

.editorconfig → Indentation, line endings
.prettierrc → Formatting, quotes
.eslintrc → Linting rules
pyproject.toml → Python config
package.json → JavaScript dependencies
Cargo.toml → Rust config

Auto-detects:

Project type (Python, JavaScript, Rust, Go, etc.)
Package manager (uv, npm, yarn, cargo, etc.)
Test framework (pytest, jest, vitest, etc.)
Build commands

Generates instruction files for:

Claude Desktop/Code (CLAUDE.md)
GitHub Copilot (.github/copilot-instructions.md)
Cursor (.cursor/rules/standards.mdc)

🔒 Production-Grade Security

Built with defense-in-depth:

✅ Path whitelist - Only allowed directories
✅ Input sanitization - No log injection
✅ Rate limiting - 100 patterns/min max
✅ Audit logging - Complete modification trail
✅ 100% local - No cloud, no tracking

🧠 Persistent Memory

Local SQLite database with FTS5
Full-text search (<50ms on 1M+ episodes)
Export to markdown
Project-specific vs global preferences

Quick Start

Install

# 1. Clone repository git clone https://github.com/airmcp-com/mcp-standards.git cd mcp-standards # 2. Install dependencies uv sync # 3. Configure Claude Desktop # Add to ~/Library/Application Support/Claude/claude_desktop_config.json: { "mcpServers": { "mcp-standards": { "command": "uv", "args": [ "run", "--directory", "/ABSOLUTE/PATH/TO/mcp-standards", "python", "run_server.py" ] } } } # Replace /ABSOLUTE/PATH/TO/ with your actual path! # Example: /Users/yourname/Projects/mcp-standards/run_server.py # 4. Restart Claude Desktop - you're done!

Option B: From PyPI (Recommended)

# Install from PyPI uv pip install mcp-standards # Configure Claude Desktop # Add to ~/Library/Application Support/Claude/claude_desktop_config.json: { "mcpServers": { "mcp-standards": { "command": "mcp-standards", "args": [] } } } # Restart Claude Desktop

🚀 60-Second Quickstart

Once Claude Desktop restarts, try this:

// 1. Store a preference right now add_episode( name="My First Preference", content="I prefer using TypeScript over JavaScript for new projects", source="user" ) // 2. Search for it search_episodes(query="TypeScript", limit=5) // 3. Generate AI standards from your current project generate_ai_standards(project_path=".")

What just happened?

✅ Your preference is stored in local SQLite database
✅ Searchable in all future conversations
✅ AI standards file generated from your project config

Next: Start correcting Claude when it makes mistakes. After 3 similar corrections, run:

get_learned_preferences(min_confidence=0.3)

You'll see MCP Standards has learned the pattern automatically!

Optional: Add Cost Optimization (99.5% Savings)

Want to save on AI costs? Add agentic-flow to route simple operations to cheaper models:

# Get free Gemini API key: https://aistudio.google.com/app/apikey # Add to your claude_desktop_config.json (alongside mcp-standards): { "mcpServers": { "mcp-standards": { ... }, "agentic-flow": { "command": "npx", "args": ["-y", "agentic-flow", "mcp"], "env": { "GEMINI_API_KEY": "your_gemini_api_key_here", "DEFAULT_MODEL": "gemini-1.5-flash", "SHOW_MODEL_USAGE": "true", "SHOW_COST_SAVINGS": "true", "LOG_LEVEL": "info" } } } }

What agentic-flow does:

Routes simple operations (memory, search) → Gemini Flash ($0.075/1M tokens)
Keeps complex operations (code gen) → Claude Sonnet ($15/1M tokens)
Shows which model was used for each operation
Displays cost savings in real-time
Saves ~$389/month on typical usage
100% optional - MCP Standards works perfectly without it

📖 Quick Start Guide

MCP Standards has two complementary systems for building your AI assistant's knowledge:

System 1: Episodes (Manual Knowledge - Immediate)

Store facts, preferences, and instructions right now:

// ✅ Store a preference immediately add_episode( name="Package Manager Preference", content="Always use uv instead of pip for Python. Example: uv pip install pytest", source="user" ) // 🔍 Search your stored knowledge search_episodes(query="package manager", limit=5) // Returns: Your uv preference with full context // 📋 List recent additions list_recent(limit=10) // Returns: Last 10 episodes you added

When to use Episodes:

✅ Store a preference immediately
✅ Document project-specific facts
✅ Save code examples and snippets
✅ Build a searchable knowledge base

System 2: Learned Preferences (Auto Pattern Detection - Over Time)

The system automatically learns from repeated corrections:

// 🤖 You DON'T call these - they happen automatically! // Example: You correct Claude 3+ times: "Use uv instead of pip" // → System detects pattern // → Creates learned preference with confidence score // 📊 Check what patterns were detected automatically get_learned_preferences(min_confidence=0.3) // Returns: Preferences learned from corrections with confidence scores // Example: { preference: "use uv over pip", confidence: 0.85, occurrences: 5 } // 💡 Get AI-suggested CLAUDE.md updates suggest_claudemd_update( project_path="./my-project", min_confidence=0.7 ) // Returns: "Add rule: Use uv for package management (confidence: 0.85)" // ✍️ Apply learned patterns to your CLAUDE.md update_claudemd( file_path="./CLAUDE.md", min_confidence=0.7 ) // Automatically updates CLAUDE.md with high-confidence learned patterns

Learned preferences build automatically when:

🔄 You correct the same thing 3+ times
🔄 Patterns emerge across different projects
🔄 Confidence scores reach thresholds:
- 0.3 = Emerging pattern (2-3 corrections)
- 0.7 = Strong preference (5-7 corrections)
- 0.9 = Very confident (10+ corrections)

🎯 Practical Example: Teaching Claude to Use `uv`

Scenario: You want Claude to always use uv instead of pip

Option A: Store Immediately (Recommended for new preferences)

add_episode( name="Python Package Manager", content="User prefers uv over pip. Always use: uv pip install <package>", source="user" )

✅ Available immediately in search ✅ Works in current session ✅ Manual but fast

Option B: Let System Learn (Automatic over time)

Day 1: Correct Claude: "Use uv instead of pip" → Pattern #1 detected
Day 3: Correct again on different project → Pattern #2 detected
Day 7: Correct third time → Learned preference created (confidence: 0.3)
Day 14: Fourth correction → Confidence increases to 0.7
Run get_learned_preferences() → See the pattern
Run suggest_claudemd_update() → Get suggestion to add to CLAUDE.md
Run update_claudemd() → Automatically updates your config file

✅ Builds confidence scores ✅ Suggests CLAUDE.md updates ✅ Automatic but slower

🚀 Best Practice: Use Both!

Store critical preferences immediately with add_episode()
Let the system learn patterns over time from corrections
Review learned preferences monthly with get_learned_preferences()
Update CLAUDE.md when confidence scores are high (0.7+)

🔧 Generate Standards from Existing Project

// Auto-generate CLAUDE.md from existing config files generate_ai_standards(project_path=".") // Analyzes: .editorconfig, .prettierrc, eslint.config.js, pyproject.toml // Generates: CLAUDE.md, .github/copilot-instructions.md, .cursor/rules/

How It Works

Pattern Learning Pipeline

User Correction → Pattern Extraction → Frequency Tracking → Confidence Scoring → Preference Promotion → CLAUDE.md Update

Example Flow:

User says: "Actually, use uv not pip"
Pattern extractor detects: "use uv instead of pip"
Frequency tracker increments: occurrence #1
Repeat 2 more times → occurrence #3
Promotion engine creates preference (confidence 0.3)
User approves → CLAUDE.md updated
Future sessions → Claude sees preference in context

Database Schema

-- Pattern frequency (tracks occurrences) CREATE TABLE pattern_frequency ( pattern_key TEXT UNIQUE, occurrence_count INTEGER, confidence REAL, promoted_to_preference BOOLEAN ); -- Tool preferences (learned rules) CREATE TABLE tool_preferences ( category TEXT, preference TEXT, confidence REAL, apply_count INTEGER, project_specific BOOLEAN ); -- Audit log (security trail) CREATE TABLE audit_log ( action TEXT, target_path TEXT, details TEXT, success BOOLEAN, timestamp TIMESTAMP );

What Makes MCP Standards Different?

Feature	MCP Standards	Tabnine	Copilot	Other MCPs
Learns from corrections	✅ Auto	❌ No	❌ No	❌ No
Updates CLAUDE.md	✅ Auto	N/A	N/A	❌ Manual
Pattern detection	✅ 5 types	❌ No	❌ No	❌ No
100% local	✅ Yes	❌ Cloud	❌ Cloud	✅ Varies
Open source	✅ MIT	❌ No	❌ No	✅ Varies
Security features	✅ 4 layers	⚠️ Basic	⚠️ Basic	⚠️ Varies

Unique Value Proposition: MCP Standards is the ONLY system that learns from your corrections and automatically updates your AI configuration.

Documentation

Guides

Quick Start - 5-minute setup
Self-Learning Guide - How pattern learning works
Security Guide - Security features explained
Integration Guide - Setup for all AI assistants
Config Standards - Universal config reference

Technical

Architecture - System design
Self-Learning PRD - Product requirements document

MCP Tools

Core Memory

add_episode(name, content) - Save knowledge
search_episodes(query, limit) - Full-text search
list_recent(limit) - Recent episodes

Pattern Learning

get_learned_preferences(category, min_confidence) - View learned patterns
suggest_claudemd_update(project_path) - Get suggestions
update_claudemd(file_path, min_confidence) - Apply updates

Standards Generation

generate_ai_standards(project_path, formats) - Auto-generate from config files
export_to_markdown(export_path) - Export knowledge base

Requirements

Python 3.10 or higher
Claude Desktop or Claude Code
MCP 1.0+

Supported Config Files

Formatting:

.editorconfig
.prettierrc / .prettierrc.json
.eslintrc / .eslintrc.json

Languages:

pyproject.toml (Python - Black, Ruff, Poetry, uv)
package.json (JavaScript/TypeScript)
Cargo.toml (Rust)
go.mod (Go)

More coming: Ruby, PHP, Java, C#

Cost Optimization (Optional)

By default, MCP Standards uses Claude Sonnet for all operations. You can optionally configure it to use 99.5% cheaper models for simple operations:

Setup Gemini Flash (Recommended)

Get free API key: https://aistudio.google.com/app/apikey
Add to your environment:
export GEMINI_API_KEY="your_key_here" # Or add to ~/.bashrc or ~/.zshrc
Automatic routing:
- Simple operations (memory CRUD, searches) → Gemini 1.5 Flash ($0.075/1M tokens)
- Complex operations (code generation, pattern analysis) → Claude Sonnet ($15/1M tokens)
- 99.5% cost savings on routine operations

Powered by Agentic Flow

MCP Standards uses agentic-flow for intelligent model routing and cost optimization.

Features:

Automatic model selection based on task complexity
Support for 20+ AI providers (Anthropic, Google, OpenRouter, Groq, etc.)
Fallback chains for reliability
Token usage tracking

Learn more: agentic-flow documentation

Roadmap

✅ v0.1.0 (October 2025 - Current)

Self-learning pattern detection
CLAUDE.md auto-generation
Config file parsing
Security enhancements (whitelist, sanitization, rate limiting, audit logs)
100% local with SQLite + FTS5

🔄 v0.2.0 (Q1 2026)

Implicit rejection detection (user edits within 2 min)
Rule violation detection (compare vs config files)
Workflow pattern learning (test after code changes)
Cross-project promotion (project → global)
MCP notifications for pattern promotions

🔮 v0.3.0 (Q2 2026)

Team sync (share learned preferences)
Analytics dashboard (trends, common corrections)
Cloud backup (optional)
Multi-project management
Priority support

Contributing

We welcome contributions! See CONTRIBUTING.md for:

How to report bugs
How to request features
Development setup
Code standards

License

MIT License - see LICENSE for details

Support

GitHub Issues: Report bugs or request features
Discussions: Ask questions or share ideas
Email: matt.strautmann@gmail.com

Built With

Python 3.10+
SQLite with FTS5 (full-text search)
MCP (Model Context Protocol)
uv (fast Python package manager)

Acknowledgments

Anthropic for Claude and MCP
agentic-flow for intelligent model routing and cost optimization
The open source community
Everyone who tested early versions

Made with ❤️ by

Stop repeating yourself. Start using MCP Standards.

⭐ Star us on GitHub if this helps you!