Power your agent
การติดตั้งจากผู้เผยแพร่ ไม่ใช่เอนด์พอยต์ของ PlugMCP
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดจากผู้เผยแพร่
Intelligent context-aware memory system for AI assistants
English | 中文 | 📋 Changelog | 🚀 Latest Release
DevMind MCP provides persistent memory capabilities for AI assistants through the Model Context Protocol (MCP). It enables AI to remember context across conversations, automatically track development activities, and retrieve relevant information intelligently.
┌──────────────────────────────────────────────────────────────┐
│ AI Assistant │
│ (Claude Code / Cursor / etc.) │
└────────────────────────┬─────────────────────────────────────┘
│ MCP Protocol (stdio)
▼
┌──────────────────────────────────────────────────────────────┐
│ DevMind MCP Server │
│ ┌─────────────────┐ ┌─────────────────┐ ┌──────────────┐ │
│ │ 15 MCP Tools │ │ Type-Based │ │ Hybrid Search│ │
│ │ │ │ Auto-Memory │ │ │ │
│ │ • Session (4) │ │ │ │ • Semantic │ │
│ │ • Context (6) │ │ │ │ • Keyword │ │
│ │ • Project (3) │ │ • 3 Tiers │ │ • Quality │ │
│ │ • Codebase (2) │ │ • Smart Types │ │ • Freshness │ │
│ │ • Visualize (1) │ │ • Lazy Scoring │ │ │ │
│ └─────────────────┘ └─────────────────┘ └──────────────┘ │
└────────────────────────┬─────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ SQLite Local Storage │
│ Projects • Sessions • Contexts • Relationships • Embeddings │
│ + Auto-generated quality scores (lazy update every 24h) │
└──────────────────────────────────────────────────────────────┘
Key Components:
devmind-mcp/
├── src/
│ ├── mcp-server.ts # MCP protocol server
│ ├── database.ts # SQLite storage engine
│ ├── vector-search.ts # Semantic search with embeddings
│ ├── session-manager.ts # Session & context management
│ ├── pending-memory-tracker.ts # Unrecorded file tracking (v2.2.6+)
│ ├── content-extractor.ts # Code analysis & extraction
│ ├── content-quality-assessor.ts # Content quality scoring
│ ├── quality-score-calculator.ts # Multi-dimensional quality scoring
│ ├── auto-record-filter.ts # Smart deduplication
│ ├── context-file-manager.ts # File change tracking
│ ├── performance-optimizer.ts # Performance optimizer (v2.2.0+)
│ ├── search-cache.ts # Search cache
│ ├── smart-confirmation-system.ts # Smart confirmation system
│ ├── types.ts # Type definitions
│ ├── index.ts # Main entry point
│ │
│ ├── memory-graph/ # Memory graph visualization
│ │ ├── index.ts # Main graph generator
│ │ ├── types.ts # Graph type definitions
│ │ ├── data/
│ │ │ ├── GraphDataExtractor.ts # Data extraction from database
│ │ │ ├── NodeBuilder.ts # Node construction & labeling
│ │ │ └── EdgeBuilder.ts # Edge/relationship building
│ │ └── templates/
│ │ ├── HTMLGenerator.ts # HTML visualization generator
│ │ └── HTMLGeneratorCytoscape.ts # Cytoscape graph generator
│ │
│ ├── context-engine/ # Codebase indexing engine
│ │ ├── index.ts # ContextEngine main entry
│ │ ├── FileScanner.ts # File scanning and filtering
│ │ ├── IgnoreProcessor.ts # .gitignore and .augmentignore rules
│ │ └── types.ts # Type definitions
│ │
│ ├── utils/
│ │ ├── file-path-detector.ts # Intelligent file detection
│ │ ├── git-diff-parser.ts # Git diff parsing
│ │ ├── path-normalizer.ts # Cross-platform path handling
│ │ ├── project-root-finder.ts # Project root finder (v2.1.11+)
│ │ ├── language-detector.ts # Programming language detection
│ │ ├── query-enhancer.ts # Search query enhancement (v2.2.0+)
│ │ ├── auto-memory-classifier.ts # Auto memory classification (v2.2.0+)
│ │ ├── context-enricher.ts # Context enrichment (v2.2.0+)
│ │ ├── batch-processor.ts # Batch processor (v2.2.0+)
│ │ └── performance-optimizer.ts # Performance optimization (v2.2.0+)
│
├── dist/ # Compiled output
├── scripts/ # Maintenance scripts
├── docs/zh/ # Chinese documentation
└── tests/ # Test files
Choose the method that fits your needs:
Option A: Using Claude Code CLI (Easiest)
# Install latest version
claude add mcp npx -y devmind-mcp@latest
# Or install specific version
claude add mcp npx -y [email protected]
Option B: Manual Configuration
Edit your MCP client configuration file:
Configuration File Locations:
C:\Users\<YourUsername>\.claude.json or %USERPROFILE%\.claude.json~/.claude.json~/.claude.jsonAdd this configuration:
{
"mcpServers": {
"devmind": {
"command": "npx",
"args": ["-y", "devmind-mcp@latest"]
}
}
}
Using Global Install? Replace with: {"command": "devmind-mcp"}
Restart Claude Code or your MCP client to load DevMind.
In your AI assistant, try:
"Use semantic_search to find information about authentication"
Done! DevMind is now enhancing your AI with persistent memory.
Follow these steps for each development session:
Session Initialization
get_current_session or let it auto-createlist_contexts(limit: 5)During Development
record_context IMMEDIATELY after editing filesBefore Completing Tasks
files_changed for multi-file modificationsWhen User Asks About History
semantic_search for intelligent querieslist_contexts for chronological browsingget_context to view full detailsDevMind provides 15 powerful tools for your AI assistant:
Note: The codebase tool supports .gitignore and .augmentignore exclusion patterns. It also includes built-in defaults that automatically exclude common directories like node_modules/, dist/, build/, .git/, and many more.
Note: DevMind automatically manages one main session per project. Sessions are created automatically when needed and reactivated across conversations.
|| Tool | Purpose | Example Use |
||------------------|-----------------------------|------------------------|
|| record_context | Store development context | Save bug fix solution |
|| list_contexts | List all contexts | Review project history |
|| delete_context | Delete specific context | Remove outdated info |
|| update_context | Update context content/tags | Refine documentation |
|| Tool | Purpose | Example Use |
||-------------------|-------------------------------|------------------------------|
|| semantic_search | AI-powered semantic search | Find related implementations |
|| get_context | Get context(s) by ID(s) | View full memory content |
Note: Embeddings are auto-generated on record_context. Quality scores auto-update every 24h during searches (lazy loading).
New in v1.19: Memory graph features a clean vertical timeline layout with fixed node positioning and optimized performance.
ContextEngine is a powerful codebase indexing system that automatically scans and indexes your entire project for intelligent search and code discovery.
file_index table to avoid polluting development memoryProject Directory
│
▼
┌─────────────────────┐
│ FileScanner │ 1. Recursively scan all files
│ │ 2. Apply ignore rules
│ - Recursive scan │ 3. Detect file types
│ - File filtering │ 4. Skip binaries
└─────────────────────┘
│
▼
┌─────────────────────┐
│ IgnoreProcessor │ 1. Apply ignore rules
│ │ 2. Filter files
│ - Smart filtering │
└─────────────────────┘
│
▼
┌─────────────────────┐
│ Database Storage │ 1. Store in file_index table
│ │ 2. Generate file hashes
│ - file_index │ 3. Index for search
│ - SHA-256 hashes │
└─────────────────────┘
ContextEngine automatically excludes common directories and files:
.git/, .svn/, .hg/node_modules/, vendor/, .composer/dist/, build/, out/, .next/, .vite/, target/*.log, *.tmp, *.temp, .DS_Store, Thumbs.db.vscode/, .idea/, *.swpcoverage/, .nyc_output/, .pytest_cache/// Index your entire codebase
await codebase({
project_path: "/path/to/my-project"
});
// Force re-index all files
await codebase({
project_path: "/path/to/my-project",
force_reindex: true
});
// After indexing, use semantic_search to query
const results = await semantic_search({
query: "How is authentication implemented?",
project_path: "/path/to/my-project"
});
Once indexed, ContextEngine files are automatically included in semantic_search results alongside development memory contexts. This enables AI assistants to:
// Store development context
await record_context({
content: "Implemented user authentication using JWT tokens with refresh token support",
type: "implementation",
tags: ["auth", "jwt", "security", "api"]
});
// Find relevant contexts
const results = await semantic_search({
query: "How did we implement authentication?",
limit: 10
});
// Update context with new information
await update_context(contextId, {
content: "Updated authentication to support OAuth2 and SAML",
tags: ["auth", "jwt", "oauth2", "saml", "security"]
});
// Search within specific timeframe
const results = await semantic_search({
query: "database optimization",
timeRange: { days: 7 }
});
DevMind works out of the box with sensible defaults. Configuration is completely optional.
If you want to customize behavior, create .devmind.json in your project root:
{
"database_path": "~/.devmind/memory.db",
"quality_threshold": 0.3,
"embedding_model": "local",
"auto_save_interval": 30000,
"ignored_patterns": [
"node_modules/**",
".git/**",
"dist/**",
"build/**"
],
"included_extensions": [
".js",
".ts",
".py",
".go"
]
}
To ensure AI assistants automatically record development context, add this to your system prompt configuration (e.g., Kiro steering files, Claude Desktop config):
## Core Responsibility
AI assistants should immediately call the record_context tool after each code edit to ensure all changes are properly recorded in the project memory.
Why This Is Necessary:
With NPX (Recommended):
{
"mcpServers": {
"devmind": {
"command": "npx",
"args": ["-y", "devmind-mcp@latest"]
}
}
}
With Global Installation:
{
"mcpServers": {
"devmind": {
"command": "devmind-mcp"
}
}
}
Important: Restart your MCP client after configuration changes.
record_context(context: ContextData): Promise<string>Store new context information.
Parameters:
content (string) - Main content texttype (string) - Content type: solution, code, error, documentation, test, configurationtags (string[]) - Associated tagsmetadata (object) - Additional metadataReturns: Context ID string
Example:
const id = await record_context({
content: "Fixed memory leak in WebSocket connection handler",
type: "solution",
tags: ["websocket", "memory-leak", "bug-fix"]
});
codebase(options: CodebaseOptions): Promise<IndexResult>Index project files into memory for semantic search.
Parameters:
project_path (string) - Path to the project directory to indexforce_reindex (boolean) - Force reindex all files (default: false)Returns: Index result with statistics
Example:
// Index a project
const result = await codebase({
project_path: "./my-project",
force_reindex: true
});
delete_codebase_index(options: DeleteIndexOptions): Promise<DeleteResult>Delete codebase index for a project.
Parameters:
project_path (string) - Path to the project directory to delete index forReturns: Delete result with statistics
Example:
// Delete project index
const result = await delete_codebase_index({
project_path: "./my-project"
});
semantic_search(query: SearchQuery): Promise<Context[]>Search for relevant contexts using semantic understanding.
Parameters:
query (string) - Search querylimit (number) - Maximum results (default: 20)type (string) - Filter by content typetags (string[]) - Filter by tagstimeRange (object) - Time range filter: { days: 7 }Returns: Array of matching contexts
Example:
const results = await semantic_search({
query: "authentication implementation",
limit: 10,
type: "implementation"
});
update_context(id: string, updates: Partial<ContextData>): Promise<boolean>Update existing context.
Example:
await update_context(contextId, {
tags: ["websocket", "memory-leak", "bug-fix", "resolved"]
});
delete_context(id: string): Promise<boolean>Delete context by ID.
cleanup_empty_projects(options?: CleanupOptions): Promise<CleanupResult>Clean up empty project records that have no associated memories.
Parameters:
dry_run (boolean) - Preview projects to be deleted without actually deleting (default: true)Returns: Cleanup result object
Example:
// Preview empty projects to be deleted
const preview = await cleanup_empty_projects({ dry_run: true });
console.log(`Will delete ${preview.deleted_count} empty projects`);
// Actually delete empty projects
const result = await cleanup_empty_projects({ dry_run: false });
console.log(`Deleted ${result.deleted_count} empty projects`);
cleanup(): Promise<void>Perform database cleanup and optimization.
stats(): Promise<DatabaseStats>Get database statistics and health information.
export(format: 'json' | 'csv'): Promise<string>Export all contexts to specified format.
# Clone repository
git clone https://github.com/JochenYang/Devmind.git
cd Devmind
# Install dependencies
npm install
# Development mode with watch
npm run dev
# Run tests
npm test
# Type checking
npm run type-check
# Linting
npm run lint
We welcome contributions to DevMind MCP! Please follow these steps:
git checkout -b feature/amazing-featuregit commit -m 'Add amazing feature'git push origin feature/amazing-featureThis project is licensed under the MIT License. See the LICENSE file for details.
DevMind MCP - Intelligent context-aware memory for AI assistants
Made with ❤️ by Jochen
DevMind MCP provides **persistent memory capabilities** for AI assistants through the Model Context Protocol (MCP). It enables AI to remember context across conversations, automatically track developm
ภาพรวม
DevMind MCP provides **persistent memory capabilities** for AI assistants through the Model Context Protocol (MCP). It enables AI to remember context across conversations, automatically track development activities, and retrieve relevant information intelligently.
เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
Devmind ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-10-28 DevMind MCP provides **persistent memory capabilities** for AI assistants through the Model Context Protocol (MCP). It enables AI to remember context across conversations, automatically track development activities, and retrieve relevant information intelligently.