Memdocs

io.github.silversurfer562由 GitHub 账号 silversurfer562 发布v2.1.4更新于 Oct 25, 2026

Git-native project memory for AI assistants with enterprise-grade audit compliance

已验证STDIO仅桌面知识与记忆开发者工具

概览

AI 生成的概览

MemDocs 是一个基于 Git 的项目记忆服务器，用 Claude 为代码生成文档，并通过 MCP 把这些上下文提供给 AI 助手。

可以做什么
按文件、模块或仓库级别生成文档并存入 .memdocs 目录，随代码一起提交，以 JSON、YAML 和 Markdown 记录符号、API 与决策摘要。检索已存储的项目记忆，支持本地关键词搜索，也可选用本地向量嵌入，并把相关上下文返回给助手。查看记忆统计信息，并把记忆导出为 Cursor 等其他格式。向兼容 MCP 的助手提供记忆，使其能跨会话请求项目上下文。
适用场景
适合希望助手在会话之间保留项目上下文、又不想依赖云服务的场景，尤其是只审查变更文件的大型仓库。也适合希望通过 Git 共享记忆的团队，以及新人上手和代码评审准备。
运行要求
作为 Python 包在桌面机器上本地运行（可用 pip 安装或通过 uvx 启动）。需要 ANTHROPIC_API_KEY 用于 Claude 摘要与分析，并用 PROJECT_ROOT 指定项目目录。可选的嵌入功能需要额外安装；检索不依赖云服务。
安装前请注意
会把代码发送到 Anthropic 的 Claude API 进行摘要，按次产生费用，README 给出了按文件和按提交的成本。它会向项目写入文档文件，并可安装每次提交时运行的 Git 钩子。可选的 PHI/PII 检测与脱敏默认关闭，未启用时敏感代码可能被发送到 API。README 提到企业授权条款。

安装

在 SourceWeft 中

  1. 打开 控制台中的 Memdocs，将其添加到工作区。
  2. 为需要使用其工具的对话启用该服务。

Desktop only，通过 STDIO。 STDIO 服务会启动本地进程，因此需要 SourceWeft 桌面宿主。

其他 MCP 客户端

参照 仓库 中的启动说明。

README

MemDocs 🧠

Persistent Memory for AI Projects

[CI] [codecov] [Python 3.10+] [PyPI version] [License] [Code style: black]

Features • Quick Start • Complete Stack • Empathy Integration • Documentation • Examples • Contributing

🚀 The Complete Stack for 10x+ Productivity

VS Code + Claude Code (latest) + MemDocs + Empathy = 10x+ Productivity

Documented user experience: Transformational productivity through Level 4-5 AI collaboration

📖 Learn More:

🎯 What is MemDocs?

MemDocs is a git-native memory management system that gives AI assistants persistent, project-specific memory. It generates structured, machine-readable documentation that lives in your repository—no cloud services, no recurring costs, just local/git-based storage that enhances AI context and team collaboration.

💡 The Problem

AI assistants like ChatGPT and GitHub Copilot have no memory between sessions. Every conversation starts from scratch, forcing you to repeatedly explain your codebase, architecture decisions, and project context.

Result: AI stuck at Level 1-2 (Reactive) - can only respond after being asked, can't predict future needs, can't learn from patterns.

✨ The Solution

MemDocs creates a persistent memory layer that unlocks Level 4-5 AI collaboration:

  • 🧠 Remembers your project across sessions (via .memdocs/ directory)
  • 🔮 Enables predictions 30-90 days ahead (Level 4 Anticipatory Empathy)
  • 👥 Shares memory with your team (committed to git)
  • 💰 2000x cost savings vs full repo reviews ($0.03 vs $60)
  • ⚡ Works offline (no cloud dependencies for retrieval)
  • 🤝 Integrates with Empathy Framework (Level 4 Anticipatory Intelligence)
  • 🔒 Privacy-first (optional PHI/PII detection and redaction)

