Project MCP Server
Supports containerized deployment of the Project MCP server through Docker, allowing for isolated and portable execution of the project management environment.
Enables installation directly from GitHub repositories, facilitating easy distribution and updates of the project management server.
Leverages npm for package management and installation, supporting both global installation and npx execution patterns for the project management server.
Click on "Deploy 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., "@Project MCP Server start a new session for the Q4 marketing campaign project"
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.
Project MCP Server
An MCP server implementation that provides tools for managing project knowledge graphs, enabling structured representation of projects, tasks, milestones, resources, and team members. This server helps project managers track progress, manage risks, allocate resources, and make informed decisions.
Features
Persistent Project Context: Maintain a structured knowledge graph of project entities and relationships across multiple sessions
Session Management: Track project management sessions with unique IDs and record progress over time
Project Status Tracking: Monitor project health, risks, and issue status in real time
Task Dependencies: Visualize and manage dependencies between tasks to identify bottlenecks
Milestone Progress: Track progress towards key project milestones
Resource Allocation: Monitor how resources are distributed across projects and tasks
Risk Assessment: Identify, monitor, and mitigate project risks
Decision Logging: Record important project decisions and their context
Team Member Management: Track assignments and workloads for team members
Project Timeline Analysis: Analyze project timelines including critical paths
Related MCP server: Student MCP Server
Entities
The Project MCP Server recognizes the following entity types:
project: The main container for all related entities
task: Individual work items that need to be completed
milestone: Key checkpoints or deliverables in the project
resource: Materials, tools, or assets needed for the project
teamMember: People involved in the project
note: Documentation, ideas, or observations
document: Formal project documents
issue: Problems or blockers
risk: Potential future problems
decision: Important choices made during the project
dependency: External requirements or prerequisites
component: Parts or modules of the project
stakeholder: People affected by or interested in the project
change: Modifications to project scope or requirements
status: Entity status values (inactive, active, complete)
priority: Priority level values (high, low)
Relationships
Entities can be connected through the following relationship types:
part_of: Indicates an entity is a component/subset of another
depends_on: Shows dependencies between entities
assigned_to: Links tasks to team members
created_by: Tracks who created an entity
modified_by: Records who changed an entity
related_to: Shows general connections between entities
blocks: Indicates one entity is blocking another
manages: Shows management relationships
contributes_to: Shows contributions to entities
documents: Links documentation to entities
scheduled_for: Connects entities to dates or timeframes
responsible_for: Assigns ownership/responsibility
reports_to: Indicates reporting relationships
categorized_as: Links entities to categories or types
required_for: Shows requirements for completion
discovered_in: Links issues to their discovery context
resolved_by: Shows what resolved an issue
impacted_by: Shows impact relationships
stakeholder_of: Links stakeholders to projects/components
prioritized_as: Indicates priority levels
has_status: Links entities to their current status (inactive, active, complete)
has_priority: Links entities to their priority level (high, low)
precedes: Indicates that one task comes before another in a sequence
Available Tools
The Project MCP Server provides these tools for interacting with project knowledge:
startsession
Starts a new project management session, generating a unique session ID and displaying current projects, tasks, milestones, risks, and recent sessions. Shows status information via has_status relations, priority levels via has_priority relations, and identifies tasks ready to be worked on next based on sequential dependencies.
loadcontext
Loads detailed context for a specific entity (project, task, etc.), displaying relevant information based on entity type. Includes status information (inactive, active, complete), priority levels (high, low), and sequential task relationships.
endsession
Records the results of a project management session through a structured, multi-stage process:
summary: Records session summary, duration, and project focus
achievements: Documents key achievements from the session
taskUpdates: Tracks updates to existing tasks
newTasks: Records new tasks created during the session
statusUpdates: Records changes to entity status values
projectStatus: Updates overall project status, priority assignments, and sequential relationships
assembly: Final assembly of all session data
buildcontext
Creates new entities, relations, or observations in the knowledge graph:
entities: Add new project-related entities (projects, tasks, milestones, status, priority, etc.)
relations: Create relationships between entities (including has_status, has_priority, precedes)
observations: Add observations to existing entities
deletecontext
Removes entities, relations, or observations from the knowledge graph:
entities: Remove project entities
relations: Remove relationships between entities (including status, priority, and sequential relations)
observations: Remove specific observations from entities
advancedcontext
Retrieves information from the knowledge graph:
graph: Get the entire knowledge graph
search: Search for nodes based on query criteria
nodes: Get specific nodes by name
related: Find related entities
status: Find entities with a specific status value (inactive, active, complete)
priority: Find entities with a specific priority value (high, low)
sequence: Identify sequential relationships for tasks
Domain-Specific Functions
The Project MCP Server includes specialized domain functions for project management:
getProjectOverview: Comprehensive view of a project including tasks, milestones, team members, issues, etc.
getTaskDependencies: Analyze task dependencies to identify blocked tasks and critical paths
getTeamMemberAssignments: View all assignments for a specific team member
getMilestoneProgress: Track progress towards project milestones
getProjectTimeline: Analyze project timeline and key dates
getResourceAllocation: Examine how resources are allocated across the project
getProjectRisks: Identify and assess project risks
findRelatedProjects: Discover connections between different projects
getDecisionLog: Track decision history and context
getProjectHealth: Assess overall project health with metrics and recommendations
getStatusOverview: View all entities with a specific status (inactive, active, complete)
getPriorityItems: Identify high-priority tasks and activities
getTaskSequence: Visualize the sequence of tasks based on precedes relations
Example Prompts
Starting a Session
Let's start a new project management session to review the Mobile App Development project.Loading Project Context
Load the context for the Mobile App Development project so I can see its current status.Recording Session Results
I've just finished a project review meeting for Mobile App Development. We completed the UI design milestone, identified 2 new risks related to the backend API, and assigned 3 new tasks to the development team. The UI tasks are now marked as complete, and we've set the API development tasks as high priority. The project is still on track but we need to monitor the API risks closely.Managing Project Knowledge
Create a new task called "Implement User Authentication" that's part of the Mobile App Development project, assigned to Sarah, with high priority and due in two weeks. Set its status to active and make it precede the "User Profile" task.Update the status of the "Database Migration" task to "completed" and add an observation that it was finished ahead of schedule.Usage
This MCP server enables project managers to:
Maintain Context Continuity: Keep track of project details across multiple planning sessions
Onboard New Team Members: Quickly get new team members up to speed on project status
Record Session Results: Document the outcomes of meetings and work sessions
Track Dependencies: Identify and manage critical dependencies and bottlenecks
Monitor Risk: Keep track of project risks and implement mitigation strategies
Allocate Resources: Optimize resource allocation across projects and tasks
Make Informed Decisions: Base decisions on comprehensive project data
Track Progress: Monitor entity status throughout the project lifecycle
Prioritize Work: Identify and focus on high-priority tasks
Sequence Tasks: Plan and visualize the logical order of project tasks
Configuration
Usage with Claude Desktop
Add this to your claude_desktop_config.json:
Install from GitHub and run with npx
{
"mcpServers": {
"project": {
"command": "npx",
"args": [
"-y",
"github:tejpalvirk/project"
]
}
}
}Install globally and run directly
First, install the package globally:
npm install -g github:tejpalvirk/projectThen configure Claude Desktop:
{
"mcpServers": {
"project": {
"command": "contextmanager-project"
}
}
}docker
{
"mcpServers": {
"project": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"mcp/project"
]
}
}
}Building
From Source
# Clone the repository
git clone https://github.com/tejpalvirk/contextmanager.git
cd contextmanager
# Install dependencies
npm install
# Build the server
npm run build
# Run the server
cd project
node project_index.jsDocker:
docker build -t mcp/project -f project/Dockerfile .License
This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
Environment Variables
The Project 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:
./project/memory.json
SESSIONS_FILE_PATH: Path where session data will be stored
Can be absolute or relative (relative paths use current working directory)
Default:
./project/sessions.json
Example usage:
# Store data in the current directory
MEMORY_FILE_PATH="./pm-memory.json" SESSIONS_FILE_PATH="./pm-sessions.json" npx github:tejpalvirk/contextmanager-project
# Store data in a specific location (absolute path)
MEMORY_FILE_PATH="/path/to/data/project-memory.json" npx github:tejpalvirk/contextmanager-project
# Store data in user's home directory
MEMORY_FILE_PATH="$HOME/contextmanager/project-memory.json" npx github:tejpalvirk/contextmanager-projectAvailable Tools
6 toolsadvancedcontextA
A sophisticated query tool for exploring, analyzing, and retrieving complex information from the project management knowledge graph.
When to use this tool:
Retrieving a comprehensive view of your entire project management structure
Searching for specific project entities across your initiatives
Getting detailed information about particular projects or project elements
Exploring task dependencies and their critical paths
Analyzing team member assignments and workload
Tracking milestone progress and completion status
Examining project timelines and schedules
Assessing resource allocation across projects
Identifying and monitoring project risks
Finding connections between related projects
Reviewing decision logs and project governance
Evaluating overall project health and status
Filtering entities by status values (inactive, active, complete)
Finding high-priority tasks and activities
Analyzing sequential relationships between tasks
Key features:
Offers specialized operations for querying different aspects of project management data
Retrieves complete or filtered views of the project knowledge graph
Provides flexible search capabilities across all project entities
Supports detailed exploration of specific entities by name
Generates comprehensive project overviews with related elements
Maps task dependencies to identify critical paths
Tracks team member assignments and responsibilities
Monitors milestone progress with completion metrics
Creates project timelines with key dates and dependencies
Manages resource allocation across project activities
Identifies and prioritizes project risks
Finds relationships between projects for portfolio management
Records and retrieves decision logs for governance
Assesses project health with key performance indicators
Filters entities by status via has_status relations
Identifies high-priority items via has_priority relations
Analyzes task sequencing through precedes relations
Parameters explained:
type: The type of query operation to perform
Accepts one of the specialized operations: "graph", "search", "nodes", "project", "dependencies", "assignments", "milestones", "timeline", "resources", "risks", "related", "decisions", "health", "status", "priority", "sequence"
Determines how the params parameter is interpreted
params: Operation-specific parameters (structure varies by type):
For "graph": No parameters needed (retrieves the full project knowledge graph)
For "search": Object containing:
query: Search string to find entities (supports entity type filters)
For "nodes": Object containing:
names: Array of entity names to retrieve
For "project": Object containing:
projectName: Name of the project to retrieve details for
For "dependencies": Object containing:
taskName: Name of the task to analyze dependencies for
depth: (Optional) How many levels of dependencies to retrieve (default: 2)
For "assignments": Object containing:
teamMemberName: Name of the team member to retrieve assignments for
For "milestones": Object containing:
projectName: Project name to retrieve milestones for
milestoneName: (Optional) Specific milestone to retrieve details for
For "timeline": Object containing:
projectName: Project name to generate timeline for
For "resources": Object containing:
projectName: Project name to analyze resource allocation for
resourceName: (Optional) Specific resource to analyze allocation for
For "risks": Object containing:
projectName: Project name to retrieve risks for
For "related": Object containing:
projectName: Project name to find related projects for
depth: (Optional) Depth of project relationships to explore (default: 1)
For "decisions": Object containing:
projectName: Project name to retrieve decision log for
For "health": Object containing:
projectName: Project name to assess health for
For "status": Object containing:
statusValue: The status value to filter by (e.g., "inactive", "active", "complete")
For "priority": Object containing:
priorityValue: The priority value to filter by (e.g., "high", "low")
For "sequence": Object containing:
taskName: Name of the task to analyze sequential relationships for
Operation details:
graph: Returns the complete project knowledge graph with all entities and relationships
search: Performs text-based search across entity names and observations
nodes: Retrieves detailed information about specific entities by name
project: Returns comprehensive project information including tasks, milestones, and team members
dependencies: Maps task dependencies to identify critical paths and bottlenecks
assignments: Lists all assignments for a specific team member with workload information
milestones: Tracks milestone progress with completion status and metrics
timeline: Generates a project timeline with key dates, dependencies, and current status
resources: Analyzes resource allocation across project activities
risks: Identifies and prioritizes project risks with mitigation strategies
related: Finds connections between projects for portfolio management
decisions: Retrieves decision log for project governance and audit
health: Assesses project health with key performance indicators and metrics
status: Retrieves all entities with a specific status value (inactive, active, complete)
priority: Retrieves all entities with a specific priority value (high, low)
sequence: Identifies sequential relationships for tasks, showing preceding and following tasks
Status and Priority Information:
Status queries return entities organized by their current state in the project lifecycle
Priority queries help identify critical project tasks and elements
Status values include: inactive, active, complete
Priority values include: high, low
Status and priority are assigned through has_status and has_priority relations
Sequential Task Information:
Sequence queries identify tasks that come before or after in a project workflow
Sequential relationships help visualize the project workflow and dependencies
The sequence operation shows both incoming and outgoing precedes relations
Task sequences are critical for project planning and critical path identification
Return information:
success: Boolean indicating whether the operation succeeded
Additional fields depend on the operation type:
graph: Complete knowledge graph
results: For search operations
nodes: For specific entity retrieval
project/dependencies/assignments/etc.: For specialized views
status/priority: Lists of entities with specified status/priority values
sequence: Preceding and following tasks in project workflows
You should:
Start with broad queries ("graph", "search") to explore your project portfolio
Use specific entity queries ("nodes", "project") for detailed information
Map task dependencies to identify critical paths and bottlenecks
Track team member assignments to manage workload and availability
Monitor milestone progress to ensure project timeline adherence
Generate project timelines for planning and tracking purposes
Analyze resource allocation to optimize utilization
Identify and prioritize project risks for proactive management
Find relationships between projects for portfolio-level insights
Review decision logs for governance and accountability
Assess project health regularly with the health operation
Use status queries to filter entities by their current state
Use priority queries to focus on high-priority items
Use sequence queries to understand task workflows and dependencies
Combine multiple operations to build comprehensive project dashboards
Inputs: params (required), type (required).
buildcontextA
A versatile tool for constructing and enhancing your project management knowledge graph by adding new project elements, relationships, and observations.
When to use this tool:
Creating new project entities (projects, tasks, milestones, team members, etc.)
Establishing relationships between project elements (e.g., connecting tasks to projects, assigning team members)
Adding observations, properties, or metadata to existing project entities
Building the project management structure incrementally as your project evolves
Organizing and structuring project data within your management framework
Documenting project status, risks, and decisions
Tracking project dependencies and assignments
Creating comprehensive project timelines with connected elements
Setting status values for project entities
Assigning priorities to tasks and other entities
Defining task sequencing and dependencies
Key features:
Creates three distinct types of knowledge graph elements: entities, relations, and observations
Supports various project management entity types (projects, tasks, milestones, team members, etc.)
Validates entity and relation types against predefined standards for the project domain
Handles batch creation of multiple entities or relations in a single operation
Returns confirmation with details of created elements
Ensures proper data typing and structure for the project management knowledge graph
Enables comprehensive documentation of project structure and progress
Supports status and priority assignment through entity-relation model
Enables sequential task relationships through precedes relation
Parameters explained:
type: The type of creation operation to perform
Accepts: "entities", "relations", or "observations"
Determines how the data parameter is interpreted
data: The content to add to the knowledge graph (structure varies by type):
For "entities": An array of objects, each containing:
name: Unique identifier for the entity
entityType: One of the valid entity types for project management
observations: Array of strings containing properties or metadata about the entity
embedding: (Optional) Vector embedding for enhanced semantic search
For "relations": An array of objects, each containing:
from: Name of the source entity
to: Name of the target entity
relationType: The type of relationship between entities (e.g., "depends_on", "assigned_to", "has_status")
observations: (Optional) Array of strings with metadata about the relationship
For "observations": Either a single object or an array of objects:
Single object format:
entityName: Name of the entity to add observations to
observations: Array of strings with new observations to add
Array format:
Each object containing:
entityName: Name of the entity to add observations to
contents: Array of strings with new observations to add
Valid entity types:
project: Overall project container
task: Individual action items or work packages
milestone: Key project checkpoints
teamMember: Project team participants
risk: Potential project threats or issues
decision: Documented project decisions
resource: Project assets or materials
issue: Problems requiring resolution
dependency: Inter-element relationships
meeting: Project-related gatherings
document: Project files and documentation
stakeholder: Parties with interest in the project
status: Entity status (inactive, active, complete)
priority: Entity priority (low, high)
Valid relation types:
part_of: Entity belongs to another entity
depends_on: Task dependency relationship
assigned_to: Assignment relationship between tasks and team members
responsible_for: Ownership of project elements
created_by: Authorship relationship
leads_to: Sequential relationship
blocks: Impediment relationship
reports_to: Organizational hierarchy
collaborates_with: Collaborative relationship
decides_on: Decision-making relationship
impacts: Effect relationship
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)
Status Values:
inactive: Work on the entity has not begun or is paused
active: Work is actively underway
complete: Work has been finished
Priority Values:
low: Lower priority item
high: Higher priority item
Return information:
JSON response indicating success or failure
For successful operations:
Success flag set to true
Details of created elements in the "created" field (for entities/relations) or info message for observations
For failed operations:
Success flag set to false
Error message describing the issue
Error handling:
Returns descriptive error messages for invalid inputs
Gracefully handles type mismatches and formatting errors
Rejects operations with invalid types
You should:
Use consistent naming conventions for entities to facilitate relationships and retrieval
Begin by creating projects before more specific project elements
Add detailed observations to entities to enhance context and searchability
Create relationships to build a comprehensive network of interconnected project data
Document project status and progress through has_status relations
Assign priorities to tasks using has_priority relations
Use the precedes relation to establish task sequences and dependencies
Assign specific team members to tasks using relations
Track project risks with detailed observations
Document decisions with context and rationale
Update entity observations regularly to reflect current project information
Check the operation result to confirm successful creation
Inputs: data (required), type (required).
deletecontextA
A precise tool for removing elements from the project management knowledge graph, enabling project managers to maintain data accuracy and refine their project structure as needs evolve.
When to use this tool:
Removing completed or canceled projects or tasks
Deleting erroneous relationships between project elements
Clearing outdated observations from project entities
Restructuring your project organization as the project evolves
Removing team members who are no longer part of the project
Correcting relationships between tasks, milestones, and resources
Cleaning up the knowledge graph during project phase transitions
Eliminating deprecated risks or issues that are no longer relevant
Removing preliminary project elements that have been superseded
Reorganizing your project structure by removing and recreating elements
Updating status assignments when task or project states change
Modifying priority levels as project needs shift
Restructuring sequential relationships between tasks and activities
Key features:
Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
Maintains knowledge graph integrity during deletion operations
Supports batch deletion of multiple items in a single operation
Returns clear confirmation of deletion results
Preserves the overall structure of the project knowledge graph while removing specific elements
Performs validation to ensure deletion requests are properly formatted
Handles status and priority relation management
Supports modification of task sequencing relationships
Parameters explained:
type: The type of deletion operation to perform
Accepts: "entities", "relations", or "observations"
Determines how the data parameter is interpreted
data: The elements to remove from the knowledge graph (structure varies by type):
For "entities": Array of entity names to delete
Example: ["Task_A", "Milestone_1"]
For "relations": Array of relation objects, each containing:
from: Name of the source entity
to: Name of the target entity
relationType: Type of relationship to remove (e.g., "part_of", "has_status", "has_priority", "precedes")
Example: [{ "from": "Task_A", "to": "Milestone_1", "relationType": "part_of" }]
For "observations": Array of objects, each containing:
entityName: Name of the entity to remove observations from
observations: Array of specific observations to remove
Example: [{ "entityName": "Project_X", "observations": ["duration:3 months", "budget:10000"] }]
Deletion behavior by type:
Entities: Removes the specified entities and all their associated relations from the knowledge graph
Relations: Removes only the specified relationships, leaving the connected entities intact
Observations: Removes specific observations from entities while preserving the entities themselves
Status and Priority Management:
When deleting status or priority entities, be aware that all has_status or has_priority relations using these entities will be removed
For changing an entity's status, delete the existing has_status relation before creating a new one
For changing priority, delete the existing has_priority relation before creating a new one
Status values (inactive, active, complete) are managed through relations, not direct properties
Priority values (low, high) are managed through relations, not direct properties
Sequential Task Management:
Removing precedes relations will affect task sequencing and dependencies
When reorganizing project tasks, update all affected precedes relations
Consider the impact on project timelines when modifying sequential relationships
Safety considerations:
Entity deletion is permanent and will also remove all relationships involving those entities
Consider exporting or backing up your project knowledge graph before performing large-scale deletions
For sensitive operations, consider removing specific observations rather than entire entities
When removing key project elements, consider the impact on your overall project structure
Status changes should be carefully managed to maintain accurate project tracking
Changes to task sequences may affect dependent project activities
Return information:
JSON response indicating success or failure
For successful operations:
Success flag set to true
Confirmation message with count of deleted items
For entities: "Deleted X entities"
For relations: "Deleted X relations"
For observations: "Deleted observations from X entities"
For failed operations:
Success flag set to false
Error message describing the issue
You should:
Be specific in your deletion requests to avoid unintended data loss
Use relations deletion when you want to disconnect entities without removing them
For observations, provide the exact observations to ensure only the intended content is removed
When restructuring your project, consider how deletions will affect related elements
Use deletecontext in conjunction with buildcontext to refine and evolve your project structure
Regularly review your knowledge graph for elements that may need to be removed or updated
Consider the cascading effects of entity deletion on your overall project structure
Delete completed tasks and milestones systematically when closing project phases
Remove resolved risks and issues to keep your project status current
When updating entity status, delete the old has_status relation before creating a new one
When updating entity priority, delete the old has_priority relation before creating a new one
Maintain logical consistency when modifying sequential task relationships
Inputs: data (required), type (required).
endsessionA
A multi-stage tool for documenting project management sessions, recording achievements, tracking task updates, and creating a structured record of project evolution.
When to use this tool:
Concluding a project planning or review session
Documenting decisions made during team meetings
Recording updates to tasks and their status
Tracking new tasks created during work sessions
Documenting changes to project risk assessments
Updating overall project status information
Creating a structured record of project activities
Establishing a formal conclusion to a focused work period
Building a historical record of project development
Preserving context for future team members or sessions
Updating entity status values and tracking progress
Modifying task priorities as project needs evolve
Establishing or modifying sequential relationships between tasks
Key features:
Provides a structured, multi-stage workflow for project session documentation
Records project decisions and achievements in the knowledge graph
Captures task status updates and progress information
Tracks creation of new tasks with descriptions and priorities
Documents risk updates with impact and probability assessments
Updates project status information
Maintains session continuity with unique session IDs
Supports revision of previous stages when needed
Offers a comprehensive assembly stage that consolidates all session information
Manages status progression of project entities via has_status relations
Tracks priority assignments for tasks via has_priority relations
Documents sequential task relationships via precedes relations
The endsession tool uses a sequential, multi-stage approach with 7 typical stages:
Summary Stage: Records basic session information
Achievements Stage: Documents decisions and accomplishments
Task Updates Stage: Records changes to existing tasks
New Tasks Stage: Documents newly created tasks
Status Updates Stage: Records changes to entity status values
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 project session
Obtained from the startsession tool
Example: "proj_1234567890_abc123"
stage: Required - Current stage of the endsession workflow
Accepts: "summary", "achievements", "taskUpdates", "newTasks", "statusUpdates", "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 the stages
Used to track progress through the session documentation workflow
totalStages: Required - Total number of stages planned for this workflow
Typically 7 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 marketing campaign project"
stageData: Optional - Stage-specific structured data
Structure varies by stage type:
summary: { summary: "Session summary text", duration: "3 hours", project: "ProjectName" }
achievements: { achievements: ["Decision 1", "Accomplishment 2"] }
taskUpdates: { updates: [{ name: "Task1", status: "active", progress: "50%" }] }
newTasks: { tasks: [{ name: "New Task", description: "Details", priority: "high", precedes: "Task3" }] }
statusUpdates: { statusUpdates: [{ entityName: "Task1", newStatus: "complete", note: "Finished implementation" }, { entityName: "Risk1", newStatus: "inactive", note: "Risk mitigated" }] }
projectStatus: { projectStatus: "active", projectObservation: "Good progress", priorityUpdates: [{ entityName: "Task2", priority: "high", note: "Critical for launch" }], sequenceUpdates: [{ before: "Task1", after: "Task4", note: "Rearranged sequence to optimize workflow" }] }
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
Status and Priority Management:
The statusUpdates stage allows for batch updates to entity status values
Valid status values include: inactive, active, complete
Priority assignments (high, low) can be modified in the projectStatus stage
Status changes are implemented through has_status relations
Priority changes are implemented through has_priority relations
Status and priority changes are tracked to maintain project progress history
Sequential Task Management:
The projectStatus stage allows for defining or modifying sequential relationships
The precedes relation is used to establish logical ordering between tasks
New tasks can specify which tasks they precede or follow
Sequential updates help maintain a coherent project workflow
Task sequences can be visualized through the loadcontext tool
When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool performs these actions:
Records the session completion in persistent storage
Creates a summary of all documented information
Updates the project status in the knowledge graph
Links all achievements, task updates, and risk information
Updates status, priority, and sequential relationships for relevant entities
Return information:
JSON response with the following structure when stages are in progress:
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
Formatted markdown text summary when the session is completed, including:
Session date and project name
Decisions documented
Task updates
Status changes
Priority modifications
Task sequencing changes
Project status
New tasks added
Risk updates
Session summary
You should:
Complete all stages in order for comprehensive session documentation
Provide specific details in each stage for accurate project documentation
Specify task updates with clear status information using valid values (inactive, active, complete)
Include priority levels (high, low) when adding new tasks or updating priorities
Document all key decisions made during the session as achievements
Update entity status using has_status relations with valid status values
Define task sequences using precedes relations to establish workflow
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
Use the unique session ID consistently across all stages
Inputs: nextStageNeeded (required), sessionId (required), stage (required), stageNumber (required), +5 more.
loadcontextA
A powerful tool for retrieving detailed contextual information about project entities, providing rich insights tailored to each entity type in the project management domain.
When to use this tool:
Retrieving comprehensive information about projects, tasks, milestones, and team members
Exploring task dependencies and critical path information
Examining milestone progress and completion status
Reviewing team member assignments and workload
Analyzing resource allocation and availability
Inspecting project risks and issues
Preparing for project status updates and planning meetings
Examining project timelines and progress metrics
Getting a holistic view of project status and health
Understanding relationships between project entities
Viewing entity status information (inactive, active, complete)
Checking priority levels for tasks and activities
Understanding sequential relationships between tasks
Key features:
Provides richly formatted, context-aware information about project management entities
Adapts output format based on entity type (project, task, milestone, teamMember, resource)
Presents both direct entity information and related elements
Shows project metrics, task completion rates, and milestone progress
Tracks entity views within the current project session
Formats information in a structured, readable markdown format
Highlights relationships between tasks, milestones, and team members
Presents critical path information for task dependencies
Shows resource utilization metrics and availability
Displays status information via has_status relations
Shows priority levels via has_priority relations
Presents sequential relationships through precedes relations
Parameters explained:
entityName: Required - The name of the entity to retrieve context for
Example: "Marketing Campaign Q4", "Design Homepage", "Website Launch"
entityType: Optional - The type of entity being retrieved
Default: "project"
Helps the system format the output appropriately
Common types include: "project", "task", "milestone", "teamMember", "resource", "status", "priority"
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 project status (via has_status), description, timeline, budget, goal, tasks, milestones, issues, team members, risks, and task completion rate
Task: Displays project affiliation, status (inactive, active, complete), priority (low, high), due date, assignee, description, critical path status, task dependencies, and task sequencing (preceding and following tasks)
Milestone: Shows project affiliation, status (via has_status), date, completion criteria, description, progress percentage, days remaining, required tasks, and blocking tasks
Team Member: Displays role, skills, availability, workload, assigned tasks, projects, upcoming deadlines, and overdue tasks
Resource: Shows type, project affiliation, availability, capacity, cost, usage percentage, assigned tasks, and team members using the resource
Status: Shows all entities assigned this status value, organized by entity type
Priority: Shows all entities assigned this priority value, organized by entity type
Other Entity Types: Shows basic entity information, observations, incoming relations, and outgoing relations
Status and Priority Information:
All entity displays include status information when available via has_status relations
Tasks and other prioritized elements show priority assignments via has_priority relations
Valid status values include: inactive, active, complete
Valid priority values include: high, low
Sequential Task Relationships:
Task displays show preceding and following tasks through precedes relations
Sequential relationships are visualized to show workflow between tasks
Tasks display their position in the overall project workflow
Critical path information highlights essential task sequences
Return information:
Formatted markdown text with hierarchical structure
Sections adapted to the specific entity type
Related entities shown with their relationships
Progress metrics and completion statistics where applicable
Status and priority information prominently displayed
Sequential relationships clearly indicated
Error messages if the entity doesn't exist or can't be retrieved
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
Examine task context to understand dependencies and critical path
Review milestone context to assess progress towards key deliverables
Use team member context to evaluate workload and assignments
Explore resource context to understand allocation and availability
Check status entities to see all project elements at the same stage
Review priority entities to identify critical project tasks
Explore sequential relationships to understand task workflows
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
Inputs: entityName (required), entityType, sessionId.
startsessionA
A comprehensive tool for initializing a new project management session, providing structured information about ongoing projects, tasks, deadlines, and overall project health.
When to use this tool:
Beginning a new project management session
Getting oriented to your current project portfolio status
Planning which projects or tasks to focus on in the current work session
Reviewing recent project activity and progress
Checking upcoming deadlines for tasks and milestones
Assessing the health of active projects
Identifying high-priority tasks requiring attention
Reviewing project risks that need mitigation
Establishing context before diving into specific project work
Creating a structured record of your project management activity
Tracking the status of various project entities
Managing sequential task dependencies
Key features:
Generates a unique session identifier for tracking project management activities
Retrieves and displays your most recent project management sessions
Shows active projects you're currently managing with status information
Highlights high-priority tasks requiring attention
Lists upcoming milestones with progress metrics
Provides project health summaries with status indicators
Identifies top project risks requiring mitigation
Formats information in a structured, easy-to-read format
Integrates with the loadcontext tool for deeper exploration
Maintains continuity between project management sessions
Displays status information through has_status relations
Shows priority assignments through has_priority relations
Presents task sequencing through precedes relations
Parameters explained: No parameters required - the tool automatically retrieves all relevant context.
Return information:
Session ID: A unique identifier for this project management session
Recent Project Management Sessions: Up to 3 most recent sessions with:
Date
Project focus
Session summary (truncated for readability)
Active Projects: List of current projects with:
Project name
Current status (via has_status relation)
Deadline information
High-Priority Tasks: Up to 10 highest priority tasks with:
Task name
Associated project
Status (inactive, active, complete)
Priority (high via has_priority relation)
Assignee
Upcoming Milestones: Up to 8 nearest milestones with:
Milestone name
Associated project
Due date
Completion percentage
Status (via has_status relation)
Project Health Summary: Status of active projects with:
Project name
Health status indicator
Health score
Issue count
Risk count
Top Project Risks: Up to 5 highest severity risks with:
Risk name
Associated project
Severity level
Impact assessment
Next Sequence Tasks: Up to 5 tasks ready to be worked on next based on sequential dependencies:
Task name
Associated project
Status (via has_status relation)
Prerequisites completion status
Status and Priority Information:
Project and task status is retrieved through has_status relations
Valid status values include: inactive, active, complete
Task priority is retrieved through has_priority relations
Valid priority values include: high, low
This information helps you prioritize your project management activities
Sequential Task Management:
Tasks are presented in their logical sequence based on precedes relations
Prerequisite tasks must be completed before dependent tasks can begin
The sequential view helps identify the next logical actions in project workflows
Critical path tasks are highlighted to show dependencies affecting project timelines
Session Workflow:
Start a project management session with startsession
Review the provided context to decide what to focus on
Use loadcontext to retrieve detailed information about specific projects
Conduct your project management work, adding new elements with buildcontext as needed
End the session when work is complete
Record progress, decisions, and next steps
You should:
Begin each focused project management period with startsession
Review recent sessions to maintain continuity in your work
Prioritize work based on high-priority tasks and upcoming milestones
Address projects with poor health indicators
Mitigate high-severity risks promptly
Focus on tasks that are next in sequence based on precedes relations
Complete prerequisite tasks to unblock dependent tasks
Check entity status to identify active work items
Use the session ID when using other tools to maintain session tracking
Establish a regular cadence of project management sessions
Use the structured overview to make deliberate choices about where to focus your effort
Consider creating or updating project entities after reviewing the current state
Follow up on projects with approaching deadlines
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each tool has a distinct, non-overlapping purpose: advancedcontext for querying, buildcontext for creating, deletecontext for deleting, endsession for session documentation, loadcontext for retrieving entity details, and startsession for session initialization. The descriptions clearly differentiate their functions, eliminating ambiguity.
Most tools follow a consistent pattern with a verb or action prefix (advanced, build, delete, end, load, start) followed by 'context' or 'session', making them predictable. However, 'advancedcontext' deviates slightly by using an adjective instead of a verb, and 'loadcontext' uses 'load' while others use more specific verbs like 'build' or 'delete', but overall the naming is readable and coherent.
With 6 tools, the server is well-scoped for project management, covering essential operations like querying, creating, deleting, session handling, and entity retrieval. Each tool serves a clear purpose without redundancy, making the count appropriate for the domain.
The tool set provides comprehensive coverage for project management: advancedcontext handles complex queries, buildcontext enables CRUD-like creation, deletecontext allows removal, endsession documents sessions, loadcontext retrieves details, and startsession initializes sessions. There are no obvious gaps; the tools support full lifecycle management, status/priority handling, and sequential dependencies.
Maintenance
Related MCP Connectors
Durable, shareable and governed project memory with smart triage and explicit project composition.
Project management shared by people and AI agents, with persistent project state through MCP.
A graph-based task manager your agent can read and update: tasks, dependencies, blockers.
Project memory for coding agents: requirements, decisions, code graph and delivery telemetry.
Related MCP Servers
- AlicenseAqualityDmaintenanceProvides tools for managing qualitative research knowledge graphs, enabling structured representation of research projects, participants, interviews, observations, codes, themes, and findings.610MIT
- AlicenseAqualityDmaintenanceProvides tools for managing student knowledge graphs, enabling structured representation of courses, assignments, exams, concepts, and study resources.61MIT
- AlicenseAqualityNot gradedmaintenanceProvides centralized knowledge management for projects, allowing users to store, search, and maintain project-specific knowledge that persists across sessions.2714 npm1-
- AlicenseAqualityDmaintenanceEnables creating, managing, analyzing, and visualizing knowledge graphs with support for multiple graph types (topology, timelines, changelogs, requirements, knowledge bases, ontologies) including node/edge management and resource association.1520 npm1MIT