| 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: 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: 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: 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: Active Projects: List of active software projects with their status High-Priority Tasks: Tasks with high priority status (via has_priority relation) including: Upcoming Milestones: Milestones with active status including:
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 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
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 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 totalStages: Required - Total number of stages planned for this workflow analysis: Optional - Text analysis or observations for the current stage 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 isRevision: Optional - Whether this is revising a previous stage revisesStage: Optional - If revising, which stage number is being revised
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
|