Enterprise ROI: 6,000% return on investment (documented across 10-1,000 developer teams)

🚀 Quick Start

Installation

bash
# From PyPI (recommended)pip install memdocs
# With optional featurespip install memdocs[embeddings]  # Local vector searchpip install memdocs[all]         # All features
# From sourcegit clone https://github.com/Smart-AI-Memory/memdocs.gitcd memdocspip install -e ".[dev,embeddings]"

Basic Usage

bash
# 1. Set your Claude API keyexport ANTHROPIC_API_KEY="your-key-here"
# 2. Initialize MemDocs in your project (MCP enabled by default!)cd your-projectmemdocs init
# 3. Set up automatic updates (recommended)memdocs setup-hooks --post-commit
# 4. Document changed filesmemdocs review --changed
# 5. Search your project memorymemdocs query "payment processing"
# 6. Show memory statsmemdocs stats

Large Repository Workflow

bash
# For repos with 1,000+ files: use git integrationmemdocs initmemdocs setup-hooks --post-commit  # Auto-review on every commit
# Work normally - memory updates automatically!git add file.pygit commit -m "refactor: improve performance"# MemDocs reviews changed files automatically (5-15 seconds)
# Or manually review only changesmemdocs review --changed        # Modified files onlymemdocs review --since main     # Your branch changesmemdocs review --since HEAD~10  # Last 10 commits

Your First Documentation

bash
# Document a specific filememdocs review --path src/main.py
# Output:# ✨ Analyzing src/main.py...# 📝 Generating documentation with Claude Sonnet 4.5...# ✅ Documentation saved to .memdocs/docs/main/#    - index.json (machine-readable)#    - symbols.yaml (code map)#    - summary.md (human-readable)

✨ Key Features

🧠 Git-Native Memory

  • All documentation stored in .memdocs/ directory
  • Committed alongside your code (same git workflow)
  • Version controlled memory (track how project evolves)
  • Team collaboration built-in (push/pull memory with code)

🎯 Smart Scoping

  • File-level (default): Document individual files
  • Module-level: Document entire directories
  • Repo-level: Full codebase overview
  • Auto-escalation: Automatically increases scope for important changes

🤖 AI-Powered Summarization

  • Claude Sonnet 4.5: Latest and most capable model
  • Intelligent extraction: Symbols, APIs, architecture decisions
  • Multi-format output: JSON, YAML, Markdown
  • Token-efficient: Only summarizes, doesn't embed

🔍 Semantic Search (Optional)

  • Local embeddings: sentence-transformers (no API costs)
  • Vector search: FAISS for fast similarity search
  • Automatic indexing: Updates as you document
  • No cloud lock-in: Everything runs locally

📈 Enterprise Scale - Large Repository Support

MemDocs scales to codebases of any size through intelligent git integration:

  • Review only what changed: memdocs review --changed reviews modified files only
  • Branch-aware: memdocs review --since main reviews your branch changes
  • Automatic updates: Git hooks keep memory current on every commit
  • Cost-effective: 2000x cheaper than full repo reviews ($0.03 vs $60)
  • Lightning fast: 15 seconds instead of hours

Perfect for large repos (1,000+ files):

bash
# One-time setupmemdocs initmemdocs setup-hooks --post-commit
# Every commit after: automatic memory updates!git commit -m "fix: bug in auth"  # Reviews 5 files, takes 15s, costs $0.03

Cost comparison:

Repo SizeFull ReviewChanged FilesSavings
10,000 files$60 + 2-4 hours$0.03 + 15 seconds2000x
5,000 files$30 + 1-2 hours$0.02 + 10 seconds1500x
1,000 files$6 + 15 minutes$0.01 + 5 seconds600x

