Provides developers with continuous, project-centric context awareness. Requires a TursoDB database.
Empower your development workflow with intelligent context awareness - DevContext understands your codebase, conversations, and development patterns to provide relevant context exactly when you need it.
DevContext is a cutting-edge Model Context Protocol (MCP) server designed to provide developers with continuous, project-centric context awareness. Unlike traditional context systems, DevContext continuously learns from and adapts to your development patterns. DevContext leverages sophisticated retrieval methods, focusing on keyword analysis, relationship graphs, and structured metadata to deliver highly relevant context during development, understanding both your conversations and your codebase at a deeper level.
The server operates with a database instance dedicated to a single project, eliminating cross-project complexity and ensuring performance with minimal resource requirements. DevContext builds a comprehensive understanding of your codebase - from repository structure down to individual functions - while continuously learning from and adapting to your development patterns.
The BEST way to use this MCP server is to follow the guide below on implementing the provided Cursor Rules system which in turn gives you:
Sign up for TursoDB:
Install Turso CLI (optional but recommended):
curl -sSfL https://get.turso.tech/install.sh | bash
Authenticate with Turso:
turso auth login
Create a project database:
turso db create devcontext
Get database credentials:
# Get database URL
turso db show devcontext --url
# Create auth token
turso db tokens create devcontext
Save both the URL and token for the next step.
Create or edit .cursor/mcp.json in your project directory:
{
"mcpServers": {
"devcontext": {
"command": "npx",
"args": ["-y", "devcontext@latest"],
"enabled": true,
"env": {
"TURSO_DATABASE_URL": "your-turso-database-url",
"TURSO_AUTH_TOKEN": "your-turso-auth-token"
}
}
}
}
Replace your-turso-database-url and your-turso-auth-token with the values obtained in Step 1.
DevContext implements a sophisticated set of Cursor Rules that create an autonomous development environment. These rules guide Cursor's AI assistants in maintaining project scope alignment, incorporating up-to-date documentation, and implementing advanced task workflows.
Be on the lookout for the DevContext Project Generator which is coming very soon and will create a COMPLETE set up for your project to literally 10x your development workflow.
The core rule defines a precise sequence for tool execution:
1. FIRST: Call initialize_conversation_context EXACTLY ONCE at START
2. AS NEEDED: Call update_conversation_context for code changes/new messages
3. AS NEEDED: Call retrieve_relevant_context when specific context is required
4. OCCASIONALLY: Call record_milestone_context for significant achievements
5. LAST: Call finalize_conversation_context EXACTLY ONCE at END
This workflow ensures comprehensive context management throughout the entire development session.
All external library usage must be preceded by proper documentation retrieval:
This prevents common issues with incorrect API usage, incompatible versions, or missing dependencies.
The task workflow system enables:
tasks.mdCreate Rules Directory:
mkdir -p .cursor/rules
Download/Copy and Paste Rules:
Download or copy and paste the .cursor/rules directory into your project. Next, copy and paste the contents of the .cursorrules file in your project root and paste it into your cursor settings rules (Cursor Settings -> Rules -> User Rules). You should also copy and paste the .cursorrules file into your main directory as well.
Below is a complete example of an mcp.json file that configures both DevContext and Context7 MCP servers:
{
"mcpServers": {
"devcontext": {
"command": "npx",
"args": ["-y", "devcontext@latest"],
"enabled": true,
"env": {
"TURSO_DATABASE_URL": "libsql://your-project-db-name.turso.io",
"TURSO_AUTH_TOKEN": "your_turso_auth_token_here"
}
},
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp@latest"]
}
}
}
| Parameter | Description | Default Value |
|---|---|---|
TURSO_DATABASE_URL | URL of your TursoDB instance | None (Required) |
TURSO_AUTH_TOKEN | Authentication token for TursoDB | None (Required) |
DevContext is a state-of-the-art context management system for software development, implementing the Model Context Protocol (MCP) with advanced context retrieval techniques.
The system operates as a Node.js application with a modular JavaScript codebase, bundled into a single .js file using esbuild. It leverages TursoDB (or similar SQL database) as the persistent store for all context, metadata, and optional logs for a specific project.
Key Differentiators:
DevContext implements the following MCP tools that can be invoked by Cursor IDE:
Initializes a new conversation session with comprehensive project context.
When to use: At the beginning of every conversation, exactly once.
Key parameters:
initialQuery: The user's first message or questioncontextDepth: Minimal, standard, or comprehensive context depthincludeArchitecture: Whether to include architectural contextfocusHint: Optional focus on specific code entityReturns: Conversation ID and initial context summary
Updates the active context with new messages and code changes.
When to use: After code changes or new messages are exchanged.
Key parameters:
conversationId: ID from initialize_conversation_contextnewMessages: New messages exchanged since last updatecodeChanges: Code files created or modifiedpreserveContextOnTopicShift: Whether to maintain context during topic changesReturns: Updated focus and context continuity information
Retrieves context snippets relevant to a specific query.
When to use: When specific project context is needed.
Key parameters:
conversationId: ID from initialize_conversation_contextquery: Specific question about the projectconstraints: Optional filters for entity types, file paths, etc.weightingStrategy: How to prioritize resultsReturns: Relevant context snippets with explanations
Records significant development milestones for future reference.
When to use: After completing important features, fixing critical bugs, or making architectural decisions.
Key parameters:
conversationId: ID from initialize_conversation_contextname: Short, descriptive milestone namedescription: Detailed explanationmilestoneCategory: Category (feature, bug fix, refactoring, etc.)assessImpact: Whether to analyze impactReturns: Milestone ID and impact assessment
Concludes a conversation, extracting learnings and suggesting next steps.
When to use: At the end of every conversation, exactly once.
Key parameters:
conversationId: ID from initialize_conversation_contextextractLearnings: Whether to identify and extract learningspromotePatterns: Whether to promote patterns to global repositorygenerateNextSteps: Whether to suggest follow-up actionsReturns: Conversation summary, extracted learnings, and next steps
DevContext uses a SQL database (TursoDB) with the following core tables:
The database schema is automatically created and maintained by the server.
DevContext is optimized for performance with:
For large codebases (>100,000 LOC), initial indexing may take several minutes, but subsequent operations remain fast and responsive.
Common issues and solutions:
This project is licensed under the MIT License - see the LICENSE file for details.
DevContext: Continuous Context for Continuous Progress
A Model Context Protocol (MCP) server for CODESYS V3 programming environments.
Connects Blender to Claude AI via the Model Context Protocol (MCP), enabling direct interaction and control for prompt-assisted 3D modeling, scene creation, and manipulation.
Predict anything with Chronulus AI forecasting and prediction agents.
An MCP server and client implementation for EdgeOne Pages Functions, supporting OpenAI-formatted requests.
Interact with your MLOps and LLMOps pipelines through your ZenML MCP server
Tool platform by IBM to build, test and deploy tools for any data source
Generate mermaid diagram and chart with AI MCP dynamically.
Perform virtual try-ons using the HeyBeauty API.
A Node.js MCP server example for the OpenWeather API, requiring an API key.
An AI-powered MCP server for analyzing NPM package security, dependencies, and performance.