In Memoria

In Memoria

Persistent memory and pattern learning for AI coding assistants via MCP.

AI coding tools suffer from complete session amnesia. Every conversation with Claude, Copilot, or Cursor starts from scratch, forcing you to re-explain your codebase architecture, patterns, and preferences repeatedly.

In Memoria solves this by building persistent intelligence about your code that AI assistants can access through the Model Context Protocol - giving them memory that persists across sessions.

The Problem

Current AI tools:

• Re-analyze codebases every session (expensive)
• Give generic suggestions that don't match your style
• Have no memory of architectural decisions
• Can't learn from corrections you've made

Quick Start

How It Works

In Memoria runs as an MCP server that AI tools connect to. It provides 17 tools for codebase analysis and pattern learning.

Architecture:

Core engines:

• AST Parser (Rust): Tree-sitter parsing for TypeScript, JavaScript, Python, Rust, Go, Java, C/C++, C#, Svelte, Vue, and SQL
• Pattern Learner (Rust): Statistical analysis of naming conventions, function signatures, and architectural choices
• Semantic Engine (Rust): Code relationship mapping and concept extraction with timeout protection
• TypeScript Layer: MCP server, SQLite/SurrealDB operations, file watching
• Storage: SQLite for structured patterns, SurrealDB for vector search and semantic queries

What It Learns

In Memoria builds statistical models from your actual code to understand your preferences:

Naming Patterns:

Architectural Choices:

Code Structure Preferences:

Project Organization:

MCP Tools for AI Assistants

In Memoria provides 17 tools that AI assistants can use to understand your codebase:

Getting Started:

• get_learning_status - Check what intelligence exists for a project
• auto_learn_if_needed - Automatically learn from codebase if no intelligence exists
• quick_setup - Initialize In Memoria for a new project

Code Analysis:

• analyze_codebase - Get architectural overview, complexity metrics, and language breakdown
• get_file_content - Retrieve files with rich metadata and analysis
• get_project_structure - Understand directory hierarchy and organization patterns
• search_codebase - Semantic search that finds code by meaning, not just keywords

Pattern Intelligence:

• get_pattern_recommendations - Get coding suggestions that match your established style
• predict_coding_approach - Predict how you'd solve similar problems based on your patterns
• get_developer_profile - Access your learned coding preferences and decision patterns
• get_semantic_insights - Discover code relationships and architectural concepts

Learning & Memory:

• learn_codebase_intelligence - Manually trigger analysis of a codebase
• contribute_insights - Allow AI to add observations back to the knowledge base
• generate_documentation - Create docs that understand your project's patterns

System Monitoring:

• get_system_status - Health check and component status
• get_intelligence_metrics - Quality and completeness of learned patterns
• get_performance_status - System performance and benchmarking

Implementation Details

Pattern Learning Algorithm:

1. Parse code into ASTs using tree-sitter
2. Extract structural patterns (function signatures, class hierarchies, naming)
3. Build frequency maps of developer choices
4. Train classifier on decision patterns
5. Generate predictions for new code contexts

Performance:

• Smart file filtering - Automatically excludes build artifacts, dependencies, and generated files
• Timeout protection - Prevents analysis from hanging on complex files
• Fast analysis - Optimized processing that skips node_modules/, dist/, .next/, and other non-source files
• File size limits - Skips very large files to prevent memory issues
• Incremental analysis - Only processes changed files in subsequent runs
• SQLite for structured data, SurrealDB embedded for semantic search and vectors
• Cross-platform Rust binaries (Windows, macOS, Linux)
• Built-in performance profiling and memory leak detection
• Optimized for real-time file watching without blocking development workflow

Team Usage

In Memoria works for individual developers and teams:

Individual:

• Learns your personal coding style
• Remembers architectural decisions you've made
• Provides context-aware suggestions

Team:

• Share .in-memoria.db files containing learned patterns across team members
• Onboard new developers by providing pre-learned codebase intelligence
• Ensure consistent AI suggestions team-wide through shared pattern recognition

Technical Comparison

vs GitHub Copilot's memory:

• Copilot: Basic fact storage, no pattern learning
• In Memoria: Semantic analysis with prediction engine

vs Cursor's rules:

• Cursor: Static rules, manually defined
• In Memoria: Dynamic learning from actual code

vs Custom RAG:

• RAG: Retrieves relevant code snippets
• In Memoria: Understands coding patterns and predicts behavior

Build from Source

Requirements:

• Node.js 18+
• Rust 1.70+ (for building)
• 2GB RAM minimum

Quality & Testing:

• 98.3% unit test pass rate (118/120 tests)
• 100% MCP integration test coverage (23/23 tests)
• Comprehensive server lifecycle testing
• All Rust clippy warnings resolved
• Zero memory leaks verified

Development:

Contributing

This is infrastructure for the AI development ecosystem. Contributions welcome:

• Language support - Add tree-sitter parsers or extend file filtering
• Pattern learning improvements - Enhance statistical analysis and concept extraction
• MCP tool additions - New tools for AI assistant integration
• Performance optimizations - Further speed improvements and memory usage reduction
• Timeout and reliability - Additional safeguards for edge cases

See CONTRIBUTING.md for details.

FAQ

Q: Does this replace my AI coding assistant? A: No, it enhances them. In Memoria provides memory and context that AI tools can use.

Q: What data is collected? A: Everything stays local. No data is sent to external services.

Q: How accurate is pattern learning? A: Pattern recognition accuracy improves with codebase size and consistency. Projects with established patterns and consistent style will see better pattern detection than smaller or inconsistent codebases. The system learns from frequency and repetition in your actual code.

Q: Performance impact? A: Minimal. Runs in background with smart filtering that skips build artifacts and dependencies. Modern analysis engine with built-in safeguards for reliable operation.

Q: What file types are supported? A: TypeScript, JavaScript, Python, Rust, Go, Java, C/C++, C#, Svelte, Vue, and SQL with native AST parsing. Build artifacts and dependencies are automatically excluded.

Q: What if analysis encounters issues? A: Built-in reliability features handle edge cases gracefully. Large files and complex directories are processed efficiently with automatic fallbacks. Progress is shown during analysis.

License

MIT - see LICENSE

Try it: npx in-memoria server

Give your AI tools the memory they've been missing.