Como instalo Devmind?

Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.

Devmind precisa de uma chave de API?

Este registro não lista nenhuma variável de ambiente obrigatória.

Qual transporte Devmind usa?

Devmind roda localmente via stdio.

Servidor MCP Devmind | PlugMCP

┌──────────────────────────────────────────────────────────────┐
│                      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)     │
└──────────────────────────────────────────────────────────────┘

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

Method	Command	Best For	Auto-update
NPX	`npx -y devmind-mcp@latest`	Quick testing, first-time use	Yes
Global Install	`npm install -g devmind-mcp`	Daily development	No
From Source	`git clone + npm install`	Contributing, customization	No

# Install latest version
claude add mcp npx -y devmind-mcp@latest

# Or install specific version
claude add mcp npx -y [email protected]

{
  "mcpServers": {
    "devmind": {
      "command": "npx",
      "args": ["-y", "devmind-mcp@latest"]
    }
  }
}

Tool	Purpose	Example Use
`codebase`	Index project files for semantic search	Index entire codebase
`delete_codebase_index`	Remove codebase index for a project	Clean up indexed files

Tool	Purpose	Example Use
`list_projects`	[RECOMMENDED] List all projects with stats	Overview tracked projects
`cleanup_empty_projects`	Clean up empty projects with no memories	Remove unused project records

Tool	Purpose	Example Use
`create_session`	Start new development session	Beginning a new feature
`get_current_session`	Get active session info	Check current context
`end_session`	End development session	Finishing work
`delete_session`	Delete session and all contexts	Clean up old sessions

Tool	Purpose	Example Use
`export_memory_graph`	Export interactive timeline graph (v1.19)	Visualize memory in vertical timeline with 6 type columns

Project 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  │
└─────────────────────┘

// 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"
});

// 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 }
});

{
  "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"
  ]
}

Option	Type	Default	Description
`database_path`	string	`~/.devmind/memory.db`	SQLite database file location
`quality_threshold`	number	`0.3`	Minimum quality score for context storage
`embedding_model`	string	`"local"`	Embedding model for vector search
`auto_save_interval`	number	`30000` (30 seconds)	Auto-save interval in milliseconds
`ignored_patterns`	string[]	See example above	Glob patterns to ignore
`included_extensions`	string[]	See example above	File extensions to include

## 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.

{
  "mcpServers": {
    "devmind": {
      "command": "npx",
      "args": ["-y", "devmind-mcp@latest"]
    }
  }
}

{
  "mcpServers": {
    "devmind": {
      "command": "devmind-mcp"
    }
  }
}

const id = await record_context({
  content: "Fixed memory leak in WebSocket connection handler",
  type: "solution",
  tags: ["websocket", "memory-leak", "bug-fix"]
});

// Index a project
const result = await codebase({
  project_path: "./my-project",
  force_reindex: true
});

// Delete project index
const result = await delete_codebase_index({
  project_path: "./my-project"
});

const results = await semantic_search({
  query: "authentication implementation",
  limit: 10,
  type: "implementation"
});

await update_context(contextId, {
  tags: ["websocket", "memory-leak", "bug-fix", "resolved"]
});

// 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`);

# 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

Devmind

Q: Quando Devmind foi verificado pela última vez?

Última verificação: 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.

JochenYang18 estrelas

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

Knowledge Memory

Instalar Rodar no PlugMCPReivindicar este servidor

GitHub

Rodar no PlugMCP

1# Devmind

README.mdServidor MCP

Transporte: stdio
Status: Local

Adicionar este servidor

Host a copy with our keys and logs.

Dados do servidor

Documentação

DevMind MCP

Why DevMind MCP?

Table of Contents

Overview

What is DevMind MCP?

Key Features

Core Capabilities

Technical Features

Architecture

Project Structure

Quick Start

Prerequisites

Installation

Step-by-Step Setup

Step 1: Add to MCP Client

Step 2: Restart Your MCP Client

Step 3: Try Your First Command

Next Steps

How AI Should Use DevMind

Usage Guide

MCP Tools Quick Reference

Codebase Indexing

Project Management

Session Management

Context Operations

Search & Discovery

Visualization

ContextEngine (New in v2.4.9)

Key Features

How It Works

Default Exclusions

Usage Example

Integration with Semantic Search

Usage Examples

Store Context Information

Search and Retrieve

Update Existing Context

Contextual Search

Configuration

Basic Configuration (Optional)

Configuration Options

Recommended System Prompt Configuration

Full MCP Configuration Example

API Reference

Core Methods

record_context(context: ContextData): Promise<string>

codebase(options: CodebaseOptions): Promise<IndexResult>

delete_codebase_index(options: DeleteIndexOptions): Promise<DeleteResult>

semantic_search(query: SearchQuery): Promise<Context[]>

update_context(id: string, updates: Partial<ContextData>): Promise<boolean>

delete_context(id: string): Promise<boolean>

cleanup_empty_projects(options?: CleanupOptions): Promise<CleanupResult>

Utility Methods

cleanup(): Promise<void>

stats(): Promise<DatabaseStats>

export(format: 'json' | 'csv'): Promise<string>

Use Cases

Software Development

Research & Learning

Project Management

AI Assistant Enhancement

Development

Setup

Contributing

Development Process

Code Standards

📄 License

🔗 Support

Sobre Devmind

Ferramentas

Perguntas

Como instalo Devmind?

Devmind precisa de uma chave de API?

Qual transporte Devmind usa?

Quando Devmind foi verificado pela última vez?

`record_context(context: ContextData): Promise<string>`

`codebase(options: CodebaseOptions): Promise<IndexResult>`

`delete_codebase_index(options: DeleteIndexOptions): Promise<DeleteResult>`

`semantic_search(query: SearchQuery): Promise<Context[]>`

`update_context(id: string, updates: Partial<ContextData>): Promise<boolean>`

`delete_context(id: string): Promise<boolean>`

`cleanup_empty_projects(options?: CleanupOptions): Promise<CleanupResult>`

`cleanup(): Promise<void>`

`stats(): Promise<DatabaseStats>`

`export(format: 'json' | 'csv'): Promise<string>`