Developer MCP Server

Developer MCP Server

A powerful context management system that maintains persistent context across coding sessions, helping development teams track project structure, dependencies, and progress.

tejpalvirk

Developer Tools
Visit Server

README

Developer MCP Server

A powerful context management system designed specifically for software development teams. The Developer MCP Server maintains persistent context across your coding sessions, ensuring you never lose track of your project's structure, dependencies, and progress.

Features

  • Persistent Development Context: Pick up exactly where you left off in your last session, with complete context about the components, issues, and tasks you were working on.

  • Session Management: Start new development sessions and record your achievements, task updates, and project status changes when you finish, creating a persistent record of your development activities.

  • Dependency Tracking: Understand how components, features, and technologies relate to each other with a comprehensive dependency model.

  • Project Status Insights: Get immediate visibility into project progress, including status of components, features, issues, and milestones.

  • Component Context Retrieval: Understand any component's purpose, implementation details, dependencies, and related issues at a glance.

  • Decision History: Track why architectural and implementation decisions were made, when, and by whom—no more guessing why something was built a certain way.

  • Milestone Progress Tracking: Monitor progress toward project milestones and identify potential bottlenecks before they derail your timeline.

  • Related Entity Discovery: Quickly find all related entities for any component, feature, or task to understand its complete context.

Entities

The Developer MCP Server recognizes the following types of entities in your software development context:

  • Project: Overall software project or product
  • Component: Module, service, package, or logical unit within a project
  • Feature: Specific functionality being developed
  • Issue: Bug, problem, or defect to be addressed
  • Task: Work item or activity needed for development
  • Developer: Team member working on the project
  • Technology: Programming language, framework, library, or tool
  • Decision: Important technical or architectural decision
  • Milestone: Key project deadline or phase
  • Environment: Development, staging, or production environment
  • Documentation: Project documentation resource
  • Requirement: Project requirement or specification

Relationships

The Developer MCP Server models the following relationships between entities, mirroring real-world software development dynamics:

  • depends_on: Entity A requires Entity B to function
  • implements: Component implements a feature
  • assigned_to: Task is assigned to a developer
  • blocked_by: Task is blocked by an issue
  • uses: Component uses a technology
  • part_of: Component is part of a project
  • contains: Project contains a component
  • works_on: Developer works on a project/component
  • related_to: General relationship between entities
  • affects: Issue affects a component
  • resolves: Task resolves an issue
  • created_by: Entity was created by a developer
  • documented_in: Component is documented in documentation
  • decided_in: Decision was made in a meeting
  • required_by: Feature is required by a requirement
  • has_status: Entity has a particular status
  • depends_on_milestone: Task depends on reaching a milestone
  • precedes: Task precedes another task (sequencing)
  • reviews: Developer reviews a component
  • tested_in: Component is tested in an environment

Environment Variables

The Developer MCP Server supports the following environment variables to customize where data is stored:

  • MEMORY_FILE_PATH: Path where the knowledge graph data will be stored

    • Can be absolute or relative (relative paths use current working directory)
    • Default: ./developer/memory.json
  • SESSIONS_FILE_PATH: Path where session data will be stored

    • Can be absolute or relative (relative paths use current working directory)
    • Default: ./developer/sessions.json

Example usage:

# Store data in the current directory
MEMORY_FILE_PATH="./dev-memory.json" SESSIONS_FILE_PATH="./dev-sessions.json" npx github:tejpalvirk/contextmanager-developer

# Store data in a specific location (absolute path)
MEMORY_FILE_PATH="/path/to/data/developer-memory.json" npx github:tejpalvirk/contextmanager-developer

# Store data in user's home directory
MEMORY_FILE_PATH="$HOME/contextmanager/developer-memory.json" npx github:tejpalvirk/contextmanager-developer

Available Tools

The Developer MCP Server provides the following tools:

  • startsession: Starts a new development session and provides information about recent sessions, active projects, high-priority tasks, and upcoming milestones.

  • loadcontext: Loads detailed context for an entity (project, component, feature, task, etc.) and tracks this context loading as part of the current session.

  • endsession: Performs a structured analysis of the development session through multiple stages (summary, achievements, task updates, new tasks, project status) and records this information in the persistent knowledge graph.

  • buildcontext: Creates new entities, relations, or observations in the knowledge graph.

  • deletecontext: Removes entities, relations, or observations from the knowledge graph.

  • advancedcontext: Retrieves information from the knowledge graph with different query types (graph, search, nodes, related, decisions, milestone).

Prompts

Here are some example prompts to use with the Developer MCP Server:

Starting a Session

"Start a new development session for me."

Loading Context

"Show me the current status of the AuthService project."
"Load the context for the UserProfile component."
"What are the open issues affecting the Payment feature?"
"Show me details about the upcoming Q2 Release milestone."

Recording Session Progress