🔌 MCP Server (Model Context Protocol)

  • Real-time memory serving: Serve memory to AI assistants via MCP
  • Claude Desktop integration: Auto-loaded context in Claude Desktop
  • Cursor/Continue.dev support: Works with MCP-compatible tools
  • Query-based context: AI requests exactly what it needs
  • Auto-start: Automatically detect and serve memory when opening projects

Quick setup for Claude Desktop:

bash
# Start MCP servermemdocs serve --mcp
# Or auto-start in VS Code (add to .vscode/tasks.json)# See docs/guides/mcp-setup.md for details

🚀 The Complete Stack: Transformational Productivity

When you combine the right tools, productivity isn't linear—it's exponential.

VS Code + Claude Code (latest) + MemDocs + Empathy = 10x+ Productivity

The four components work synergistically:

ComponentRoleWhat It Enables
VS CodeProfessional IDETested environment, task automation, MCP auto-start
Claude Code (VS Code extension)AI pair programmingMulti-file editing, command execution, real-time assistance
MemDocsPersistent memory layerPattern detection, trajectory tracking, cross-session learning
Empathy Framework5-level maturity modelLevel 4-5 anticipatory suggestions, structural design

Real-world results:

  • 10x+ efficiency improvement (documented user experience)
  • Lower cost: 2000x cheaper than full repo reviews
  • Higher quality: Problems predicted and prevented
  • Faster delivery: Anticipatory design eliminates bottlenecks

Quick setup (5 minutes):

bash
# Install VS Code: https://code.visualstudio.com# Install Claude Code extension in VS Code: https://claude.ai/claude-codepip install empathy-framework[full]>=1.6.0  # Empathy 1.6.0+ includes MemDocscd your-project/memdocs init  # Auto-configures MCP for Claude Codeempathy-os configurecode .  # Open in VS Code - MCP server auto-starts!

Result: Claude Code in VS Code operates at Level 4-5 (anticipatory) instead of Level 1-2 (reactive)

🔗 Empathy Framework Integration: Level 4-5 AI Collaboration

MemDocs unlocks Level 4 Anticipatory Empathy when integrated with the Empathy Framework.

The Five Levels of AI Collaboration:

LevelNameBehaviorMemory RequiredExample
1ReactiveHelp after being askedNoneChatGPT: "You asked, here it is"
2GuidedCollaborative explorationSession only"Let me ask clarifying questions"
3ProactiveAct before being askedMemDocs patterns"I pre-fetched what you usually need"
4AnticipatoryPredict future needs (30-90 days)MemDocs trajectory"Next week's audit—docs ready"
5SystemsDesign structural solutionsMemDocs cross-project"I built a framework for all cases"

Why MemDocs is Essential:

  • 🔄 Level 3 (Proactive): MemDocs stores user patterns across sessions
  • 🔮 Level 4 (Anticipatory): MemDocs tracks system trajectory for predictions
  • 🏗️ Level 5 (Systems): MemDocs identifies leverage points across projects

Without persistent memory, AI is stuck at Level 1-2 forever.

📚 Deep Dive Resources:

Integration features:

  • ✅ Works seamlessly with Empathy framework (1.6.0+)
  • ✅ Supports Level 4 Anticipatory Empathy workflows
  • ✅ Bidirectional sync (MemDocs ↔ Empathy)
  • ✅ Trust-building behaviors powered by persistent memory
  • ✅ 16 software development wizards (security, performance, testing, etc.)
  • ✅ 18 healthcare documentation wizards (SOAP notes, SBAR, assessments, etc.)

🔒 Privacy & Security

  • PHI/PII detection: Automatic sensitive data detection
  • Redaction: Optional redaction modes (off, standard, strict)
  • HIPAA/GDPR aware: Configurable privacy settings
  • Local-first: No required cloud dependencies

📖 Documentation

Configuration

Create .memdocs.yml in your project root:

