| buildcontext | 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)
|
| deletecontext | 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
|
| advancedcontext | 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
|
| startsession | 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
|
| loadcontext | 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
|
| endsession | 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
|