"End my development session. I've been working on AuthService for 3 hours and completed user authentication flow implementation."
"Record my achievements for today: implemented password reset feature and fixed login redirect bug."
"Update the status of these tasks: Login Form is complete, User Registration is in progress."
"Create new tasks for the next sprint: Implement MFA, Add social login options."

Knowledge Graph Management

"Create a new feature called 'BillingSystem' in the ProjectX project."
"Create a relationship showing that PaymentComponent implements BillingSystem feature."
"Show me all components that depend on the DatabaseService."
"What decisions have been made about the authentication approach for ProjectX?"

Usage

The Developer MCP Server excels in scenarios like:

Context Continuity

"Let me see the component I was working on yesterday and all its dependencies."

The server retrieves your most recently accessed components along with their dependencies, issues, and related tasks, allowing you to instantly resume work without spending time reconstructing context.

Onboarding New Team Members

"Give me an overview of Project X's architecture and component structure."

New developers can quickly understand the project structure, key components, and their relationships—dramatically reducing the time needed to become productive on a new codebase.

Session Recording

"End my development session and record what I accomplished."

The server guides you through a structured process to document your achievements, task updates, and project status changes, preserving this context for future sessions and team members.

Architectural Decision Context

"Why was GraphQL chosen over REST for the API layer?"

The server retrieves the decision entity along with related meetings, developers involved, and the context in which the decision was made—preserving organizational knowledge that would otherwise be lost.

Dependency Analysis

"What would be affected if we modify the authentication service?"

Before making changes, developers can understand all components, features, and tasks that depend on a particular component, reducing the risk of unexpected breakages.

Project Progress Tracking

"What's our progress toward the Q2 release milestone?"

Project leads can instantly see the status of all tasks and features associated with a milestone, identifying at-risk items before they jeopardize the timeline.

Configuration

Usage with Claude Desktop

Add this to your claude_desktop_config.json:

Install from GitHub and run with npx

{
  "mcpServers": {
    "developer": {
      "command": "npx",
      "args": [
        "-y",
        "github:tejpalvirk/developer"
      ]
    }
  }
}

Install globally and run directly

First, install the package globally:

npm install -g github:tejpalvirk/contextmanager/developer

Then configure Claude Desktop:

{
  "mcpServers": {
    "developer": {
      "command": "contextmanager-developer"
    }
  }
}

docker

{
  "mcpServers": {
    "developer": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "mcp/developer"
      ]
    }
  }
}

Building

From Source

# Clone the repository
git clone https://github.com/tejpalvirk/contextmanager.git
cd contextmanager

# Install dependencies
npm install

# Build the server
npm run build

# Run the server
cd developer
node developer_index.js

Docker:

docker build -t mcp/developer -f developer/Dockerfile .

License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

Recommended Servers

playwright-mcp

playwright-mcp

A Model Context Protocol server that enables LLMs to interact with web pages through structured accessibility snapshots without requiring vision models or screenshots.

Official
Featured
TypeScript
Magic Component Platform (MCP)

Magic Component Platform (MCP)

An AI-powered tool that generates modern UI components from natural language descriptions, integrating with popular IDEs to streamline UI development workflow.

Official
Featured
Local
TypeScript
MCP Package Docs Server

MCP Package Docs Server

Facilitates LLMs to efficiently access and fetch structured documentation for packages in Go, Python, and NPM, enhancing software development with multi-language support and performance optimization.

Featured
Local
TypeScript
Claude Code MCP

Claude Code MCP

An implementation of Claude Code as a Model Context Protocol server that enables using Claude's software engineering capabilities (code generation, editing, reviewing, and file operations) through the standardized MCP interface.

Featured
Local
JavaScript
@kazuph/mcp-taskmanager

@kazuph/mcp-taskmanager

Model Context Protocol server for Task Management. This allows Claude Desktop (or any MCP client) to manage and execute tasks in a queue-based system.

Featured
Local
JavaScript
Linear MCP Server

Linear MCP Server

Enables interaction with Linear's API for managing issues, teams, and projects programmatically through the Model Context Protocol.

Featured
JavaScript
mermaid-mcp-server

mermaid-mcp-server

A Model Context Protocol (MCP) server that converts Mermaid diagrams to PNG images.

Featured
JavaScript
Jira-Context-MCP

Jira-Context-MCP

MCP server to provide Jira Tickets information to AI coding agents like Cursor

Featured
TypeScript
Linear MCP Server

Linear MCP Server

A Model Context Protocol server that integrates with Linear's issue tracking system, allowing LLMs to create, update, search, and comment on Linear issues through natural language interactions.

Featured
JavaScript
Sequential Thinking MCP Server

Sequential Thinking MCP Server

This server facilitates structured problem-solving by breaking down complex issues into sequential steps, supporting revisions, and enabling multiple solution paths through full MCP integration.

Featured
Python