The Developer MCP Server is a context management system that maintains persistent knowledge graphs for software development projects, helping teams track components, dependencies, decisions, and progress across coding sessions.
Core Capabilities:
Session Management: Start sessions with automatic retrieval of recent activity, active projects, high-priority tasks, and upcoming milestones. End sessions through a structured workflow documenting achievements, updating task statuses, creating new tasks, and recording progress. Load detailed context for any entity with formatted output tailored to the entity type.
Knowledge Graph Management: Create entities representing 12 types of development artifacts (projects, components, features, issues, tasks, developers, technologies, decisions, milestones, environments, documentation, requirements). Establish relationships using 19 relation types (depends_on, implements, blocked_by, uses, part_of, contains, has_status, has_priority, precedes, and more). Add observations to document metadata and contextual information. Delete entities, relations, or observations to maintain accuracy.
Advanced Querying & Analysis: Retrieve the entire knowledge graph, search entities using keyword or partial matching, fetch specific entities by exact name, explore incoming and outgoing relationships, review decision history chronologically, and track milestone progress with completion percentages and task breakdowns.
Development Workflow Support: Track dependencies between components and features for impact analysis, manage task sequencing, set and update status (inactive, active, complete) and priorities (low, high), document architectural decisions with context, and monitor progress to identify bottlenecks.
Team Collaboration: Maintain context continuity across sessions, onboard new team members with instant visibility into project architecture, preserve organizational knowledge about technical decisions and their rationale, and track developer assignments.
Data Persistence: Customize storage locations using environment variables (MEMORY_FILE_PATH and SESSIONS_FILE_PATH), store knowledge graphs persistently in JSON format, and maintain session history for reviewing past activities.
Supports containerized deployment and execution of the MCP server through Docker
Implied integration through source code management for building the server from source
Allows installation and usage of the MCP server directly from a GitHub repository
Referenced as a technology choice for API implementation that can be tracked and explained through the system's decision history capabilities
Supports installation and package management of the MCP server
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Developer MCP Server show me the status of the authentication component"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Context management system designed for software development teams. The Developer MCP Server maintains persistent context across coding sessions, ensuring you never lose track of the project's structure, dependencies, and progress.
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.
Related MCP server: Context Management System
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
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
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-developerThe 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).
Here are some example prompts to use with the Developer MCP Server:
"Start a new development session for me.""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.""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.""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?"The Developer MCP Server excels in scenarios like:
"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.
"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.
"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.
"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.
"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.
"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.
Add this to your claude_desktop_config.json:
{
"mcpServers": {
"developer": {
"command": "npx",
"args": [
"-y",
"github:tejpalvirk/developer"
]
}
}
}First, install the package globally:
npm install -g github:tejpalvirk/contextmanager/developerThen configure Claude Desktop:
{
"mcpServers": {
"developer": {
"command": "contextmanager-developer"
}
}
}{
"mcpServers": {
"developer": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"mcp/developer"
]
}
}
}# 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.jsdocker build -t mcp/developer -f developer/Dockerfile .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.
A sophisticated tool for advanced querying and analysis of the software development knowledge graph. This tool provides specialized operations to extract meaningful insights and contextual information from the graph structure. It enables deep exploration of projects, components, relationships, decisions, and progress tracking.
When to use this tool:
Retrieving the complete development knowledge graph
Searching for specific entities using keyword or partial matching
Fetching details on a precise set of development entities
Exploring all relationships for a specific entity
Examining the decision history for a software project
Tracking progress toward project milestones
Investigating dependencies between components
Analyzing the evolution of a software project
Understanding the context surrounding development entities
Exploring task sequencing and dependencies
Identifying entities by status or priority
Key features:
Six specialized query operation types
Full graph retrieval with entities and relations
Keyword-based search across entities and their properties
Direct entity lookup by exact name
Relationship exploration with filtering options
Project decision history with chronological ordering
Milestone progress tracking with task status breakdown
Status and priority information retrieval
Parameters explained:
type: The query operation type to perform, which must be one of:
"graph" - Retrieve the entire knowledge graph (all entities and relations)
"search" - Find entities by keyword/partial match in name, type, or observations
"nodes" - Get specific entities by exact name
"related" - Get all entities related to a specific entity
"decisions" - Get the decision history for a project
"milestone" - Get progress tracking for a specific milestone
params: Operation-specific parameters structure:
For "graph": No parameters needed
For "search": { query: "search text" }
For "nodes": { names: ["EntityName1", "EntityName2", ...] }
For "related": { entityName: "EntityName", relationTypes: ["type1", "type2", ...] }
For "decisions": { projectName: "ProjectName" }
For "milestone": { milestoneName: "MilestoneName" }
Operation details:
"graph" returns the complete knowledge graph structure
"search" performs partial matching on entity names, types, and observations
"nodes" retrieves specific entities by exact name matching
"related" finds all incoming and outgoing relationships for an entity
"decisions" retrieves and chronologically sorts project decisions
"milestone" calculates progress percentage and task breakdowns with status information
Notes:
Valid status values: "inactive", "active", or "complete"
Valid priority values: "low" or "high"
Status is represented via the has_status relation type, and priority via has_priority
Return structures:
All operations return { success: true/false, ... } with operation-specific data
Error responses include detailed error messages
"related" returns both incoming and outgoing relationships
"milestone" includes progress percentage and task categorization by status
Sequencing information appears in directed relationship graphs
You should:
Select the most appropriate query type for your information need
Provide the required parameters for your chosen operation type
Start with broader queries and refine to more specific ones
Use "search" for exploratory investigation when entity names are unknown
Use "related" to explore the neighborhood of a known entity
Use "decisions" to understand the rationale behind project changes
Use "milestone" to evaluate project progress and identify blockers
Analyze task sequencing to understand dependencies and critical paths
Filter entities by status to focus on active, inactive, or completed items
Consider entity priorities when planning work or resolving issues
Combine query results to build comprehensive understanding
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes | Parameters for the operation, structure varies by type | |
| type | Yes | Type of get operation: 'graph', 'search', 'nodes', 'related', 'decisions', or 'milestone' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure and does so comprehensively. It details six specialized query operations, explains return structures including error handling, specifies valid status and priority values, and describes how sequencing information appears. It covers behavioral aspects like partial matching, chronological ordering, and progress calculation that aren't inferable from the schema alone.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (When to use, Key features, Parameters explained, etc.), but it's excessively long with repetitive information. Sentences like 'It enables deep exploration of projects, components, relationships, decisions, and progress tracking' could be more concise, and some details in the 'You should' section overlap with earlier guidance, reducing efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 operation types with varying parameters) and lack of annotations or output schema, the description provides complete context. It covers all operations, parameter structures, return formats, valid values, and usage strategies. The detailed explanations compensate for the missing structured data, making the tool fully understandable for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 100% schema description coverage, the description adds significant value beyond the schema. It explains each 'type' enum value with specific use cases and details the 'params' structure for each operation type, including examples like { query: 'search text' } and { names: ['EntityName1', ...] }. This provides crucial semantic context that the schema's generic descriptions don't cover.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'advanced querying and analysis of the software development knowledge graph' with specific verbs like 'extract meaningful insights,' 'deep exploration,' and 'tracking progress.' It distinguishes itself from siblings like 'buildcontext' and 'deletecontext' by focusing on query operations rather than creation or deletion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool with a dedicated 'When to use this tool' section listing 11 specific scenarios (e.g., 'Retrieving the complete development knowledge graph,' 'Exploring all relationships for a specific entity'). It also includes a 'You should' section with 11 actionable recommendations for selecting query types and refining searches, offering clear alternatives and context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
A powerful tool for building and enriching the software development knowledge graph through creation operations. This tool allows developers to add new entities, create relationships between entities, or add observations to existing entities. Each operation type serves a specific purpose in constructing a comprehensive development context model.
When to use this tool:
Creating new project components like features, tasks, and milestones
Establishing relationships between development entities (e.g., component implements feature)
Documenting observations about existing entities (statuses, descriptions, etc.)
Building a graph of connected software development artifacts
Recording new information discovered during development
Tracking project structure, dependencies, and status
Documenting developer roles and assignments
Setting entity status and priority values
Defining task sequencing and dependencies
Key features:
Three distinct operation types (entities, relations, observations)
Type validation against software development domain standards
Automatic rejection of invalid entity or relation types
Safe addition of new observations to existing entities
JSON-formatted response with operation results
Clear error messages when operations fail
Handles both single and batch operations
Parameters explained:
type: The operation type to perform, which must be one of:
"entities" - Create new software development entities
"relations" - Create relationships between existing entities
"observations" - Add observations to existing entities
data: Operation-specific data structure:
For "entities": Array of objects with { name, entityType, observations[] }
For "relations": Array of objects with { from, to, relationType }
For "observations": Array of objects with { entityName, contents[] }
Entity Types:
project - Overall software project
component - Module, service, or package within a project
feature - Specific functionality being developed
issue - Bug or problem to be fixed
task - Work item or activity needed for development
developer - Team member working on the project
technology - Language, framework, or tool used
decision - Important technical or architectural decision
milestone - Key project deadline or phase
environment - Development, staging, production environments
documentation - Project documentation
requirement - Project requirement or specification
status - Entity status (inactive, active, or complete)
priority - Entity priority (low or high)
Relation Types include:
depends_on - Dependency relationship
implements - Component implements a feature
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
has_status - Links entity to its status (inactive, active, complete)
has_priority - Links entity to its priority (low, high)
precedes - Task precedes another task (for sequencing)
related_to - General relationship
affects - Issue affects a component
resolves - Task resolves an issue
documented_in - Component is documented in documentation
decided_in - Decision was made in a meeting
required_by - Feature is required by a requirement
depends_on_milestone - Task depends on reaching a milestone
tested_in - Component is tested in an environment
You should:
Specify the operation type based on what you need to create (entities, relations, or observations)
Structure your data according to the operation type's requirements
Use valid entity types and relation types from the software development domain
Ensure entities exist before creating relations between them
Provide meaningful names and descriptions for new entities
Use observations to add metadata about entities
Create complete structures rather than adding entities/relations piecemeal
For task sequencing, use the 'precedes' relation to define which tasks must be completed before others
Set status values using the has_status relation (valid values: inactive, active, complete)
Set priority values using the has_priority relation (valid values: low, high)
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | Data for the creation operation, structure varies by type but must be an array | |
| type | Yes | Type of creation operation: 'entities', 'relations', or 'observations' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does so effectively. It discloses key behavioral traits: 'Three distinct operation types,' 'Type validation against software development domain standards,' 'Automatic rejection of invalid entity or relation types,' 'Safe addition of new observations,' 'JSON-formatted response,' 'Clear error messages,' and 'Handles both single and batch operations.' It covers most aspects well but could mention performance characteristics like rate limits or latency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately structured with clear sections (purpose, when to use, key features, parameters explained, entity types, relation types, guidelines), but it is lengthy with multiple lists and detailed examples. While informative, some content could be more condensed without losing value, making it less front-loaded than ideal.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multiple operation types, extensive domain-specific types) and lack of annotations or output schema, the description is highly complete. It covers purpose, usage, behavior, parameters with examples, valid types, and detailed guidelines, providing all necessary context for an AI agent to use the tool effectively without structured fields.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant meaning beyond the input schema's 100% coverage. It explains the 'type' parameter's three values with detailed semantics ('entities' for creating new entities, 'relations' for relationships, 'observations' for adding metadata) and provides extensive context for the 'data' parameter with examples of valid structures, entity types (14 listed), and relation types (17 listed). This greatly enhances understanding of how to structure inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'building and enriching the software development knowledge graph through creation operations' and specifies it 'allows developers to add new entities, create relationships between entities, or add observations to existing entities.' It distinguishes from siblings like 'deletecontext' and 'loadcontext' by focusing on creation operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes an explicit 'When to use this tool' section with 8 specific use cases (e.g., 'Creating new project components,' 'Establishing relationships between development entities'), plus a 'You should' section with 10 detailed guidelines (e.g., 'Specify the operation type,' 'Ensure entities exist before creating relations'). This provides comprehensive guidance on when and how to use this tool versus alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
A versatile tool for removing elements from the software development knowledge graph. This tool allows precise deletion of entities, relationships between entities, or specific observations from existing entities. It helps maintain an accurate and current representation of the development context as projects evolve.
When to use this tool:
Removing deprecated or completed project components
Deleting obsolete relationships between development entities
Pruning outdated observations that no longer apply
Correcting errors in the knowledge graph
Cleaning up testing or prototype entities
Maintaining graph accuracy as project scope changes
Removing sensitive or confidential information
Archiving completed projects or components
Removing task sequencing relationships
Updating status or priority relationships
Key features:
Three distinct deletion operation types (entities, relations, observations)
Cascading deletion for entities (automatically removes related relations)
Precise deletion of specific observations without removing entire entities
Targeted relation removal with exact matching on from/to/type
Batch operations for efficient cleanup
JSON-formatted response with operation results
Secure validation before deletion
Parameters explained:
type: The deletion operation type to perform, which must be one of:
"entities" - Remove development entities and their relations
"relations" - Remove specific relationships between entities
"observations" - Remove specific observations from entities
data: Operation-specific data structure:
For "entities": Array of entity names to delete
For "relations": Array of objects with { from, to, relationType }
For "observations": Array of objects with { entityName, observations[] }
Deletion behavior by type:
"entities": Completely removes the specified entities and any relations where they appear
"relations": Removes only the exact relations specified, matching on all three attributes
"observations": Removes specific observations from entities while preserving the entities themselves
Safety considerations:
Entity deletion cascades to relations, so be careful when deleting key entities
There is no "undo" operation, so confirm deletions carefully
Partial graph information can lead to inconsistent views
Relations require entities on both ends to exist
Instead of deleting status or priority entities, prefer updating them using appropriate tools
Deleting task sequencing relations may disrupt project planning and dependencies
You should:
Identify the specific elements that need to be removed
Choose the appropriate deletion type (entities, relations, or observations)
Structure your data according to the deletion type's requirements
Start with the most specific deletions (observations) before broader ones
Verify the entities or relations exist before attempting deletion
To update status or priority, create new has_status or has_priority relations rather than deleting old ones
When removing task sequencing, consider how it affects other tasks and milestones
Check the operation result to confirm successful deletion
Consider documenting major deletions as observations on related entities
When removing an entire project, first delete its components for cleaner removal
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | Data for the deletion operation, structure varies by type but must be an array | |
| type | Yes | Type of deletion operation: 'entities', 'relations', or 'observations' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and delivers comprehensive behavioral disclosure. It explains cascading deletion effects, lack of undo, partial graph implications, relation prerequisites, and specific deletion behaviors for each operation type. The safety considerations section provides critical operational context beyond basic functionality.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While well-structured with clear sections, the description is verbose with 10-item lists in multiple sections. Some redundancy exists (e.g., operation types explained multiple times). The core functionality could be communicated more efficiently while maintaining the valuable safety and usage guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive tool with no annotations and no output schema, the description provides exceptional completeness. It covers purpose, usage scenarios, parameter semantics, behavioral traits, safety considerations, and operational procedures. The absence of output schema is compensated by mentioning 'JSON-formatted response with operation results.'
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 100% schema description coverage, the description adds substantial value through a dedicated 'Parameters explained' section that clarifies the meaning of 'type' options and provides detailed data structure examples for each operation. It transforms the abstract schema into concrete usage patterns with specific examples for entities, relations, and observations.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'removing elements from the software development knowledge graph' with three specific operation types (entities, relations, observations). It distinguishes itself from siblings like 'buildcontext' and 'loadcontext' by focusing on deletion rather than creation or retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides extensive guidance with a dedicated 'When to use this tool' section listing 10 specific scenarios, plus safety considerations and a numbered list of 10 actionable steps. It explicitly advises against using this tool for status/priority updates, directing users to 'appropriate tools' instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
A multi-stage tool for documenting development sessions, recording achievements, tracking task progress, and updating project status in the knowledge graph.
When to use this tool: Only use this tool when the user explicity requests it or provides explicit approval.
Key features:
Provides a structured, multi-stage workflow for session documentation
Records session achievements in the knowledge graph
Updates task statuses using the has_status relation (inactive, active, complete)
Updates task priorities using the has_priority relation (low, high)
Updates task sequencing relationships using the precedes relation
Creates links between completed tasks and projects
Updates project status metadata
Creates new tasks for future development
Supports revision of previous stages when needed
Offers a comprehensive assembly stage that consolidates all session information
Organizes development activity into a coherent project history
The endsession tool uses a sequential, multi-stage approach with 6 typical stages:
Summary Stage: Records basic session information
Achievements Stage: Documents specific accomplishments
Task Updates Stage: Records status and priority changes to existing tasks
New Tasks Stage: Defines new tasks created during the session
Project Status Stage: Updates the overall project status
Assembly Stage: Consolidates all information and finalizes the session record
Parameters explained:
sessionId: Required - Unique identifier for the development session
Obtained from the startsession tool
Example: "dev_1234567890_abc123"
stage: Required - Current stage of the endsession workflow
Accepts: "summary", "achievements", "taskUpdates", "newTasks", "projectStatus", or "assembly"
Each stage has specific data requirements and processing logic
stageNumber: Required - The sequence number of the current stage
Starts at 1 and typically progresses through 6 stages
Used to track progress through the session documentation workflow
totalStages: Required - Total number of stages planned for this workflow
Typically 6 for the complete workflow
Provides context for the progress within the overall process
analysis: Optional - Text analysis or observations for the current stage
Descriptive text explaining the work done in this stage
Example: "Analyzed progress on the authentication system"
stageData: Optional - Stage-specific structured data
summary: { summary: "Session summary text", duration: "2 hours", focus: "ProjectName" }
achievements: { achievements: ["Implemented feature X", "Fixed bug Y", "Refactored component Z"] }
taskUpdates: { taskUpdates: [{ name: "Task1", status: "complete" }, { name: "Task2", status: "active", priority: "high" }] }
newTasks: { newTasks: [{ name: "NewTask1", description: "Implement feature A", priority: "high", precedesTask: "Task2" }] }
projectStatus: { projectName: "ProjectName", status: "active", observation: "Making good progress" }
assembly: No stageData needed - automatically assembled from previous stages
nextStageNeeded: Required - Whether additional stages are needed after this one
Boolean value (true/false)
Set to false on the final stage to complete the session
isRevision: Optional - Whether this is revising a previous stage
Boolean value (true/false)
Default: false
revisesStage: Optional - If revising, which stage number is being revised
Required when isRevision is true
Indicates which previous stage is being updated
Return information:
success: Boolean indicating whether the operation succeeded
stageCompleted: The stage that was just completed
nextStageNeeded: Whether more stages are required
stageResult: The processed result of the current stage
endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
sessionRecorded: (Final stage only) Whether the session was recorded
summaryMessage: (Final stage only) Formatted summary of all recorded information
error: (Only on failure) Error message describing the issue
You should:
Complete all stages in order for comprehensive session documentation
Provide specific details in each stage for accurate knowledge graph updates
Be precise about task names to ensure they match existing tasks in the knowledge graph
Use valid status values (inactive, active, complete) when updating task status
Use valid priority values (low, high) when specifying task priorities
Specify task sequencing with the precedesTask field to establish task dependencies
Use clear, descriptive names for any new tasks
Include relevant observations for project status updates
If making a revision, specify which stage is being revised
Only mark nextStageNeeded as false on the final assembly stage
Review the final summary message to confirm all session details were recorded properly
| Name | Required | Description | Default |
|---|---|---|---|
| analysis | No | Text analysis or observations for the current stage | |
| isRevision | No | Whether this is revising a previous stage | |
| nextStageNeeded | Yes | Whether additional stages are needed after this one (false for final stage) | |
| revisesStage | No | If revising, which stage number is being revised | |
| sessionId | Yes | The unique session identifier obtained from startsession | |
| stage | Yes | Current stage of analysis: 'summary', 'achievements', 'taskUpdates', 'newTasks', 'projectStatus', or 'assembly' | |
| stageData | No | Stage-specific data structure - format depends on the stage type: - For 'summary' stage: { summary: "Session summary text", duration: "2 hours", focus: "ProjectName" } - For 'achievements' stage: { achievements: ["Implemented feature X", "Fixed bug Y", "Refactored component Z"] } - For 'taskUpdates' stage: { taskUpdates: [{ name: "Task1", status: "completed" }, { name: "Task2", status: "in_progress" }] } - For 'newTasks' stage: { newTasks: [{ name: "NewTask1", description: "Implement feature A", priority: "high" }] } - For 'projectStatus' stage: { projectName: "ProjectName", projectStatus: "in_progress", projectObservation: "Making good progress" } - For 'assembly' stage: no stageData needed - automatic assembly of previous stages | |
| stageNumber | Yes | The sequence number of the current stage (starts at 1) | |
| totalStages | Yes | Total number of stages in the workflow (typically 6 for standard workflow) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the multi-stage workflow, revision capabilities, and output structure (e.g., 'success,' 'stageCompleted,' 'summaryMessage'). However, it lacks details on error handling beyond mentioning an 'error' field, and doesn't specify performance characteristics like rate limits or idempotency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a clear purpose and usage guidelines, but becomes overly verbose with detailed lists of features, stages, and parameter explanations that could be condensed. Sentences like 'Organizes development activity into a coherent project history' add minimal value. While structured, it could be more concise without losing essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (9 parameters, multi-stage workflow, no annotations, no output schema), the description is largely complete. It covers purpose, usage, parameters, and outputs in detail. However, it lacks explicit error scenarios or edge-case handling (e.g., invalid 'stageData' formats), which would enhance robustness for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining parameter interactions (e.g., 'isRevision' and 'revisesStage' relationship), providing concrete examples for 'stageData' formats, and clarifying usage contexts like 'sessionId' from 'startsession.' This goes beyond the schema's technical definitions to aid practical application.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as a 'multi-stage tool for documenting development sessions' with specific verbs like 'recording achievements, tracking task progress, and updating project status in the knowledge graph.' It distinguishes from siblings like 'startsession' by focusing on session conclusion rather than initiation, and from context tools by its session-specific workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states 'Only use this tool when the user explicitly requests it or provides explicit approval' under 'When to use this tool.' It also provides implicit guidance by detailing the 6-stage workflow and recommending completion 'in order for comprehensive session documentation,' helping differentiate it from simpler or single-purpose tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
A powerful tool for retrieving rich, contextual information about specific software development entities, providing formatted details based on entity type.
When to use this tool:
Retrieving detailed information about a specific project, component, feature, or other development entity
Exploring relationships between software development entities
Examining project status, components, features, tasks, and issues
Understanding the structure and elements of a software component
Reviewing milestone progress and completion metrics
Examining task details, dependencies, and task sequencing
Exploring feature implementations and technical requirements
Analyzing the project knowledge graph to understand entity relationships
Preparing for work on a specific entity by establishing context
Key features:
Provides contextually rich, formatted information about software development entities
Adapts output format based on entity type (project, component, feature, task, etc.)
Presents both direct entity information and related elements
Organizes information in a clear, hierarchical structure
Automatically identifies entity relationships and presents them systematically
Parameters explained:
entityName: Required - The name of the entity to retrieve context for
Example: "AuthService", "UserProfile", "LoginFeature"
entityType: Optional - The type of entity being retrieved
Default: "project"
Accepted values: "project", "component", "task", "issue", "milestone", "decision", "feature", "technology", "documentation", "dependency", "developer"
Helps the system format the output appropriately
sessionId: Optional - The current session identifier
Typically provided by startsession
Used for tracking entity views within the session
Each entity type returns specialized context information:
Project: Shows status, components, active features, active tasks, active issues, upcoming milestones, team members, recent decisions, and task sequencing information
Component: Displays parent projects, implemented features, technologies used, active issues, documentation, and dependencies
Feature: Shows status, priority, description, requirements, implementing components, and related tasks
Task: Displays project, status, priority, description, related issues, blocking items, preceding tasks, and following tasks
Milestone: Shows status, progress percentage, and tasks grouped by completion status (complete, active, inactive)
Other Entity Types: Shows observations and both incoming and outgoing relationships within the knowledge graph
You should:
Specify the exact entity name for accurate retrieval
Provide the entity type when possible for optimally formatted results
Start with project entities to get a high-level overview
Explore components to understand technical architecture
Examine features to see functional requirements and implementations
Review tasks to understand specific work items and their status
Analyze task sequencing to understand dependencies and workflow
Use status information to focus on active or incomplete work
Consider priority information when planning next steps
Use milestone context to track progress toward completion
After retrieving context, follow up on specific entities of interest
Use in conjunction with startsession to maintain session tracking
Remember that this tool only retrieves existing information; use buildcontext to add new entities
| Name | Required | Description | Default |
|---|---|---|---|
| entityName | Yes | ||
| entityType | No | ||
| sessionId | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well by explaining key behavioral traits: it's a read-only retrieval tool ('only retrieves existing information'), provides formatted/hierarchical output, adapts based on entity type, and presents relationships. It doesn't mention rate limits, authentication needs, or error conditions, but covers core behavior thoroughly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections, but overly verbose at ~450 words. Many sentences in the 'You should' section are repetitive (e.g., multiple 'Explore...' items) and could be consolidated. While front-loaded with purpose, it could be more concise without losing value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 3-parameter tool with no annotations and no output schema, the description provides excellent context: clear purpose, detailed usage guidelines, parameter explanations, and behavioral traits. It lacks explicit output format details (though hints at 'formatted' and 'hierarchical'), but given the comprehensive parameter coverage and sibling differentiation, it's nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates with a detailed 'Parameters explained' section. It explains all 3 parameters: entityName (required, with examples), entityType (optional, default value, accepted values list), and sessionId (optional, purpose, typical source). This adds substantial meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'retrieving rich, contextual information about specific software development entities' with 'formatted details based on entity type.' It distinguishes from siblings like buildcontext (adds new entities) and deletecontext (removes entities), making the read-only retrieval purpose explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides extensive guidance with a dedicated 'When to use this tool' section listing 9 specific scenarios, plus a 'You should' section with 13 actionable recommendations. It explicitly contrasts with buildcontext ('only retrieves existing information') and mentions startsession for session tracking, offering clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
A powerful session initialization tool for software development contextual work. This tool starts a new development session and provides a comprehensive overview of the current development landscape. It retrieves recent sessions, active projects, high-priority tasks, and upcoming milestones to help focus the work effectively.
When to use this tool:
Beginning a new development work session
Establishing context before diving into specific development work
Key features:
Generates a unique session identifier for tracking activity
Retrieves and displays recent development sessions
Shows active software development projects (based on has_status relations)
Highlights high-priority tasks (based on has_priority relations)
Lists upcoming project milestones with progress tracking
Displays task dependencies and sequencing information
Parameters explained:
No parameters required - the tool automatically retrieves all relevant context
Return information:
Session ID: A unique identifier for this development session (format: dev_timestamp_randomstring)
Recent Development Sessions: Up to 3 most recent sessions with:
Date
Project focus
Session summary (truncated to 100 characters)
Active Projects: List of active software projects with their status
High-Priority Tasks: Tasks with high priority status (via has_priority relation) including:
Task name
Current status (via has_status relation)
Task sequencing information (preceding and following tasks)
Upcoming Milestones: Milestones with active status including:
Milestone name
Progress percentage based on completed tasks
You should:
Use the generated session ID with the loadcontext tool to load specific entities
End the session with endsession when work is complete
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: generating a unique session ID, retrieving recent sessions, active projects, high-priority tasks, and upcoming milestones. It also mentions tracking activity and progress, though it lacks details on rate limits, error handling, or authentication needs, which keeps it from a perfect score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with sections like 'When to use this tool,' 'Key features,' 'Parameters explained,' and 'Return information,' making it front-loaded and easy to scan. However, it is slightly verbose with detailed lists in the return section, which could be condensed without losing essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of the tool (session initialization with multiple data retrievals), no annotations, and no output schema, the description does a good job of covering purpose, usage, features, parameters, and return values. It explains what the tool does and how to use it with siblings, though it could benefit from more behavioral details like error cases or performance expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0 parameters with 100% coverage, so the baseline is 4. The description explicitly states 'No parameters required - the tool automatically retrieves all relevant context,' which adds clarity beyond the schema by confirming the automatic nature of the retrieval, though it doesn't need to explain parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'starts a new development session' and 'provides a comprehensive overview of the current development landscape,' which is a specific verb+resource combination. It distinguishes itself from siblings like 'loadcontext' (loads specific entities) and 'endsession' (ends sessions), making the differentiation explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Beginning a new development work session' and 'Establishing context before diving into specific development work') and provides clear guidance on alternatives, such as using 'loadcontext' with the session ID and 'endsession' when work is complete. This covers both usage context and exclusions effectively.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0advancedcontextbuildcontextdeletecontextendsessionloadcontextstartsessionEach tool has a clearly distinct purpose with no overlap: advancedcontext queries, buildcontext creates, deletecontext deletes, endsession documents sessions, loadcontext retrieves single entities, and startsession initializes sessions. The descriptions reinforce distinct roles, making misselection unlikely.
All tool names follow a consistent verb_noun pattern (e.g., advancedcontext, buildcontext, deletecontext, endsession, loadcontext, startsession). The naming is uniform and predictable, enhancing usability and clarity.
With 6 tools, the set is well-scoped for managing a software development knowledge graph. Each tool serves a specific, necessary function (query, create, delete, session management, retrieve, initialize), and no tool feels redundant or missing for the domain.
The toolset provides complete CRUD/lifecycle coverage for the domain: advancedcontext for querying, buildcontext for creation, deletecontext for deletion, loadcontext for retrieval, and startsession/endsession for session management. There are no obvious gaps, enabling agents to handle all core workflows effectively.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Intelligent context infrastructure for AI teams: knowledge graph, sessions, tasks, documents.
Shared project context for AI agents and teams: docs, tasks, and messages that stay current.
Give your AI agent a persistent map of your project's structure, dependencies, and bugs.
Project memory for coding agents: requirements, decisions, code graph and delivery telemetry.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/tejpalvirk/developer'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