yaml
version: 1
# Scope policy (controls memory granularity)policies:  default_scope: file          # file | module | repo  max_files_without_force: 150
  # Auto-escalate for important changes  escalate_on:    - cross_module_changes      # Multi-module = bigger context    - security_sensitive_paths  # auth/*, security/* = thorough docs    - public_api_signatures     # API changes = team awareness
# Output configuration (git-committed memory)outputs:  docs_dir: .memdocs/docs       # Committed to git  memory_dir: .memdocs/memory   # Committed to git  formats:    - json                      # index.json (machine-readable)    - yaml                      # symbols.yaml (code map)    - markdown                  # summary.md (human-readable)
# AI configuration (Claude API)ai:  provider: anthropic  model: claude-sonnet-4-5-20250929  # Claude Sonnet 4.5 (latest)  max_tokens: 8192  temperature: 0.3              # Lower = more deterministic
# Privacy (optional, for sensitive codebases)privacy:  phi_mode: "off"               # off | standard | strict  scrub:                        # Types of sensitive data to redact    - email    - phone    - ssn    - mrn  audit_redactions: true        # Log all redactions for compliance
# Exclude patternsexclude:  - node_modules/**  - .venv/**  - __pycache__/**  - "*.pyc"  - dist/**  - build/**

💼 Use Cases

1. Enterprise-Scale Codebases (1,000+ files)

Problem: Full repository reviews cost $60+ and take hours. Often fail due to token limits.

Solution: Git-aware incremental updates.

bash
# Day 1: One-time setup (5 minutes)cd large-monorepo  # 10,000 filesmemdocs initmemdocs setup-hooks --post-commitmemdocs review --path src/core/  # Review critical paths first
# Every day after: Zero effort!# Just commit normally...git commit -m "feat: add caching layer"# Hook reviews 7 changed files# Takes 15 seconds, costs $0.02# Memory stays current automatically!
# 100 commits later: $2 total# vs $60 per full review = 3,000% cost savings

Real numbers from production use:

  • 10,000 file Python monorepo
  • 200 commits/week
  • Cost: $4/week with hooks vs $240/week without
  • 98% cost reduction

2. Onboarding New Developers

bash
# New team member clones repogit clone <your-repo>cd your-repo
# MemDocs memory already there!memdocs query "authentication flow"memdocs query "database schema"

Result: Instant context about the project without asking teammates.

3. AI Assistant Context

python
from pathlib import Pathfrom memdocs.index import MemoryIndexerimport anthropic
# Get project context from MemDocsindexer = MemoryIndexer(    memory_dir=Path(".memdocs/memory"),    use_embeddings=True  # Requires: pip install memdocs[embeddings])results = indexer.query_memory("payment processing", k=5)
# Build context for Claudecontext = "\n".join([r["metadata"]["summary"] for r in results])
# Claude now has project memoryclient = anthropic.Anthropic()response = client.messages.create(    model="claude-sonnet-4-5-20250929",    system=f"Project context:\n{context}",    messages=[{"role": "user", "content": "Explain the charge flow"}])

Result: Claude remembers your project structure and decisions.

4. Code Review Preparation

bash
# Before opening PRmemdocs review --path src/new-feature/
# MemDocs generates:# - Feature summary# - API changes# - Breaking changes# - Migration notes

Result: Reviewers get structured context automatically.

5. Empathy Framework Integration

python
from memdocs.empathy_adapter import adapt_empathy_to_memdocs
# Empathy analysis resultsanalysis = {    "current_issues": [...],    "predictions": [...]}
# Convert to MemDocs formatdoc_index = adapt_empathy_to_memdocs(    analysis,    file_path="src/compliance/audit.py",    memdocs_root=".memdocs")

Result: Level 4 Anticipatory Empathy powered by project memory.

🏗 Architecture

Storage Structure

