专为软件开发团队设计的强大上下文管理系统。Developer MCP 服务器会在您的编码会话期间维护持久上下文，确保您始终掌握项目的结构、依赖关系和进度。
持久开发环境：准确地从您上次会话中断的地方继续，提供有关您正在处理的组件、问题和任务的完整背景信息。
会话管理：开始新的开发会话并在完成后记录您的成就、任务更新和项目状态变化，从而创建开发活动的持久记录。
依赖关系跟踪：通过全面的依赖关系模型了解组件、功能和技术如何相互关联。
项目状态洞察：立即了解项目进度，包括组件、功能、问题和里程碑的状态。
组件上下文检索：一目了然地了解任何组件的用途、实现细节、依赖关系和相关问题。
决策历史：追踪架构和实施决策的制定原因、时间和制定者——无需再猜测为什么以某种方式构建某些东西。
里程碑进度跟踪：监控项目里程碑的进度，并在潜在瓶颈影响您的时间表之前发现它们。
相关实体发现：快速找到任何组件、功能或任务的所有相关实体，以了解其完整上下文。
Related MCP server: Context Management System
开发人员 MCP 服务器可识别软件开发环境中的以下类型的实体：
项目：整体软件项目或产品
组件：项目内的模块、服务、包或逻辑单元
功能：正在开发的特定功能
问题：需要解决的错误、问题或缺陷
任务：开发所需的工作项目或活动
开发人员：从事该项目的团队成员
技术：编程语言、框架、库或工具
决策：重要的技术或架构决策
里程碑：关键项目截止日期或阶段
环境：开发、准备或生产环境
文档：项目文档资源
要求：项目要求或规范
开发者 MCP 服务器模拟了实体之间的以下关系，反映了现实世界的软件开发动态：
取决于：实体 A 需要实体 B 才能运行
implements ：组件实现一个功能
已分配：任务已分配给开发人员
blocked_by ：任务因问题而被阻止
用途：组件使用一种技术
part_of ：组件是项目的一部分
contains ：项目包含一个组件
works_on ：开发人员正在开发一个项目/组件
related_to ：实体之间的一般关系
影响：问题影响组件
resolves ：任务解决了一个问题
created_by ：实体由开发人员创建
documented_in ：组件已在文档中记录
determined_in ：会议做出了决定
required_by ：功能是需求所必需的
has_status ：实体具有特定状态
depends_on_milestone ：任务取决于是否达到里程碑
先于：任务先于另一任务（排序）
评论：开发人员评论组件
tested_in ：组件在环境中进行测试
开发者 MCP 服务器提供以下工具：
startsession ：启动新的开发会话并提供有关最近的会话、活跃项目、高优先级任务和即将到来的里程碑的信息。
loadcontext ：加载实体（项目、组件、功能、任务等）的详细上下文，并将此上下文加载作为当前会话的一部分进行跟踪。
endsession ：通过多个阶段（总结、成就、任务更新、新任务、项目状态）对开发会话进行结构化分析，并将这些信息记录在持久知识图谱中。
buildcontext ：在知识图谱中创建新的实体、关系或观察。
deletecontext ：从知识图谱中删除实体、关系或观察。
advancedcontext ：使用不同的查询类型（图形、搜索、节点、相关、决策、里程碑）从知识图谱中检索信息。
以下是一些与开发者 MCP 服务器一起使用的示例提示：
"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?"开发者 MCP 服务器在以下场景中表现出色：
"Let me see the component I was working on yesterday and all its dependencies."服务器检索您最近访问的组件及其依赖项、问题和相关任务，使您能够立即恢复工作，而无需花费时间重建上下文。
"Give me an overview of Project X's architecture and component structure."新开发人员可以快速了解项目结构、关键组件及其关系，从而大大减少在新的代码库上投入生产所需的时间。
"End my development session and record what I accomplished."服务器将指导您完成一个结构化的过程来记录您的成就、任务更新和项目状态变化，并为未来的会议和团队成员保留这些背景信息。
"Why was GraphQL chosen over REST for the API layer?"服务器检索决策实体以及相关会议、涉及的开发人员以及做出决策的背景，从而保存否则会丢失的组织知识。
"What would be affected if we modify the authentication service?"在进行更改之前，开发人员可以了解依赖于特定组件的所有组件、功能和任务，从而降低意外中断的风险。
"What's our progress toward the Q2 release milestone?"项目负责人可以立即查看与里程碑相关的所有任务和功能的状态，并在危及时间表之前识别出有风险的项目。
将其添加到您的claude_desktop_config.json中：
{
"mcpServers": {
"developer": {
"command": "npx",
"args": [
"-y",
"github:tejpalvirk/developer"
]
}
}
}首先，全局安装包：
npm install -g github:tejpalvirk/contextmanager/developer然后配置Claude桌面：
{
"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 .此 MCP 服务器采用 MIT 许可证。这意味着您可以自由使用、修改和分发该软件，但须遵守 MIT 许可证的条款和条件。更多详情，请参阅项目仓库中的 LICENSE 文件。
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.
v1.0.0advancedcontextbuildcontextdeletecontextendsessionloadcontextstartsessionScored across 6 tools
Each 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.
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.
Save and retrieve your chosen context, manage shared workspaces, and track project time.
Codebase graphs, caller impact analysis, and recorded project context for AI coding agents.