your-project/├── .memdocs/│   ├── docs/│   │   ├── <filename>/│   │   │   ├── index.json          # Machine-readable index│   │   │   ├── symbols.yaml        # Code symbols/API map│   │   │   └── summary.md          # Human-readable summary│   └── memory/│       ├── embeddings.json         # Optional: Local vector embeddings│       └── search.index            # Optional: FAISS index├── .memdocs.yml                    # Configuration└── src/    └── ... your code ...

How It Works

mermaid
graph LR    A[Code] -->|tree-sitter| B[Extract Symbols]    B --> C[Analyze Context]    C -->|Claude Sonnet 4.5| D[Generate Summary]    D --> E[Store in .memdocs/]    E --> F[Git Commit]    F --> G[Team Collaboration]
    H[Query] --> I[Local Search]    I --> J[Return Context]
    style D fill:#f9f,stroke:#333    style E fill:#bfb,stroke:#333
  1. Extract: tree-sitter parses code (Python, JS, TS, Go, Rust, etc.)
  2. Analyze: Identifies symbols, imports, APIs, patterns
  3. Summarize: Claude generates concise summaries with insights
  4. Store: Saves structured docs in .memdocs/ directory
  5. Retrieve: Fast local search (grep-based or vector-based)

Token Efficiency

  • Summarization only: ~1K tokens per file
  • No embeddings API: Optional local embeddings only
  • Local search: Instant, free, no API calls
  • Cost: ~$0.10 per 100 files documented

🔧 CLI Reference

memdocs init

Initialize MemDocs in a project.

bash
memdocs init [--force]

memdocs review

Generate memory documentation.

bash
# File-level (recommended)memdocs review --path src/payments/charge.py
# Module-levelmemdocs review --path src/payments/ --scope module
# With scope detectionmemdocs review --path src/
# Export to Cursormemdocs review --path src/ --export cursor

memdocs query

Search project memory (requires embeddings).

bash
memdocs query "authentication flow"memdocs query "database schema" --k 10

memdocs stats

Show memory statistics.

bash
memdocs statsmemdocs stats --format json

memdocs export

Export memory to other formats.

bash
memdocs export --format cursormemdocs export --format json --output memory.json

🔌 Integrations

Model Context Protocol (MCP)

MemDocs includes an MCP server for Claude Desktop:

json
{  "mcpServers": {    "memdocs": {      "command": "memdocs",      "args": ["mcp-server"],      "cwd": "/path/to/your/project"    }  }}

Cursor Integration

bash
# Export memory for Cursormemdocs export --format cursor
# Cursor automatically picks up .memdocs/ directory

Python API

python
from memdocs.index import MemoryIndexerfrom memdocs.summarize import Summarizerfrom memdocs.extract import Extractor
# Initialize componentsindexer = MemoryIndexer(memory_dir=".memdocs/memory", use_embeddings=True)summarizer = Summarizer()extractor = Extractor()
# Extract and documentcontext = extractor.extract_file("src/main.py")doc_index, markdown = summarizer.summarize(context, scope_info)
# Index for searchindexer.index_document(doc_index, markdown)
# Queryresults = indexer.query_memory("authentication", k=5)

💼 Enterprise ROI: The Numbers That Matter

MemDocs + Empathy delivers measurable productivity gains at any scale.

Cost Savings Examples

Team SizeAnnual CostTime Saved/YearValue @ $150/hrROI
10 developers$2,000799 hours$119,8506,000%
100 developers$20,0007,990 hours$1,198,5006,000%
1,000 developers$198,00079,900 hours$11,985,0006,000%

But the real value isn't just hours saved—it's crises prevented.

How much is it worth to:

  • ✅ Never miss a compliance audit?
  • ✅ Never hit a scaling bottleneck?
  • ✅ Never spend 40 hours in emergency bug-fix mode?
  • ✅ Scale to enterprise size without linear cost increases?

That's the difference between Level 1 (reactive) and Level 4 (anticipatory).

Why Enterprise Teams Choose This Stack

  • 🎯 Proven at scale: Built for and tested with enterprise-scale codebases (10,000+ files)
  • 📊 Measurable productivity: 10x+ documented improvement (not theoretical)
  • 💰 Lower cost than alternatives: 2000x cheaper than full repo reviews
  • 🔒 Security & compliance: PHI/PII detection, HIPAA/GDPR-aware, audit trails
  • 🏢 Commercial-ready: Fair Source licensing, clear commercial terms
  • 🤝 Vendor support: Direct access to core development team

Enterprise licensing: $99/developer/year (6+ employees) Free tier: Students, educators, and small teams (≤5 employees)

📊 Comparison

FeatureMemDocs + EmpathyVector DBsGitHub CopilotCursor
StorageGit-nativeCloudCloudCloud
Monthly cost$0 storage$$$$10-20$20
Team sharing✅ Built-in⚠️ Separate❌ None❌ None
Offline✅ Yes❌ No❌ No❌ No
Privacy✅ Local⚠️ Cloud⚠️ Cloud⚠️ Cloud
Memory persistence✅ Permanent✅ Permanent❌ Session⚠️ Limited
Level 4 Prediction✅ 30-90 days❌ No❌ No❌ No
Empathy integration✅ Native❌ No❌ No❌ No
Productivity gain10x+ (documented)1-2x2-3x2-3x
API callsOnly for docsAlwaysAlwaysAlways

🗺 Roadmap

See PRODUCTION_ROADMAP.md for detailed 4-week production plan.

Version 2.1 (Q1 2025)

  • VS Code extension
  • Enhanced CLI with rich output
  • Incremental documentation updates
  • Custom prompt templates

Version 2.2 (Q2 2025)

  • JetBrains plugin
  • Multi-language support (Go, Rust, Java, C++)
  • Memory compression (auto-summarize old docs)
  • Team analytics dashboard

Version 3.0 (Q3 2025)

  • MemDocs Cloud (optional hosted version)
  • Enterprise features (SSO, RBAC, audit logs)
  • Advanced Empathy integration
  • GitHub App for automatic PR documentation

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Quick links:

Key areas needing help:

  • Multi-language AST parsing (Go, Rust, Java, C++)
  • IDE plugins (VS Code, JetBrains)
  • Documentation improvements
  • Example projects

📄 License

Apache License 2.0 - See LICENSE for details.

💬 Support & Community

📚 Additional Resources

🙏 Acknowledgments

Created by: Patrick Roebuck (Smart AI Memory)

Powered by:

Special thanks to:

  • The Empathy Framework team
  • Early adopters and beta testers
  • The open-source community

🧠 MemDocs: Because AI should remember your project, not forget it every session.

The first git-native AI memory system with Level 4 Anticipatory Empathy.

Made with ❤️ by Smart-AI-Memory (Deep Study AI, LLC)

Transforming AI-human collaboration from reactive responses to anticipatory problem prevention.

Get Started • View Examples • Complete Stack • Enterprise ROI • Contribute

来源：README.md，提交 62dc0b8

工具

0
SourceWeft 尚未在沙箱中启动过该软件包，因此其工具未知。

版本历史

1
  1. v2.1.4最新Sep 16, 2026

评分

已满足适用检查项的 50%

该评分衡量此收录条目的完整程度，依据注册中心条目、端点与公开来源计算得出。它不是对服务器本身的评价，也不表示服务器安全或当前可用：可连通性是带日期的检查结果，评分也不包含安装量或用户评价。

  • 近 30 天内可连通25 分

    请保持端点能够响应 MCP 握手；SourceWeft 每 30 天探测一次。

  • 已声明认证方式10 分

    请在注册中心条目中声明凭据请求头，或保持端点能够响应探测，以便判定其认证方式。

  • 已列出工具15 分

    请让服务器在无凭据时响应 tools/list，或发布可在沙箱中无凭据启动的软件包。

  • 描述必需15 分
  • 图标10 分
  • 文档15 分
  • 许可证10 分