This is page 1 of 9. Use http://codebase.md/tejpalvirk/contextmanager?page={x} to view the full context.
# Directory Structure
```
├── .gitattributes
├── .gitignore
├── build-all-domains.sh
├── developer
│ ├── .gitattributes
│ ├── developer_advancedcontext.txt
│ ├── developer_buildcontext.txt
│ ├── developer_deletecontext.txt
│ ├── developer_endsession_examples.txt
│ ├── developer_endsession.txt
│ ├── developer_loadcontext.txt
│ ├── developer_startsession.txt
│ ├── Dockerfile
│ ├── index.d.ts
│ ├── index.js
│ ├── index.ts
│ ├── package.json
│ ├── README.md
│ └── tsconfig.json
├── dist
│ ├── developer
│ │ ├── index.d.ts
│ │ └── index.js
│ ├── main
│ │ ├── descriptions
│ │ │ ├── common_advancedcontext.txt
│ │ │ ├── common_buildcontext.txt
│ │ │ ├── common_deletecontext.txt
│ │ │ ├── common_endsession.txt
│ │ │ ├── common_loadcontext.txt
│ │ │ ├── common_startsession.txt
│ │ │ ├── developer_advancedcontext.txt
│ │ │ ├── developer_buildcontext.txt
│ │ │ ├── developer_deletecontext.txt
│ │ │ ├── developer_endsession_examples.txt
│ │ │ ├── developer_endsession.txt
│ │ │ ├── developer_loadcontext.txt
│ │ │ ├── developer_startsession.txt
│ │ │ ├── project_advancedcontext.txt
│ │ │ ├── project_buildcontext.txt
│ │ │ ├── project_deletecontext.txt
│ │ │ ├── project_endsession_examples.txt
│ │ │ ├── project_endsession.txt
│ │ │ ├── project_loadcontext.txt
│ │ │ ├── project_startsession.txt
│ │ │ ├── qualitativeresearch_advancedcontext.txt
│ │ │ ├── qualitativeresearch_buildcontext.txt
│ │ │ ├── qualitativeresearch_deletecontext.txt
│ │ │ ├── qualitativeresearch_endsession_examples.txt
│ │ │ ├── qualitativeresearch_endsession.txt
│ │ │ ├── qualitativeresearch_loadcontext.txt
│ │ │ ├── qualitativeresearch_startsession.txt
│ │ │ ├── quantitativeresearch_advancedcontext.txt
│ │ │ ├── quantitativeresearch_buildcontext.txt
│ │ │ ├── quantitativeresearch_deletecontext.txt
│ │ │ ├── quantitativeresearch_endsession_examples.txt
│ │ │ ├── quantitativeresearch_endsession.txt
│ │ │ ├── quantitativeresearch_loadcontext.txt
│ │ │ ├── quantitativeresearch_startsession.txt
│ │ │ ├── student_advancedcontext.txt
│ │ │ ├── student_buildcontext.txt
│ │ │ ├── student_deletecontext.txt
│ │ │ ├── student_endsession_examples.txt
│ │ │ ├── student_endsession.txt
│ │ │ ├── student_loadcontext.txt
│ │ │ └── student_startsession.txt
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── mcp.d.ts
│ │ └── mcp.js
│ ├── project
│ │ ├── index.d.ts
│ │ └── index.js
│ ├── qualitativeresearch
│ │ ├── index.d.ts
│ │ └── index.js
│ ├── quantitativeresearch
│ │ ├── index.d.ts
│ │ └── index.js
│ └── student
│ ├── index.d.ts
│ └── index.js
├── main
│ ├── descriptions
│ │ ├── common_advancedcontext.txt
│ │ ├── common_buildcontext.txt
│ │ ├── common_deletecontext.txt
│ │ ├── common_endsession.txt
│ │ ├── common_loadcontext.txt
│ │ ├── common_startsession.txt
│ │ ├── developer_advancedcontext.txt
│ │ ├── developer_buildcontext.txt
│ │ ├── developer_deletecontext.txt
│ │ ├── developer_endsession_examples.txt
│ │ ├── developer_endsession.txt
│ │ ├── developer_loadcontext.txt
│ │ ├── developer_startsession.txt
│ │ ├── project_advancedcontext.txt
│ │ ├── project_buildcontext.txt
│ │ ├── project_deletecontext.txt
│ │ ├── project_endsession_examples.txt
│ │ ├── project_endsession.txt
│ │ ├── project_loadcontext.txt
│ │ ├── project_startsession.txt
│ │ ├── qualitativeresearch_advancedcontext.txt
│ │ ├── qualitativeresearch_buildcontext.txt
│ │ ├── qualitativeresearch_deletecontext.txt
│ │ ├── qualitativeresearch_endsession_examples.txt
│ │ ├── qualitativeresearch_endsession.txt
│ │ ├── qualitativeresearch_loadcontext.txt
│ │ ├── qualitativeresearch_startsession.txt
│ │ ├── quantitativeresearch_advancedcontext.txt
│ │ ├── quantitativeresearch_buildcontext.txt
│ │ ├── quantitativeresearch_deletecontext.txt
│ │ ├── quantitativeresearch_endsession_examples.txt
│ │ ├── quantitativeresearch_endsession.txt
│ │ ├── quantitativeresearch_loadcontext.txt
│ │ ├── quantitativeresearch_startsession.txt
│ │ ├── student_advancedcontext.txt
│ │ ├── student_buildcontext.txt
│ │ ├── student_deletecontext.txt
│ │ ├── student_endsession_examples.txt
│ │ ├── student_endsession.txt
│ │ ├── student_loadcontext.txt
│ │ └── student_startsession.txt
│ ├── index.js
│ ├── index.ts
│ ├── mcp.ts
│ ├── package.json
│ ├── README.md
│ └── tsconfig.json
├── package-lock.json
├── package.json
├── project
│ ├── .gitattributes
│ ├── Dockerfile
│ ├── index.d.ts
│ ├── index.js
│ ├── index.ts
│ ├── package.json
│ ├── project_advancedcontext.txt
│ ├── project_buildcontext.txt
│ ├── project_deletecontext.txt
│ ├── project_endsession_examples.txt
│ ├── project_endsession.txt
│ ├── project_loadcontext.txt
│ ├── project_startsession.txt
│ ├── README.md
│ └── tsconfig.json
├── qualitativeresearch
│ ├── .gitattributes
│ ├── Dockerfile
│ ├── index.d.ts
│ ├── index.js
│ ├── index.ts
│ ├── package.json
│ ├── qualitativeresearch_advancedcontext.txt
│ ├── qualitativeresearch_buildcontext.txt
│ ├── qualitativeresearch_deletecontext.txt
│ ├── qualitativeresearch_endsession_examples.txt
│ ├── qualitativeresearch_endsession.txt
│ ├── qualitativeresearch_loadcontext.txt
│ ├── qualitativeresearch_startsession.txt
│ ├── README.md
│ └── tsconfig.json
├── quantitativeresearch
│ ├── .gitattributes
│ ├── Dockerfile
│ ├── index.d.ts
│ ├── index.js
│ ├── index.ts
│ ├── package.json
│ ├── quantitativeresearch_advancedcontext.txt
│ ├── quantitativeresearch_buildcontext.txt
│ ├── quantitativeresearch_deletecontext.txt
│ ├── quantitativeresearch_endsession_examples.txt
│ ├── quantitativeresearch_endsession.txt
│ ├── quantitativeresearch_loadcontext.txt
│ ├── quantitativeresearch_startsession.txt
│ ├── README.md
│ └── tsconfig.json
├── README.md
├── student
│ ├── .gitattributes
│ ├── Dockerfile
│ ├── index.d.ts
│ ├── index.js
│ ├── index.ts
│ ├── package.json
│ ├── README.md
│ ├── student_advancedcontext.txt
│ ├── student_buildcontext.txt
│ ├── student_deletecontext.txt
│ ├── student_endsession_examples.txt
│ ├── student_endsession.txt
│ ├── student_loadcontext.txt
│ ├── student_startsession.txt
│ └── tsconfig.json
└── tsconfig.json
```
# Files
--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
```
*.ts linguist-language=TypeScript
*.js linguist-generated=true
```
--------------------------------------------------------------------------------
/developer/.gitattributes:
--------------------------------------------------------------------------------
```
*.ts linguist-language=TypeScript
*.js linguist-generated=true
```
--------------------------------------------------------------------------------
/project/.gitattributes:
--------------------------------------------------------------------------------
```
*.ts linguist-language=TypeScript
*.js linguist-generated=true
```
--------------------------------------------------------------------------------
/qualitativeresearch/.gitattributes:
--------------------------------------------------------------------------------
```
*.ts linguist-language=TypeScript
*.js linguist-generated=true
```
--------------------------------------------------------------------------------
/quantitativeresearch/.gitattributes:
--------------------------------------------------------------------------------
```
*.ts linguist-language=TypeScript
*.js linguist-generated=true
```
--------------------------------------------------------------------------------
/student/.gitattributes:
--------------------------------------------------------------------------------
```
*.ts linguist-language=TypeScript
*.js linguist-generated=true
```
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
```
# Directories
backup/
backup_built/
backup_domains/
docs/
tests/
node_modules/
coverage/
.vscode/
.idea/
.DS_Store
*.py
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
lerna-debug.log*
# Diagnostic reports
report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
# Runtime data
pids
*.pid
*.seed
*.pid.lock
# Environment variables
.env
.env.local
.env.development.local
.env.test.local
.env.production.local
# Build artifacts
*.js.map
*.tsbuildinfo
**/*.js.map
# Tests
/tests
/coverage
# Documentation
/docs
# Temporary files
.tmp/
.temp/
```
--------------------------------------------------------------------------------
/main/README.md:
--------------------------------------------------------------------------------
```markdown
# MCP Context Manager
A unified Model Context Protocol (MCP) server that orchestrates multiple domain-specific MCP servers. This context manager provides a central interface for accessing and managing context across different knowledge domains.
## Features
- **Domain Management**: Set and switch between different context domains (developer, project, student, etc.)
- **Session Management**: Create and manage sessions for different domains
- **Context Operations**: Build, load, and manipulate context for different entity types
- **Cross-Domain Support**: Work with multiple knowledge domains through a single interface, including creating relationships between entities in different domains
- **Domain Discovery**: Explore available domains and their entity types
- **Direct Integration**: Communicates directly with domain-specific MCP servers
## Implementation
The Context Manager uses the MCP Client SDK to communicate with domain-specific MCP servers. It:
1. Maintains a registry of domain servers with their connection information
2. Creates MCP clients to connect to each domain server
3. Routes requests to the appropriate domain server based on the active domain
4. Provides cross-domain functionality for relating entities across domains
## Path Resolution
The Context Manager uses absolute paths constructed at runtime to locate domain servers. This approach:
- Ensures consistent path resolution regardless of the current working directory
- Makes the code portable and sharable on GitHub
- Uses Node.js's `path.resolve()` with `import.meta.url` to create absolute paths relative to the context manager's location
If you need to modify paths to domain servers, update the `domains` array in `main/index.ts`.
## Available Domains
The context manager provides access to the following domains:
1. **Developer Domain**: Software development context with entities like projects, components, and tasks
2. **Project Domain**: Project management context with entities like projects, tasks, and resources
3. **Student Domain**: Educational context with entities like courses, assignments, and exams
4. **Qualitative Research Domain**: Qualitative research context with entities like studies, participants, and interviews
5. **Quantitative Research Domain**: Quantitative research context with entities like datasets, variables, and analyses
## Usage
### Starting the Server
```bash
npm install
npm run build
npm start
```
### Command-Line Arguments
The Context Manager accepts the following command-line arguments:
```bash
# Run on a specific port (default: 3000)
npm start -- --port 3001
# Enable debug logging
npm start -- --debug
# Specify a config file
npm start -- --config ./my-config.json
# Run only specific domain servers
npm start -- --domains developer,project
```
### Domain Management
Use the `setActiveDomain` tool to select which domain you want to work with:
```
setActiveDomain(domain="developer")
```
### Session Management
Start a new session for the active domain:
```
startsession(domain="developer")
```
End a session when you're done:
```
endsession(sessionId="session_id_here", stage="completed", stageNumber=1, totalStages=1, nextStageNeeded=false)
```
### Context Operations
Build context for the active domain:
```
buildcontext(type="entities", data={...})
```
Load context for a specific entity:
```
loadcontext(entityName="MyProject", entityType="project")
```
Delete context:
```
deletecontext(type="entities", data={...})
```
### Cross-Domain Operations
Create relationships between entities in different domains:
```
relateCrossDomain(fromDomain="developer", fromEntity="ProjectX", toDomain="project", toEntity="ProjectX", relationType="manages")
```
## Troubleshooting
### Common Issues
1. **Path Resolution Errors**:
```
Error: Cannot find module '...'
```
Solution: Ensure all paths in the `domains` array in `main/index.ts` are correctly specified.
2. **Connection to Domain Server Failed**:
```
Error: Failed to connect to domain server: 'developer'
```
Solution: Check that the domain server is running and accessible.
3. **Method Not Found**:
```
Error: Method 'buildcontext' not found in domain 'developer'
```
Solution: Verify the method name and ensure it is supported by the domain server.
## Architecture
The Context Manager is a proxy that:
1. Receives MCP protocol messages from clients
2. Routes these messages to the appropriate domain server
3. Returns responses back to the client
Each domain server runs as a separate process, and the Context Manager communicates with them using the MCP protocol.
## Versioning
This package follows [Semantic Versioning](https://semver.org/):
- **MAJOR**: Incompatible API changes
- **MINOR**: Backwards-compatible functionality additions
- **PATCH**: Backwards-compatible bug fixes
Current version: 1.0.0
## Contributing
Contributions are welcome! Please follow these steps:
1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request
### Coding Standards
- Use TypeScript for all new code
- Follow the existing code style
- Add tests for new functionality
- Update documentation as needed
## Development
To extend the Context Manager with new domains or functionality:
1. Add the new domain to the `domains` array in `main/index.ts`
2. Specify the connection information for the domain server
3. Update tests and documentation
## License
MIT
```
--------------------------------------------------------------------------------
/project/README.md:
--------------------------------------------------------------------------------
```markdown
# 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
## 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:
1. **summary**: Records session summary, duration, and project focus
2. **achievements**: Documents key achievements from the session
3. **taskUpdates**: Tracks updates to existing tasks
4. **newTasks**: Records new tasks created during the session
5. **statusUpdates**: Records changes to entity status values
6. **projectStatus**: Updates overall project status, priority assignments, and sequential relationships
7. **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
```json
{
"mcpServers": {
"project": {
"command": "npx",
"args": [
"-y",
"github:tejpalvirk/project"
]
}
}
}
```
#### Install globally and run directly
First, install the package globally:
```bash
npm install -g github:tejpalvirk/project
```
Then configure Claude Desktop:
```json
{
"mcpServers": {
"project": {
"command": "contextmanager-project"
}
}
}
```
#### docker
```json
{
"mcpServers": {
"project": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"mcp/project"
]
}
}
}
```
## Building
### From Source
```bash
# 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.js
```
### Docker:
```bash
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:
```bash
# 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-project
```
```
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
```markdown
# MCP Context Manager
A collection of Model Context Protocol (MCP) servers to enhance AI models with persistent context across work sessions throughout the project lifecycle.
Context for each project is stored in a domain-specific knowledge graph handled by the domain's server. All domain servers can be managed through a central Context Manager that provides unified access.
Each domain server is also a standalone MCP Server that you can use on its own without the Context Manager.
## Features
- **Persistent Context**: Easily `buildcontext`, `loadcontext`, and `deletecontext` as you progress from idea to production/publication/completion
- **Efficienct Access**: Let AI models grab the exact context they need when they need it
- **Session Management**:
1. `startsession` tool to get an overview of what you've been working on in past sessions
2. `endsession` tool to analyze the entire session and update knowledge graph for future sessions
- **Cross-Domain Support**: Work with multiple knowledge domains through a single interface, including creating relationships between entities in different domains
## Why knowledge graphs?
To free up the context window (performance), and minimize token cost (efficiency).
## Available Servers
The contextmanager orchestrates several domain-specific MCP servers:
1. **Developer MCP Server**: software development context with entities like projects, components, and tasks. Includes status tracking (inactive, active, complete), priority management (high, low), and task sequencing through precedes relations.
2. **Project MCP Server**: project management context with entities like projects, tasks, and resources. Features status management (inactive, active, complete), priority assignment (high, low), and task sequencing capabilities.
3. **Student MCP Server**: educational context with entities like courses, assignments, and exams. Supports tracking status (active, completed, pending, abandoned), prioritizing assignments (high, low), and creating learning sequences.
4. **Qualitative Research MCP Server**: qualitative research context with entities like studies, participants, and interviews. Includes research activity status tracking (active, completed, pending, abandoned), priority management (high, low), and analysis sequencing.
5. **Quantitative Research MCP Server**: quantitative research context with entities like datasets, variables, and analyses. Features status management (active, completed, pending, abandoned), priority assignment (high, low), and sequential process management.
For detailed documentation on each domain server, see the README files in their respective directories:
- [Developer Server](./developer/README.md)
- [Project Server](./project/README.md)
- [Student Server](./student/README.md)
- [Qualitative Research Server](./qualitativeresearch/README.md)
- [Quantitative Research Server](./quantitativeresearch/README.md)
## Context Manager Benefits
The Context Manager provides:
- **Unified Interface**: Access all domain servers through a single interface.
- **Smart Routing**: Automatically routes requests to the appropriate domain server.
- **Cross-Domain Context**: Maintains references across different domains.
- **Consistent Status Management**: Standardized approach to status tracking across domains.
- **Unified Priority System**: Consistent priority management across different contexts.
- **Integrated Sequencing**: Harmonized approach to sequential workflows across domains.
## Implementation
The Context Manager uses the MCP Client SDK to communicate with domain-specific MCP servers. It:
1. Maintains a registry of domain servers with their connection information
2. Creates MCP clients to connect to each domain server
3. Routes requests to the appropriate domain server based on the active domain
4. Provides cross-domain functionality for relating entities across domains
5. Ensures consistent handling of status, priority, and sequential relations
## Path Resolution
The Context Manager uses absolute paths constructed at runtime to locate domain servers. If you need to modify paths to domain servers, update the `domains` array in `main/index.ts`.
## Installation & Usage
You can use the MCP Context Manager in several ways:
### Using npx (Recommended)
Run directly with npx:
```bash
npx github:tejpalvirk/contextmanager
```
### Global Installation
Install globally to make all servers available as commands:
```bash
npm install -g github:tejpalvirk/contextmanager
```
Then run:
```bash
mcp-server-contextmanager
```
Or run a specific domain server directly:
```bash
contextmanager-developer
contextmanager-project
contextmanager-student
contextmanager-qualitativeresearch
contextmanager-quantitativeresearch
```
### Clone and Build from Source
For development or customization:
```bash
git clone https://github.com/tejpalvirk/contextmanager.git
cd contextmanager
npm install
npm run build
```
Then run:
```bash
node main/index.js
```
## Command-Line Arguments
The Context Manager and domain servers accept the following command-line arguments:
```bash
# Run on a specific port (default: 3000)
npx github:tejpalvirk/contextmanager --port 3001
# Enable debug logging
npx github:tejpalvirk/contextmanager --debug
# Specify a config file
npx github:tejpalvirk/contextmanager --config ./my-config.json
# Run only specific domain servers
npx github:tejpalvirk/contextmanager --domains developer,project
```
## Environment Variables
Each domain 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: `<domain_directory>/memory.json`
- **SESSIONS_FILE_PATH**: Path where session data will be stored
- Can be absolute or relative (relative paths use current working directory)
- Default: `<domain_directory>/sessions.json`
Example usage:
```bash
# Store data in the current directory
MEMORY_FILE_PATH="./my-dev-memory.json" SESSIONS_FILE_PATH="./my-dev-sessions.json" npx github:tejpalvirk/contextmanager
# Store data in a specific location (absolute path)
MEMORY_FILE_PATH="/path/to/data/developer-memory.json" npx github:tejpalvirk/contextmanager
# Store data in user's home directory
MEMORY_FILE_PATH="$HOME/contextmanager/memory.json" npx github:tejpalvirk/contextmanager
```
## Interacting with Domain Servers
### Domain Management
Use the `setActiveDomain` tool to select which domain you want to work with:
```
setActiveDomain(domain="developer")
```
### Session Management
Start a new session for the active domain:
```
startsession(domain="developer")
```
End a session when you're done:
```
endsession(sessionId="session_id_here", stage="assembly", stageNumber=6, totalStages=6, nextStageNeeded=false)
```
### Context Operations
Build context for the active domain:
```
buildcontext(type="entities", data={...})
```
Load context for a specific entity:
```
loadcontext(entityName="MyProject", entityType="project")
```
Delete context:
```
deletecontext(type="entities", data={...})
```
### Entity Status and Priority Management
Assign status to entities:
```
buildcontext(type="relations", data=[
{ from: "LoginFeature", to: "active", relationType: "has_status" }
])
```
Set entity priorities:
```
buildcontext(type="relations", data=[
{ from: "BugFix", to: "high", relationType: "has_priority" }
])
```
Define sequential relationships:
```
buildcontext(type="relations", data=[
{ from: "DataModel", to: "UserInterface", relationType: "precedes" }
])
```
### Example: Working with the Developer Domain
```javascript
// Set the active domain to developer
setActiveDomain(domain="developer")
// Start a new session
startsession(domain="developer")
// Create a new project entity
buildcontext(type="entities", data={
"entityType": "project",
"name": "MyProject",
"description": "A sample project",
"language": "TypeScript",
"framework": "React"
})
// Load context for the project
loadcontext(entityName="MyProject", entityType="project")
// Create a component for the project and set its status to active
buildcontext(type="entities", data={
"entityType": "component",
"name": "AuthService",
"project": "MyProject",
"description": "Authentication service component",
"dependencies": ["UserService"]
})
buildcontext(type="relations", data=[
{ from: "AuthService", to: "active", relationType: "has_status" },
{ from: "AuthService", to: "high", relationType: "has_priority" }
])
```
### Cross-Domain Operations
Create relationships between entities in different domains:
```
relateCrossDomain(fromDomain="developer", fromEntity="ProjectX", toDomain="project", toEntity="ProjectX", relationType="manages")
```
### Example: Cross-Domain Integration
```javascript
// Create relationship between developer project and project management task
relateCrossDomain(
fromDomain="developer",
fromEntity="MyProject",
toDomain="project",
toEntity="ProjectX",
relationType="manages"
)
```
## Integration with Claude
In Claude Desktop, configure the Context Manager in settings:
```json
{
"mcpServers": {
"contextmanager": {
"command": "npx",
"args": [
"-y",
"github:tejpalvirk/contextmanager"
],
"options": {
"port": 3000,
"domains": ["developer", "project", "student"]
}
}
}
}
```
## Troubleshooting
### Common Issues
1. **Port Already in Use**:
```
Error: listen EADDRINUSE: address already in use :::3000
```
Solution: Use the `--port` option to specify a different port.
2. **Connection Refused**:
```
Error: connect ECONNREFUSED 127.0.0.1:3000
```
Solution: Ensure the server is running and accessible at the specified address.
3. **Domain Server Not Found**:
```
Error: Domain server 'developer' not found
```
Solution: Check that the domain name is correct and the server is registered in the Context Manager.
4. **Path Resolution Errors**:
```
Error: Cannot find module '...'
```
Solution: Ensure all paths in the `domains` array in `main/index.ts` are correctly specified.
5. **Method Not Found**:
```
Error: Method 'buildcontext' not found in domain 'developer'
```
Solution: Verify the method name and ensure it is supported by the domain server.
6. **Invalid Status or Priority Value**:
```
Error: Invalid status value 'in_progress'. Valid values are: inactive, active, complete
```
Solution: Ensure you're using the correct status values for the specific domain.
## Next Steps
- Replace JSON for YAML for 20-30% improvement in token efficiency
- Explore Knowledge Graphs in Markdown
## Versioning
This package follows [Semantic Versioning](https://semver.org/):
- **MAJOR**: Incompatible API changes
- **MINOR**: Backwards-compatible functionality additions
- **PATCH**: Backwards-compatible bug fixes
Current version: 1.0.0
## Contributing
Contributions are welcome! Please follow these steps:
1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request
### Coding Standards
- Use TypeScript for all new code
- Follow the existing code style
- Add tests for new functionality
- Update documentation as needed
## Development
### Prerequisites
- Node.js v16 or higher
- npm v7 or higher
### Building
```bash
npm install
npm run build
```
### Testing
```bash
npm test
```
## License
MIT
## Acknowledgments
This project builds on the Model Context Protocol created by Anthropic for Claude.
```
--------------------------------------------------------------------------------
/qualitativeresearch/README.md:
--------------------------------------------------------------------------------
```markdown
# Qualitative Researcher MCP Server
An MCP server implementation that provides tools for managing qualitative research knowledge graphs, enabling structured representation of research projects, participants, interviews, observations, codes, themes, and findings. This server helps qualitative researchers organize their data, track their analysis process, develop themes, and generate insights from rich textual data.
## Features
- **Persistent Research Context**: Maintain a structured knowledge graph of research entities and relationships across multiple analysis sessions
- **Study Session Management**: Track research analysis sessions with unique IDs and record progress over time
- **Thematic Analysis**: Organize and track emergent themes across data sources
- **Coding Framework**: Manage hierarchical coding structures and track code applications
- **Participant Management**: Track participant data, demographics, and contributions
- **Data Source Organization**: Organize interviews, observations, and documents
- **Research Question Tracking**: Link data to specific research questions
- **Memo Writing**: Document analytical insights throughout the research process
- **Chronological Data Analysis**: Explore data in temporal sequence
- **Code Co-occurrence Analysis**: Identify relationships between different codes
- **Methodology Documentation**: Track methodological decisions and approaches
## Entities
The Qualitative Researcher MCP Server recognizes the following entity types:
- **project**: Overall research study
- **participant**: Research subjects
- **interview**: Formal conversation with participants
- **observation**: Field notes from observational research
- **document**: External materials being analyzed
- **code**: Labels applied to data segments
- **codeGroup**: Categories or families of related codes
- **memo**: Researcher's analytical notes
- **theme**: Emergent patterns across data
- **quote**: Notable excerpts from data sources
- **literature**: Academic sources
- **researchQuestion**: Formal questions guiding the study
- **finding**: Results or conclusions
- **status**: Entity status values (active, completed, pending, abandoned)
- **priority**: Priority level values (high, low)
## Relationships
Entities can be connected through the following relationship types:
- **participated_in**: Links participants to interviews/observations
- **codes**: Shows which codes apply to which data
- **contains**: Hierarchical relationship (e.g., codegroup contains codes)
- **supports**: Data supporting a theme or finding
- **contradicts**: Data contradicting a theme or finding
- **answers**: Data addressing a research question
- **cites**: References to literature
- **followed_by**: Temporal sequence
- **related_to**: General connection
- **reflects_on**: Memo reflecting on data/code/theme
- **compares**: Comparative relationship
- **conducted_by**: Person who conducted data collection
- **transcribed_by**: Person who transcribed data
- **part_of**: Entity is part of another entity
- **derived_from**: Entity is derived from another entity
- **collected_on**: Data collection date
- **analyzes**: Analysis relationship
- **triangulates_with**: Triangulation between data sources
- **has_status**: Links entities to their current status (active, completed, pending, abandoned)
- **has_priority**: Links entities to their priority level (high, low)
- **precedes**: Indicates that one analysis activity comes before another in a sequence
## Available Tools
The Qualitative Researcher MCP Server provides these tools for interacting with research knowledge:
### startsession
Starts a new qualitative research session, generating a unique session ID and displaying current research projects, recent data collection, emergent themes, and previous sessions. Shows status information via has_status relations, priority levels via has_priority relations, and identifies research activities ready to be worked on next based on sequential process relationships.
### loadcontext
Loads detailed context for a specific entity (project, participant, interview, etc.), displaying relevant information based on entity type. Includes status information, priority levels, and sequential process relationships.
### endsession
Records the results of a research session through a structured, multi-stage process:
1. **summary**: Records session summary, duration, and project focus
2. **interviewData**: Documents new interview data processed during the session
3. **memos**: Records analytical memos created during the session
4. **codingActivity**: Tracks new and revised codes applied to data
5. **themes**: Documents emergent or developed themes from analysis
6. **statusUpdates**: Records changes to entity status values
7. **projectStatus**: Updates overall project status, priority assignments, and sequential relationships
8. **assembly**: Final assembly of all session data
### buildcontext
Creates new entities, relations, or observations in the knowledge graph:
- **entities**: Add new research entities (projects, participants, interviews, 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 research 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 (active, completed, pending, abandoned)
- **priority**: Find entities with a specific priority value (high, low)
- **sequence**: Identify sequential relationships for analysis activities
## Domain-Specific Functions
The Qualitative Researcher MCP Server includes specialized domain functions for qualitative research:
- **getProjectOverview**: Comprehensive view of a project including research questions, methodology, participants, data sources
- **getParticipantProfile**: Detailed profile of a participant including demographics, interviews, and quotes
- **getThematicAnalysis**: Analysis of themes with supporting codes and data
- **getCodedData**: View all data segments tagged with a specific code
- **getResearchQuestionAnalysis**: Organize data by research questions with related findings
- **getChronologicalData**: View data in temporal sequence
- **getCodeCooccurrence**: Analyze where multiple codes appear together
- **getMemosByFocus**: Retrieve all memos related to a specific entity
- **getMethodologyDetails**: Review methodological approach, sampling, and analysis techniques
- **getRelatedEntities**: Find entities related to a specific entity by relationship type
- **getStatusOverview**: View all entities with a specific status (active, completed, pending, abandoned)
- **getPriorityItems**: Identify high-priority research tasks and activities
- **getAnalysisSequence**: Visualize the sequence of analysis activities based on precedes relations
## Example Prompts
### Starting a Session
```
Let's start a new qualitative research session for my Health Behavior Study project.
```
### Loading Research Context
```
Load the context for the Health Behavior Study project so I can see the current state of my analysis.
```
### Recording Session Results
```
I've just finished analyzing interview data for my Health Behavior Study. I identified two new themes related to social support, coded three new interviews, and wrote memos about emerging patterns in participant responses. I've marked the initial coding phase as complete and set the thematic analysis as high priority. The project is progressing well, and I'm beginning to reach theoretical saturation.
```
### Managing Research Knowledge
```
Create a new code called "Family Support" that's part of the "Social Support" code group in the Health Behavior Study project. Set its status to active and make it precede the "Social Network Analysis" activity.
```
```
Update the status of the "Participant Recruitment" process to "completed" and add an observation that we've reached our target sample size.
```
## Usage
This MCP server enables qualitative researchers to:
- **Maintain Analytical Continuity**: Keep track of analysis progress across multiple research sessions
- **Develop Coding Frameworks**: Build, refine, and apply coding structures to qualitative data
- **Track Thematic Development**: Observe how themes emerge and evolve during analysis
- **Manage Rich Data Sources**: Organize and connect interview transcripts, field notes, and documents
- **Support Theoretical Development**: Document theoretical insights through the memo writing process
- **Prepare Research Findings**: Connect findings to supporting evidence and research questions
- **Enhance Methodological Rigor**: Document methodological decisions and analysis process
- **Track Research Progress**: Monitor entity status throughout the research lifecycle
- **Prioritize Research Tasks**: Identify and focus on high-priority research activities
- **Sequence Analysis Activities**: Plan and visualize the logical order of research and analytical steps
## Configuration
### Usage with Claude Desktop
Add this to your `claude_desktop_config.json`:
#### Install from GitHub and run with npx
```json
{
"mcpServers": {
"qualitativeresearch": {
"command": "npx",
"args": [
"-y",
"github:tejpalvirk/qualitativeresearch"
]
}
}
}
```
#### Install globally and run directly
First, install the package globally:
```bash
npm install -g github:tejpalvirk/qualitativeresearch
```
Then configure Claude Desktop:
```json
{
"mcpServers": {
"qualitativeresearch": {
"command": "contextmanager-qualitativeresearch"
}
}
}
```
#### docker
```json
{
"mcpServers": {
"qualitativeresearch": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"mcp/qualitativeresearch"
]
}
}
}
```
## Building
### From Source
```bash
# 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 qualitativeresearch
node qualitativeresearch_index.js
```
### Docker:
```bash
docker build -t mcp/qualitativeresearch -f qualitativeresearch/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 Qualitative Research 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: `./qualitativeresearch/memory.json`
- **SESSIONS_FILE_PATH**: Path where session data will be stored
- Can be absolute or relative (relative paths use current working directory)
- Default: `./qualitativeresearch/sessions.json`
Example usage:
```bash
# Store data in the current directory
MEMORY_FILE_PATH="./qualitative-memory.json" SESSIONS_FILE_PATH="./qualitative-sessions.json" npx github:tejpalvirk/contextmanager-qualitativeresearch
# Store data in a specific location (absolute path)
MEMORY_FILE_PATH="/path/to/data/qualitative-memory.json" npx github:tejpalvirk/contextmanager-qualitativeresearch
# Store data in user's home directory
MEMORY_FILE_PATH="$HOME/contextmanager/qualitative-memory.json" npx github:tejpalvirk/contextmanager-qualitativeresearch
```
```
--------------------------------------------------------------------------------
/developer/README.md:
--------------------------------------------------------------------------------
```markdown
# Developer MCP Server
A powerful context management system designed specifically for software development teams. The Developer MCP Server maintains persistent context across your coding sessions, ensuring you never lose track of your project's structure, dependencies, and progress.
## Features
- **Persistent Development Context**: Pick up exactly where you left off in your last session, with complete context about the components, issues, and tasks you were working on.
- **Session Management**: Start new development sessions and record your achievements, task updates, and project status changes when you finish, creating a persistent record of your development activities.
- **Dependency Tracking**: Understand how components, features, and technologies relate to each other with a comprehensive dependency model.
- **Project Status Insights**: Get immediate visibility into project progress, including status of components, features, issues, and milestones.
- **Component Context Retrieval**: Understand any component's purpose, implementation details, dependencies, and related issues at a glance.
- **Decision History**: Track why architectural and implementation decisions were made, when, and by whom—no more guessing why something was built a certain way.
- **Milestone Progress Tracking**: Monitor progress toward project milestones and identify potential bottlenecks before they derail your timeline.
- **Related Entity Discovery**: Quickly find all related entities for any component, feature, or task to understand its complete context.
## Entities
The Developer MCP Server recognizes the following types of entities in your software development context:
- **Project**: Overall software project or product
- **Component**: Module, service, package, or logical unit within a project
- **Feature**: Specific functionality being developed
- **Issue**: Bug, problem, or defect to be addressed
- **Task**: Work item or activity needed for development
- **Developer**: Team member working on the project
- **Technology**: Programming language, framework, library, or tool
- **Decision**: Important technical or architectural decision
- **Milestone**: Key project deadline or phase
- **Environment**: Development, staging, or production environment
- **Documentation**: Project documentation resource
- **Requirement**: Project requirement or specification
- **Status**: Entity status values (inactive, active, complete)
- **Priority**: Priority level values (high, low)
## Relationships
The Developer MCP Server models the following relationships between entities, mirroring real-world software development dynamics:
- **depends_on**: Entity A requires Entity B to function
- **implements**: Component implements a feature
- **assigned_to**: Task is assigned to a developer
- **blocked_by**: Task is blocked by an issue
- **uses**: Component uses a technology
- **part_of**: Component is part of a project
- **contains**: Project contains a component
- **works_on**: Developer works on a project/component
- **related_to**: General relationship between entities
- **affects**: Issue affects a component
- **resolves**: Task resolves an issue
- **created_by**: Entity was created by a developer
- **documented_in**: Component is documented in documentation
- **decided_in**: Decision was made in a meeting
- **required_by**: Feature is required by a requirement
- **has_status**: Links entities to their current status (inactive, active, complete)
- **has_priority**: Links entities to their priority level (high, low)
- **depends_on_milestone**: Task depends on reaching a milestone
- **precedes**: Indicates that one task comes before another in a sequence
- **reviews**: Developer reviews a component
- **tested_in**: Component is tested in an environment
## Status and Priority Management
The Developer MCP Server provides robust status and priority tracking capabilities:
- **Status Values**:
- **inactive**: Entity has not yet been started or is currently paused
- **active**: Entity is currently being worked on
- **complete**: Entity has been finished
- **Priority Values**:
- **high**: Entity requires immediate attention or has significant impact
- **low**: Entity can be addressed when higher priority items are complete
- **Sequential Task Management**:
- Define which tasks must be completed before others can begin
- Visualize the natural workflow of development tasks
- Identify critical path dependencies in your development process
## Environment Variables
The Developer MCP Server supports the following environment variables to customize where data is stored:
- **MEMORY_FILE_PATH**: Path where the knowledge graph data will be stored
- Can be absolute or relative (relative paths use current working directory)
- Default: `./developer/memory.json`
- **SESSIONS_FILE_PATH**: Path where session data will be stored
- Can be absolute or relative (relative paths use current working directory)
- Default: `./developer/sessions.json`
Example usage:
```bash
# Store data in the current directory
MEMORY_FILE_PATH="./dev-memory.json" SESSIONS_FILE_PATH="./dev-sessions.json" npx github:tejpalvirk/contextmanager-developer
# Store data in a specific location (absolute path)
MEMORY_FILE_PATH="/path/to/data/developer-memory.json" npx github:tejpalvirk/contextmanager-developer
# Store data in user's home directory
MEMORY_FILE_PATH="$HOME/contextmanager/developer-memory.json" npx github:tejpalvirk/contextmanager-developer
```
## Available Tools
The Developer MCP Server provides the following tools:
- **startsession**: Starts a new development session and provides information about recent sessions, active projects, high-priority tasks, and upcoming milestones. Shows status and priority information for tasks and other entities, as well as identifies tasks ready to be worked on based on sequential dependencies.
- **loadcontext**: Loads detailed context for an entity (project, component, feature, task, etc.) and tracks this context loading as part of the current session. Shows status values (inactive, active, complete), priority levels (high, low), and sequential relationships.
- **endsession**: Performs a structured analysis of the development session through multiple stages (summary, achievements, task updates, new tasks, status updates, project status) and records this information in the persistent knowledge graph.
- **buildcontext**: Creates new entities, relations (including has_status, has_priority, and precedes), or observations in the knowledge graph.
- **deletecontext**: Removes entities, relations (including status, priority, and sequential relations), or observations from the knowledge graph.
- **advancedcontext**: Retrieves information from the knowledge graph with different query types (graph, search, nodes, related, decisions, milestone, status, priority, sequence).
## Prompts
Here are some example prompts to use with the Developer MCP Server:
### Starting a Session
```
"Start a new development session for me."
```
### Loading Context
```
"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."
"Show me all tasks with high priority status in the Authentication module."
"What tasks need to be completed before we can start implementing the checkout flow?"
```
### Recording Session Progress
```
"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. Set MFA as high priority and make it precede the social login task."
```
### Knowledge Graph Management
```
"Create a new feature called 'BillingSystem' in the ProjectX project with status active and high priority."
"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?"
"Update the status of the API Documentation task to complete."
"Set the User Profile feature as a prerequisite for the Payment Processing feature."
```
## Usage
The Developer MCP Server excels in scenarios like:
### Context Continuity
```
"Let me see the component I was working on yesterday and all its dependencies."
```
The server retrieves your most recently accessed components along with their dependencies, issues, and related tasks, allowing you to instantly resume work without spending time reconstructing context.
### Onboarding New Team Members
```
"Give me an overview of Project X's architecture and component structure."
```
New developers can quickly understand the project structure, key components, and their relationships—dramatically reducing the time needed to become productive on a new codebase.
### Session Recording
```
"End my development session and record what I accomplished."
```
The server guides you through a structured process to document your achievements, task updates, and project status changes, preserving this context for future sessions and team members.
### Architectural Decision Context
```
"Why was GraphQL chosen over REST for the API layer?"
```
The server retrieves the decision entity along with related meetings, developers involved, and the context in which the decision was made—preserving organizational knowledge that would otherwise be lost.
### Dependency Analysis
```
"What would be affected if we modify the authentication service?"
```
Before making changes, developers can understand all components, features, and tasks that depend on a particular component, reducing the risk of unexpected breakages.
### Project Progress Tracking
```
"What's our progress toward the Q2 release milestone?"
```
Project leads can instantly see the status of all tasks and features associated with a milestone, identifying at-risk items before they jeopardize the timeline.
### Status and Priority Management
```
"Show me all high-priority tasks that are still active."
```
Quickly identify the most important work that needs attention, ensuring that critical tasks are addressed first.
### Task Sequencing
```
"What tasks are blocked because they depend on incomplete prerequisite tasks?"
```
Identify and resolve bottlenecks in the development process by understanding the sequential dependencies between tasks.
## Configuration
### Usage with Claude Desktop
Add this to your `claude_desktop_config.json`:
#### Install from GitHub and run with npx
```json
{
"mcpServers": {
"developer": {
"command": "npx",
"args": [
"-y",
"github:tejpalvirk/developer"
]
}
}
}
```
#### Install globally and run directly
First, install the package globally:
```bash
npm install -g github:tejpalvirk/contextmanager/developer
```
Then configure Claude Desktop:
```json
{
"mcpServers": {
"developer": {
"command": "contextmanager-developer"
}
}
}
```
#### docker
```json
{
"mcpServers": {
"developer": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"mcp/developer"
]
}
}
}
```
## Building
### From Source
```bash
# 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.js
```
### Docker:
```bash
docker build -t mcp/developer -f developer/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.
```
--------------------------------------------------------------------------------
/student/README.md:
--------------------------------------------------------------------------------
```markdown
# Student MCP Server
An MCP server implementation that provides tools for managing student knowledge graphs, enabling structured representation of courses, assignments, exams, concepts, and study resources. This server helps students track their academic progress, manage deadlines, and optimize their learning journey.
## Features
- **Persistent Educational Context**: Maintain a structured knowledge graph of educational entities and relationships across multiple sessions
- **Study Session Management**: Track study sessions with unique IDs and record progress over time
- **Course Management**: Organize courses, lectures, assignments, and exams in a structured format
- **Concept Mapping**: Connect learning concepts to show relationships and prerequisites
- **Assignment Tracking**: Monitor assignment status, due dates, and related resources
- **Exam Preparation**: Track exam dates and organize study materials
- **Deadline Management**: Keep track of upcoming due dates for assignments and exams
- **Resource Organization**: Connect learning resources to specific courses and concepts
- **Progress Monitoring**: Track completion status of courses, assignments, and exams
- **Knowledge Connections**: Visualize relationships between different educational concepts
## Entities
The Student MCP Server recognizes the following entity types:
- **course**: Academic courses being taken
- **assignment**: Homework, projects, and other submitted work
- **exam**: Tests, quizzes, and other assessments
- **concept**: Knowledge topics and learning objectives
- **resource**: Textbooks, articles, videos, and other learning materials
- **note**: Personal study notes and observations
- **lecture**: Individual class sessions
- **project**: Larger educational projects or undertakings
- **question**: Specific questions for study or review
- **term**: Academic terms or semesters
- **goal**: Learning objectives and targets
- **professor**: Course instructors and teachers
- **status**: Entity status values (active, completed, pending, abandoned)
- **priority**: Priority level values (high, low)
## Relationships
Entities can be connected through the following relationship types:
- **enrolled_in**: Student is taking a course
- **assigned_in**: Assignment is part of a course
- **due_on**: Assignment/exam has specific due date
- **covers**: Lecture/resource covers concept
- **references**: Note references concept
- **prerequisite_for**: Concept is foundation for another
- **taught_by**: Course taught by professor
- **scheduled_for**: Lecture/exam scheduled for specific time
- **contains**: Course contains lectures/assignments
- **requires**: Assignment requires specific concepts
- **related_to**: Concept related to another concept
- **created_for**: Note created for specific lecture
- **studies**: Study session focuses on concept/exam
- **helps_with**: Resource helps with assignment/concept
- **submitted**: Assignment submitted on date
- **part_of**: Entity is part of another entity
- **included_in**: Included in a larger component
- **follows**: Entity follows another in sequence
- **attends**: Student attends lecture
- **graded_with**: Assignment/exam graded with specific criteria
- **has_status**: Links entities to their current status (active, completed, pending, abandoned)
- **has_priority**: Links entities to their priority level (high, low)
- **precedes**: Indicates that one task or assignment comes before another in a sequence
## Status and Priority Management
The Student MCP Server provides comprehensive status and priority tracking capabilities:
- **Status Values**:
- **active**: Currently being worked on or studied
- **completed**: Finished or successfully submitted
- **pending**: Not yet started but planned
- **abandoned**: No longer being pursued
- **Priority Values**:
- **high**: Requires immediate attention or has significant impact on grades
- **low**: Can be addressed after higher priority items are complete
- **Sequential Learning Management**:
- Define which assignments or concepts must be completed before others
- Organize study activities in a logical progression
- Create dependencies between related learning tasks
- Build structured learning paths through course material
## Available Tools
The Student MCP Server provides these tools for interacting with educational knowledge:
### startsession
Starts a new study session, generating a unique session ID and displaying current courses, upcoming deadlines, recently studied concepts, and past study sessions. Shows status information via has_status relations, priority levels via has_priority relations, and identifies assignments ready to be worked on next based on sequential dependencies.
### loadcontext
Loads detailed context for a specific entity (course, assignment, etc.), displaying relevant information based on entity type. Includes status information, priority levels, and sequential relationships between related entities.
### endsession
Records the results of a study session through a structured, multi-stage process:
1. **summary**: Records session summary, duration, and course focus
2. **conceptsLearned**: Documents concepts studied during the session
3. **assignmentUpdates**: Tracks updates to assignments
4. **statusUpdates**: Records changes to entity status values
5. **courseStatus**: Updates overall course status, priority assignments, and sequential relationships
6. **newConcepts**: Records new concepts learned during the session
7. **assembly**: Final assembly of all session data
### buildcontext
Creates new entities, relations, or observations in the knowledge graph:
- **entities**: Add new educational entities (courses, assignments, concepts, 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 educational 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
- **course**: Get details about a specific course
- **deadlines**: Get upcoming deadlines
- **assignment**: Get details about a specific assignment
- **exam**: Get details about a specific exam
- **concepts**: Get information about concepts
- **lecture**: Get information about lectures
- **term**: Get details about an academic term
- **status**: Find entities with a specific status value
- **priority**: Find entities with a specific priority value
- **sequence**: Identify sequential relationships for learning activities
## Domain-Specific Functions
The Student MCP Server includes specialized domain functions for education:
- **getCourseOverview**: Comprehensive view of a course including lectures, assignments, exams, and resources
- **getUpcomingDeadlines**: Find assignments and exams with approaching due dates
- **getAssignmentStatus**: Get detailed status of assignments, including progress and related concepts
- **getExamPrep**: Get exam preparation materials and related concepts
- **findRelatedConcepts**: Discover connections between different educational concepts
- **getStudyProgress**: Track study progress across courses
- **getTermOverview**: Get overview of courses and work for an academic term
- **getConceptMastery**: Assess level of understanding for specific concepts
- **getStatusOverview**: View all entities with a specific status (active, completed, pending, abandoned)
- **getPriorityItems**: Identify high-priority assignments and study tasks
- **getLearningSequence**: Visualize the sequence of learning activities based on precedes relations
## Example Prompts
### Starting a Session
```
Let's start a new study session for my Computer Science course.
```
### Loading Course Context
```
Load the context for my Calculus 101 course so I can see upcoming assignments and exams.
```
### Recording Study Progress
```
I've just finished studying for 2 hours on Calculus 101. I focused on limits and derivatives, completed my homework assignment on basic differentiation, and took notes on the chain rule. I've marked the limits content as completed and set the derivatives practice as high priority. I'm feeling more confident about the upcoming exam next week.
```
### Managing Learning Materials
```
Create a new concept called "Binary Trees" related to my Data Structures course with the description "A binary tree is a tree data structure in which each node has at most two children." Set its status to active and make it precede the "Graph Algorithms" concept.
```
```
Update the status of my "Database Assignment" to "completed" and add that I successfully implemented all required queries. Mark the "Advanced SQL" concept as high priority for my next study session.
```
## Usage
This MCP server enables students to:
- **Maintain Study Continuity**: Keep track of what you've learned across multiple study sessions
- **Optimize Learning Time**: Focus on high-priority assignments and concepts
- **Track Academic Progress**: Monitor completion of courses, assignments, and mastery of concepts
- **Prepare for Exams**: Organize study materials and track progress towards exam readiness
- **Manage Deadlines**: Stay on top of upcoming due dates for assignments and exams
- **Connect Knowledge**: See relationships between different concepts across courses
- **Prioritize Work**: Focus on high-priority assignments and learning tasks
- **Structure Learning**: Create logical sequences for learning related concepts
- **Track Status**: Monitor the status of assignments, projects, and learning activities
## Configuration
### Usage with Claude Desktop
Add this to your `claude_desktop_config.json`:
#### Install from GitHub and run with npx
```json
{
"mcpServers": {
"student": {
"command": "npx",
"args": [
"-y",
"github:tejpalvirk/student"
]
}
}
}
```
#### Install globally and run directly
First, install the package globally:
```bash
npm install -g github:tejpalvirk/student
```
Then configure Claude Desktop:
```json
{
"mcpServers": {
"student": {
"command": "contextmanager-student"
}
}
}
```
#### docker
```json
{
"mcpServers": {
"student": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"mcp/student"
]
}
}
}
```
## Building
### From Source
```bash
# 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 student
node student_index.js
```
### Docker:
```bash
docker build -t mcp/student -f student/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 Student 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: `./student/memory.json`
- **SESSIONS_FILE_PATH**: Path where session data will be stored
- Can be absolute or relative (relative paths use current working directory)
- Default: `./student/sessions.json`
Example usage:
```bash
# Store data in the current directory
MEMORY_FILE_PATH="./student-memory.json" SESSIONS_FILE_PATH="./student-sessions.json" npx github:tejpalvirk/contextmanager-student
# Store data in a specific location (absolute path)
MEMORY_FILE_PATH="/path/to/data/student-memory.json" npx github:tejpalvirk/contextmanager-student
# Store data in user's home directory
MEMORY_FILE_PATH="$HOME/contextmanager/student-memory.json" npx github:tejpalvirk/contextmanager-student
```
```
--------------------------------------------------------------------------------
/quantitativeresearch/README.md:
--------------------------------------------------------------------------------
```markdown
# Quantitative Researcher MCP Server
An MCP server implementation that provides tools for managing quantitative research knowledge graphs, enabling structured representation of research projects, datasets, variables, hypotheses, statistical tests, models, and results. This server helps quantitative researchers organize their data, track their analyses, evaluate hypotheses, and generate insights from numerical data.
## Features
- **Persistent Research Context**: Maintain a structured knowledge graph of research entities and relationships across multiple analysis sessions
- **Study Session Management**: Track research analysis sessions with unique IDs and record progress over time
- **Hypothesis Testing**: Track hypotheses, their associated tests, and resulting conclusions
- **Dataset Management**: Organize and track descriptive statistics and variables within datasets
- **Statistical Analysis**: Record statistical tests, models, and their results
- **Variable Relationships**: Track correlations, predictions, and other relationships between variables
- **Research Question Tracking**: Link data analyses to specific research questions
- **Data Visualization**: Document visualizations created from datasets and results
- **Model Performance**: Monitor statistical model performance metrics
- **Research Finding Documentation**: Link findings to supporting statistical evidence
- **Research Methodology Documentation**: Track methodological decisions and approaches
## Entities
The Quantitative Researcher MCP Server recognizes the following entity types:
- **project**: Overall research study
- **dataset**: Collection of data used for analysis
- **variable**: Specific measurable attribute in a dataset
- **hypothesis**: Formal testable statement
- **statisticalTest**: Analysis method applied to data
- **result**: Outcome of statistical analysis
- **analysisScript**: Code used to perform analysis
- **visualization**: Visual representation of data
- **model**: Statistical/mathematical model
- **literature**: Academic sources
- **researchQuestion**: Formal questions guiding the study
- **finding**: Results or conclusions
- **participant**: Research subjects
- **status**: Entity status values (active, completed, pending, abandoned)
- **priority**: Priority level values (high, low)
## Relationships
Entities can be connected through the following relationship types:
- **correlates_with**: Statistical correlation between variables
- **predicts**: Predictive relationship from independent to dependent variable
- **tests**: Statistical test examines hypothesis
- **analyzes**: Analysis performed on dataset
- **produces**: Analysis produces result
- **visualizes**: Visualization displays data or result
- **contains**: Hierarchical relationship
- **part_of**: Entity is part of another entity
- **depends_on**: Dependency relationship
- **supports**: Evidence supporting a hypothesis or finding
- **contradicts**: Evidence contradicting a hypothesis or finding
- **derived_from**: Entity is derived from another entity
- **controls_for**: Variable/method controls for confounds
- **moderates**: Variable moderates a relationship
- **mediates**: Variable mediates a relationship
- **implements**: Script implements statistical test/model
- **compares**: Statistical comparison between groups/variables
- **includes**: Model includes variables
- **validates**: Validates a model or result
- **cites**: References literature
- **has_status**: Links entities to their current status (active, completed, pending, abandoned)
- **has_priority**: Links entities to their priority level (high, low)
- **precedes**: Indicates that one process or activity comes before another in a sequence
## Available Tools
The Quantitative Researcher MCP Server provides these tools for interacting with research knowledge:
### startsession
Starts a new quantitative research session, generating a unique session ID and displaying current research projects, datasets, models, visualizations, and previous sessions. Shows status information via has_status relations, priority levels via has_priority relations, and identifies activities ready to be worked on next based on sequential process relationships.
### loadcontext
Loads detailed context for a specific entity (project, dataset, variable, etc.), displaying relevant information based on entity type. Includes status information, priority levels, and sequential process relationships.
### endsession
Records the results of a research session through a structured, multi-stage process:
1. **summary**: Records session summary, duration, and project focus
2. **datasetUpdates**: Documents updates to datasets during the session
3. **newAnalyses**: Records new statistical analyses performed
4. **newVisualizations**: Tracks new data visualizations created
5. **hypothesisResults**: Documents results of hypothesis testing
6. **modelUpdates**: Records updates to statistical models
7. **statusUpdates**: Records changes to entity status values
8. **projectStatus**: Updates overall project status, priority assignments, and sequential relationships
9. **assembly**: Final assembly of all session data
### buildcontext
Creates new entities, relations, or observations in the knowledge graph:
- **entities**: Add new research entities (projects, datasets, variables, 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 research 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 (active, completed, pending, abandoned)
- **priority**: Find entities with a specific priority value (high, low)
- **sequence**: Identify sequential relationships for research processes
## Domain-Specific Functions
The Quantitative Researcher MCP Server includes specialized domain functions for quantitative research:
- **getProjectOverview**: Comprehensive view of a project including research questions, methodology, datasets, variables
- **getDatasetAnalysis**: Analysis of dataset contents including variables, descriptive statistics, and data quality
- **getHypothesisTests**: Review of hypothesis tests and their outcomes
- **getVariableRelationships**: Examine correlations, predictions, and other relationships between variables
- **getStatisticalResults**: Summarize the results of statistical analyses
- **getVisualizationGallery**: View visualizations created for datasets and results
- **getModelPerformance**: Assess performance metrics for statistical models
- **getResearchQuestionResults**: Organize analyses and results by research questions
- **getVariableDistribution**: Examine the distribution and properties of individual variables
- **getStatusOverview**: View all entities with a specific status (active, completed, pending, abandoned)
- **getPriorityItems**: Identify high-priority research tasks and activities
- **getResearchSequence**: Visualize the sequence of research processes based on precedes relations
## Example Prompts
### Starting a Session
```
Let's start a new quantitative research session for my Climate Impact Study project.
```
### Loading Research Context
```
Load the context for the Climate Impact Study project so I can see the current state of my statistical analyses.
```
### Recording Session Results
```
I've just finished analyzing data for my Climate Impact Study. I ran three new regression models to test the relationship between temperature and crop yield, created two visualizations of the correlation patterns, and confirmed our hypothesis about rainfall effects. I've marked the temperature analysis as complete and assigned high priority to the regional variation analysis. The model performance improved by 15% after controlling for regional variations.
```
### Managing Research Knowledge
```
Create a new variable called "Annual Precipitation" that's part of the "Climate Measures" dataset with observations noting it's normally distributed with a mean of 34.5 inches. Set its status to active and make it precede the "Crop Yield Analysis" process.
```
```
Update the status of the "Data Cleaning" process to "completed" and add an observation that all outliers have been properly handled.
```
## Usage
This MCP server enables quantitative researchers to:
- **Maintain Analytical Continuity**: Track analyses and results across multiple research sessions
- **Organize Statistical Evidence**: Link hypotheses to supporting statistical tests and results
- **Document Variable Relationships**: Record how variables correlate, predict, or influence each other
- **Track Model Development**: Document the evolution of statistical models and their performance
- **Support Result Interpretation**: Connect statistical findings to research questions and theoretical frameworks
- **Ensure Methodological Rigor**: Document methodological decisions and analytical approaches
- **Prepare Research Reports**: Organize statistical evidence to support research findings
- **Track Research Progress**: Monitor entity status throughout the research lifecycle
- **Prioritize Research Tasks**: Identify and focus on high-priority research activities
- **Sequence Research Processes**: Plan and visualize the logical order of research and analytical steps
## Configuration
### Usage with Claude Desktop
Add this to your `claude_desktop_config.json`:
#### Install from GitHub and run with npx
```json
{
"mcpServers": {
"quantitativeresearch": {
"command": "npx",
"args": [
"-y",
"github:tejpalvirk/quantitativeresearch"
]
}
}
}
```
#### Install globally and run directly
First, install the package globally:
```bash
npm install -g github:tejpalvirk/quantitativeresearch
```
Then configure Claude Desktop:
```json
{
"mcpServers": {
"quantitativeresearch": {
"command": "contextmanager-quantitativeresearch"
}
}
}
```
#### docker
```json
{
"mcpServers": {
"quantitativeresearch": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"mcp/quantitativeresearch"
]
}
}
}
```
## Building
### From Source
```bash
# 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 quantitativeresearch
node quantitativeresearch_index.js
```
### Docker:
```bash
docker build -t mcp/quantitativeresearch -f quantitativeresearch/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 Quantitative Research 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: `./quantitativeresearch/memory.json`
- **SESSIONS_FILE_PATH**: Path where session data will be stored
- Can be absolute or relative (relative paths use current working directory)
- Default: `./quantitativeresearch/sessions.json`
Example usage:
```bash
# Store data in the current directory
MEMORY_FILE_PATH="./quantitative-memory.json" SESSIONS_FILE_PATH="./quantitative-sessions.json" npx github:tejpalvirk/contextmanager-quantitativeresearch
# Store data in a specific location (absolute path)
MEMORY_FILE_PATH="/path/to/data/quantitative-memory.json" npx github:tejpalvirk/contextmanager-quantitativeresearch
# Store data in user's home directory
MEMORY_FILE_PATH="$HOME/contextmanager/quantitative-memory.json" npx github:tejpalvirk/contextmanager-quantitativeresearch
```
```
--------------------------------------------------------------------------------
/developer/tsconfig.json:
--------------------------------------------------------------------------------
```json
{
"compilerOptions": {
"target": "es2020",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"esModuleInterop": true,
"strict": true,
"outDir": "./",
"declaration": true,
"skipLibCheck": true
},
"include": ["./**/*.ts"],
"exclude": []
}
```
--------------------------------------------------------------------------------
/project/tsconfig.json:
--------------------------------------------------------------------------------
```json
{
"compilerOptions": {
"target": "es2020",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"esModuleInterop": true,
"strict": true,
"outDir": "./",
"declaration": true,
"skipLibCheck": true
},
"include": ["./**/*.ts"],
"exclude": []
}
```
--------------------------------------------------------------------------------
/qualitativeresearch/tsconfig.json:
--------------------------------------------------------------------------------
```json
{
"compilerOptions": {
"target": "es2020",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"esModuleInterop": true,
"strict": true,
"outDir": "./",
"declaration": true,
"skipLibCheck": true
},
"include": ["./**/*.ts"],
"exclude": []
}
```
--------------------------------------------------------------------------------
/quantitativeresearch/tsconfig.json:
--------------------------------------------------------------------------------
```json
{
"compilerOptions": {
"target": "es2020",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"esModuleInterop": true,
"strict": true,
"outDir": "./",
"declaration": true,
"skipLibCheck": true
},
"include": ["./**/*.ts"],
"exclude": []
}
```
--------------------------------------------------------------------------------
/student/tsconfig.json:
--------------------------------------------------------------------------------
```json
{
"compilerOptions": {
"target": "es2020",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"esModuleInterop": true,
"strict": true,
"outDir": "./",
"declaration": true,
"skipLibCheck": true
},
"include": ["./**/*.ts"],
"exclude": []
}
```
--------------------------------------------------------------------------------
/main/tsconfig.json:
--------------------------------------------------------------------------------
```json
{
"compilerOptions": {
"target": "es2020",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"esModuleInterop": true,
"strict": true,
"outDir": "../dist/main",
"declaration": true,
"skipLibCheck": true
},
"include": ["./**/*.ts"],
"exclude": ["node_modules", "dist"]
}
```
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
```json
{
"compilerOptions": {
"target": "es2020",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"esModuleInterop": true,
"strict": true,
"outDir": "./dist",
"declaration": true,
"skipLibCheck": true
},
"include": ["main/**/*.ts", "developer/**/*.ts", "student/**/*.ts", "qualitativeresearch/**/*.ts", "quantitativeresearch/**/*.ts", "project/**/*.ts"],
"exclude": ["node_modules", "dist", "tests", "backup", "backup_built"]
}
```
--------------------------------------------------------------------------------
/project/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
FROM node:22.12-alpine AS builder
COPY project /app
COPY tsconfig.json /tsconfig.json
WORKDIR /app
RUN --mount=type=cache,target=/root/.npm npm install
RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
FROM node:22-alpine AS release
COPY --from=builder /app/dist /app/dist
COPY --from=builder /app/package.json /app/package.json
COPY --from=builder /app/package-lock.json /app/package-lock.json
COPY --from=builder /app/memory.json /app/memory.json
ENV NODE_ENV=production
ENV MEMORY_FILE_PATH=/app/memory.json
WORKDIR /app
RUN npm ci --ignore-scripts --omit-dev
ENTRYPOINT ["node", "dist/project_index.js"]
```
--------------------------------------------------------------------------------
/student/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
FROM node:22.12-alpine AS builder
COPY student /app
COPY tsconfig.json /tsconfig.json
WORKDIR /app
RUN --mount=type=cache,target=/root/.npm npm install
RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
FROM node:22-alpine AS release
COPY --from=builder /app/dist /app/dist
COPY --from=builder /app/package.json /app/package.json
COPY --from=builder /app/package-lock.json /app/package-lock.json
COPY --from=builder /app/memory.json /app/memory.json
ENV NODE_ENV=production
ENV MEMORY_FILE_PATH=/app/memory.json
WORKDIR /app
RUN npm ci --ignore-scripts --omit-dev
ENTRYPOINT ["node", "dist/student_index.js"]
```
--------------------------------------------------------------------------------
/developer/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
FROM node:22.12-alpine AS builder
COPY developer /app
COPY tsconfig.json /tsconfig.json
WORKDIR /app
RUN --mount=type=cache,target=/root/.npm npm install
RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
FROM node:22-alpine AS release
COPY --from=builder /app/dist /app/dist
COPY --from=builder /app/package.json /app/package.json
COPY --from=builder /app/package-lock.json /app/package-lock.json
COPY --from=builder /app/memory.json /app/memory.json
ENV NODE_ENV=production
ENV MEMORY_FILE_PATH=/app/memory.json
WORKDIR /app
RUN npm ci --ignore-scripts --omit-dev
ENTRYPOINT ["node", "dist/developer_index.js"]
```
--------------------------------------------------------------------------------
/qualitativeresearch/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
FROM node:22.12-alpine AS builder
COPY qualitativeresearch /app
COPY tsconfig.json /tsconfig.json
WORKDIR /app
RUN --mount=type=cache,target=/root/.npm npm install
RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
FROM node:22-alpine AS release
COPY --from=builder /app/dist /app/dist
COPY --from=builder /app/package.json /app/package.json
COPY --from=builder /app/package-lock.json /app/package-lock.json
COPY --from=builder /app/memory.json /app/memory.json
COPY --from=builder /app/qualitative_research_memory.json /app/qualitative_research_memory.json
ENV NODE_ENV=production
ENV MEMORY_FILE_PATH=/app/memory.json
WORKDIR /app
RUN npm ci --ignore-scripts --omit-dev
ENTRYPOINT ["node", "dist/qualitativeresearch_index.js"]
```
--------------------------------------------------------------------------------
/quantitativeresearch/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
FROM node:22.12-alpine AS builder
COPY quantitativeresearch /app
COPY tsconfig.json /tsconfig.json
WORKDIR /app
RUN --mount=type=cache,target=/root/.npm npm install
RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
FROM node:22-alpine AS release
COPY --from=builder /app/dist /app/dist
COPY --from=builder /app/package.json /app/package.json
COPY --from=builder /app/package-lock.json /app/package-lock.json
COPY --from=builder /app/memory.json /app/memory.json
COPY --from=builder /app/quantitative_research_memory.json /app/quantitative_research_memory.json
ENV NODE_ENV=production
ENV MEMORY_FILE_PATH=/app/memory.json
WORKDIR /app
RUN npm ci --ignore-scripts --omit-dev
ENTRYPOINT ["node", "dist/quantitativeresearch_index.js"]
```
--------------------------------------------------------------------------------
/main/package.json:
--------------------------------------------------------------------------------
```json
{
"name": "contextmanager-main",
"version": "1.0.0",
"description": "A unified MCP server that manages multiple domain-specific MCP servers",
"type": "module",
"main": "index.js",
"bin": {
"mcp-server-contextmanager": "index.js"
},
"files": [
"index.js",
"README.md",
"descriptions/**/*"
],
"scripts": {
"build": "tsc && cp -r descriptions ../dist/main/",
"start": "node index.js",
"prepare": "npm run build"
},
"dependencies": {
"@modelcontextprotocol/sdk": "^1.7.0",
"zod": "^3.22.4",
"yargs": "^17.7.2",
"chalk": "^5.3.0"
},
"devDependencies": {
"@types/node": "^18.15.3",
"@types/yargs": "^17.0.32",
"typescript": "^5.0.2"
},
"keywords": [
"mcp",
"claude",
"context",
"manager"
],
"author": "tejpalvirk",
"license": "MIT"
}
```
--------------------------------------------------------------------------------
/main/descriptions/student_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "stu_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 6,
"analysis": "Analyzed progress on studying for the final exam",
"stageData": {
"summary": "Reviewed course materials and completed practice problems",
"duration": "2 hours",
"course": "Data Structures"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 2: Concepts Learned Stage
```json
{
"sessionId": "stu_1234567890_abc123",
"stage": "conceptsLearned",
"stageNumber": 2,
"totalStages": 6,
"analysis": "Listed key concepts studied",
"stageData": {
"concepts": [
"Balanced binary trees",
"Red-black trees",
"Tree traversal algorithms"
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "stu_1234567890_abc123",
"stage": "assembly",
"stageNumber": 6,
"totalStages": 6,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/student/student_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "stu_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 6,
"analysis": "Analyzed progress on studying for the final exam",
"stageData": {
"summary": "Reviewed course materials and completed practice problems",
"duration": "2 hours",
"course": "Data Structures"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 2: Concepts Learned Stage
```json
{
"sessionId": "stu_1234567890_abc123",
"stage": "conceptsLearned",
"stageNumber": 2,
"totalStages": 6,
"analysis": "Listed key concepts studied",
"stageData": {
"concepts": [
"Balanced binary trees",
"Red-black trees",
"Tree traversal algorithms"
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "stu_1234567890_abc123",
"stage": "assembly",
"stageNumber": 6,
"totalStages": 6,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/developer/developer_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "dev_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 6,
"analysis": "Analyzed progress on the authentication system",
"stageData": {
"summary": "Completed the login functionality and fixed related bugs",
"duration": "3 hours",
"focus": "AuthSystem"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 2: Achievements Stage
```json
{
"sessionId": "dev_1234567890_abc123",
"stage": "achievements",
"stageNumber": 2,
"totalStages": 6,
"analysis": "Listed key accomplishments",
"stageData": {
"achievements": [
"Implemented password reset functionality",
"Fixed login redirect bug",
"Added error handling for authentication failures"
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "dev_1234567890_abc123",
"stage": "assembly",
"stageNumber": 6,
"totalStages": 6,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/main/descriptions/developer_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "dev_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 6,
"analysis": "Analyzed progress on the authentication system",
"stageData": {
"summary": "Completed the login functionality and fixed related bugs",
"duration": "3 hours",
"focus": "AuthSystem"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 2: Achievements Stage
```json
{
"sessionId": "dev_1234567890_abc123",
"stage": "achievements",
"stageNumber": 2,
"totalStages": 6,
"analysis": "Listed key accomplishments",
"stageData": {
"achievements": [
"Implemented password reset functionality",
"Fixed login redirect bug",
"Added error handling for authentication failures"
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "dev_1234567890_abc123",
"stage": "assembly",
"stageNumber": 6,
"totalStages": 6,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/build-all-domains.sh:
--------------------------------------------------------------------------------
```bash
#!/bin/bash
# Script to build all domain packages
# Store the current directory
ORIGINAL_DIR=$(pwd)
# Define the domains to build
DOMAINS=("developer" "student" "project" "qualitativeresearch" "quantitativeresearch")
# Print header
echo "====================================="
echo "Building all domain packages"
echo "====================================="
# Loop through each domain and build
for domain in "${DOMAINS[@]}"; do
echo ""
echo "Building $domain..."
# Check if domain directory exists
if [ -d "$domain" ]; then
# Navigate to the domain directory
cd "$domain"
# Run npm build
npm run build
# Capture the exit status
BUILD_STATUS=$?
# Check if build was successful
if [ $BUILD_STATUS -eq 0 ]; then
echo "✅ $domain built successfully"
else
echo "❌ $domain build failed with status $BUILD_STATUS"
fi
# Return to the original directory
cd "$ORIGINAL_DIR"
else
echo "❌ $domain directory not found"
fi
done
echo ""
echo "====================================="
echo "Build process completed"
echo "====================================="
```
--------------------------------------------------------------------------------
/main/descriptions/project_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "proj_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 6,
"analysis": "Analyzed progress on the marketing campaign project",
"stageData": {
"summary": "Completed the social media strategy components",
"duration": "4 hours",
"project": "Q4 Marketing Campaign"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 3: Task Updates Stage
```json
{
"sessionId": "proj_1234567890_abc123",
"stage": "taskUpdates",
"stageNumber": 3,
"totalStages": 6,
"analysis": "Updated status of in-progress tasks",
"stageData": {
"updates": [
{
"name": "Design Website Homepage",
"status": "in_progress",
"progress": "70%"
},
{
"name": "Create Social Media Posts",
"status": "completed"
}
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "proj_1234567890_abc123",
"stage": "assembly",
"stageNumber": 6,
"totalStages": 6,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/project/project_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "proj_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 6,
"analysis": "Analyzed progress on the marketing campaign project",
"stageData": {
"summary": "Completed the social media strategy components",
"duration": "4 hours",
"project": "Q4 Marketing Campaign"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 3: Task Updates Stage
```json
{
"sessionId": "proj_1234567890_abc123",
"stage": "taskUpdates",
"stageNumber": 3,
"totalStages": 6,
"analysis": "Updated status of in-progress tasks",
"stageData": {
"updates": [
{
"name": "Design Website Homepage",
"status": "in_progress",
"progress": "70%"
},
{
"name": "Create Social Media Posts",
"status": "completed"
}
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "proj_1234567890_abc123",
"stage": "assembly",
"stageNumber": 6,
"totalStages": 6,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/student/package.json:
--------------------------------------------------------------------------------
```json
{
"name": "contextmanager-student",
"version": "1.0.0",
"description": "MCP Server implementations for managing context of students",
"type": "module",
"main": "./index.js",
"bin": {
"contextmanager-student": "./index.js"
},
"files": [
"index.js",
"README.md",
"*.txt"
],
"scripts": {
"build": "tsc && shx chmod +x index.js && cp student_*.txt ../main/descriptions",
"prepare": "npm run build",
"start": "node index.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/tejpalvirk/contextmanager.git"
},
"keywords": [
"mcp",
"claude",
"context"
],
"author": "Tejpal Virk",
"license": "MIT",
"bugs": {
"url": "https://github.com/tejpalvirk/contextmanager/issues"
},
"homepage": "https://github.com/tejpalvirk/contextmanager#readme",
"dependencies": {
"@modelcontextprotocol/sdk": "^1.7.0",
"zod": "^3.22.4",
"yargs": "^17.7.2",
"chalk": "^5.3.0"
},
"bundledDependencies": [
"@modelcontextprotocol/sdk",
"zod",
"yargs",
"chalk"
],
"devDependencies": {
"@types/node": "^18.15.3",
"@types/yargs": "^17.0.33",
"shx": "^0.3.4",
"typescript": "^5.0.2"
}
}
```
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
```json
{
"name": "contextmanager",
"version": "1.0.0",
"description": "MCP Server implementations for various domains",
"type": "module",
"bin": {
"mcp-server-contextmanager": "./dist/main/index.js"
},
"files": [
"dist",
"README.md"
],
"workspaces": [
"main"
],
"scripts": {
"build": "tsc && shx chmod +x dist/main/index.js && cp -r main/descriptions dist/main/",
"prepare": "npm run build",
"start": "node dist/main/index.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/tejpalvirk/contextmanager.git"
},
"keywords": [
"mcp",
"claude",
"context"
],
"author": "tejpalvirk",
"license": "MIT",
"bugs": {
"url": "https://github.com/tejpalvirk/contextmanager/issues"
},
"homepage": "https://github.com/tejpalvirk/contextmanager#readme",
"dependencies": {
"@modelcontextprotocol/sdk": "^1.7.0",
"zod": "^3.22.4",
"yargs": "^17.7.2",
"chalk": "^5.3.0"
},
"bundledDependencies": [
"@modelcontextprotocol/sdk",
"zod",
"yargs",
"chalk"
],
"devDependencies": {
"@types/node": "^18.15.3",
"@types/yargs": "^17.0.33",
"shx": "^0.3.4",
"typescript": "^5.0.2"
}
}
```
--------------------------------------------------------------------------------
/project/package.json:
--------------------------------------------------------------------------------
```json
{
"name": "contextmanager-project",
"version": "1.0.0",
"description": "MCP Server implementations for handling context for project management",
"type": "module",
"main": "./index.js",
"bin": {
"contextmanager-project": "./index.js"
},
"files": [
"index.js",
"README.md",
"*.txt"
],
"scripts": {
"build": "tsc && shx chmod +x index.js && cp project_*.txt ../main/descriptions",
"prepare": "npm run build",
"start": "node index.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/tejpalvirk/contextmanager.git"
},
"keywords": [
"mcp",
"claude",
"context"
],
"author": "Tejpal Virk",
"license": "MIT",
"bugs": {
"url": "https://github.com/tejpalvirk/contextmanager/issues"
},
"homepage": "https://github.com/tejpalvirk/contextmanager#readme",
"dependencies": {
"@modelcontextprotocol/sdk": "^1.7.0",
"zod": "^3.22.4",
"yargs": "^17.7.2",
"chalk": "^5.3.0"
},
"bundledDependencies": [
"@modelcontextprotocol/sdk",
"zod",
"yargs",
"chalk"
],
"devDependencies": {
"@types/node": "^18.15.3",
"@types/yargs": "^17.0.33",
"shx": "^0.3.4",
"typescript": "^5.0.2"
}
}
```
--------------------------------------------------------------------------------
/developer/package.json:
--------------------------------------------------------------------------------
```json
{
"name": "contextmanager-developer",
"version": "1.0.0",
"description": "MCP Server implementations for managing context of software development projects",
"type": "module",
"main": "./index.js",
"bin": {
"contextmanager-developer": "./index.js"
},
"files": [
"index.js",
"README.md",
"*.txt"
],
"scripts": {
"build": "tsc && shx chmod +x index.js && cp developer_*.txt ../main/descriptions",
"prepare": "npm run build",
"start": "node index.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/tejpalvirk/contextmanager.git"
},
"keywords": [
"mcp",
"claude",
"context"
],
"author": "Tejpal Virk",
"license": "MIT",
"bugs": {
"url": "https://github.com/tejpalvirk/contextmanager/issues"
},
"homepage": "https://github.com/tejpalvirk/contextmanager#readme",
"dependencies": {
"@modelcontextprotocol/sdk": "^1.7.0",
"zod": "^3.22.4",
"yargs": "^17.7.2",
"chalk": "^5.3.0"
},
"bundledDependencies": [
"@modelcontextprotocol/sdk",
"zod",
"yargs",
"chalk"
],
"devDependencies": {
"@types/node": "^18.15.3",
"@types/yargs": "^17.0.33",
"shx": "^0.3.4",
"typescript": "^5.0.2"
}
}
```
--------------------------------------------------------------------------------
/qualitativeresearch/package.json:
--------------------------------------------------------------------------------
```json
{
"name": "contextmanager-qualitativeresearch",
"version": "1.0.0",
"description": "MCP Server implementations for managing context of qualitative research projects",
"type": "module",
"main": "./index.js",
"bin": {
"contextmanager-qualitativeresearch": "./index.js"
},
"files": [
"index.js",
"README.md",
"*.txt"
],
"scripts": {
"build": "tsc && shx chmod +x index.js && cp qualitativeresearch_*.txt ../main/descriptions",
"prepare": "npm run build",
"start": "node index.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/tejpalvirk/contextmanager.git"
},
"keywords": [
"mcp",
"claude",
"context"
],
"author": "Tejpal Virk",
"license": "MIT",
"bugs": {
"url": "https://github.com/tejpalvirk/contextmanager/issues"
},
"homepage": "https://github.com/tejpalvirk/contextmanager#readme",
"dependencies": {
"@modelcontextprotocol/sdk": "^1.7.0",
"zod": "^3.22.4",
"yargs": "^17.7.2",
"chalk": "^5.3.0"
},
"bundledDependencies": [
"@modelcontextprotocol/sdk",
"zod",
"yargs",
"chalk"
],
"devDependencies": {
"@types/node": "^18.15.3",
"@types/yargs": "^17.0.33",
"shx": "^0.3.4",
"typescript": "^5.0.2"
}
}
```
--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "qual_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 7,
"analysis": "Analyzed progress on the interview data coding",
"stageData": {
"summary": "Completed initial coding of participant interviews",
"duration": "3 hours",
"project": "Health Behavior Study"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 5: Themes Stage
```json
{
"sessionId": "qual_1234567890_abc123",
"stage": "themes",
"stageNumber": 5,
"totalStages": 7,
"analysis": "Identified emerging themes",
"stageData": {
"themes": [
{
"name": "Perceived Barriers",
"codes": ["time_constraints", "financial_concerns"],
"description": "Factors preventing healthy behaviors"
},
{
"name": "Social Support",
"codes": ["family_influence", "peer_encouragement"],
"description": "External motivation from relationships"
}
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "qual_1234567890_abc123",
"stage": "assembly",
"stageNumber": 7,
"totalStages": 7,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "qual_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 7,
"analysis": "Analyzed progress on the interview data coding",
"stageData": {
"summary": "Completed initial coding of participant interviews",
"duration": "3 hours",
"project": "Health Behavior Study"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 5: Themes Stage
```json
{
"sessionId": "qual_1234567890_abc123",
"stage": "themes",
"stageNumber": 5,
"totalStages": 7,
"analysis": "Identified emerging themes",
"stageData": {
"themes": [
{
"name": "Perceived Barriers",
"codes": ["time_constraints", "financial_concerns"],
"description": "Factors preventing healthy behaviors"
},
{
"name": "Social Support",
"codes": ["family_influence", "peer_encouragement"],
"description": "External motivation from relationships"
}
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "qual_1234567890_abc123",
"stage": "assembly",
"stageNumber": 7,
"totalStages": 7,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/quantitativeresearch/package.json:
--------------------------------------------------------------------------------
```json
{
"name": "contextmanager-quantitativeresearch",
"version": "1.0.0",
"description": "MCP Server implementations for managing context of quantitative research projects",
"type": "module",
"main": "./index.js",
"bin": {
"contextmanager-quantitativeresearch": "./index.js"
},
"files": [
"index.js",
"README.md",
"*.txt"
],
"scripts": {
"build": "tsc && shx chmod +x index.js && cp quantitativeresearch_*.txt ../main/descriptions",
"prepare": "npm run build",
"start": "node index.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/tejpalvirk/contextmanager.git"
},
"keywords": [
"mcp",
"claude",
"context"
],
"author": "Tejpal Virk",
"license": "MIT",
"bugs": {
"url": "https://github.com/tejpalvirk/contextmanager/issues"
},
"homepage": "https://github.com/tejpalvirk/contextmanager#readme",
"dependencies": {
"@modelcontextprotocol/sdk": "^1.7.0",
"zod": "^3.22.4",
"yargs": "^17.7.2",
"chalk": "^5.3.0"
},
"bundledDependencies": [
"@modelcontextprotocol/sdk",
"zod",
"yargs",
"chalk"
],
"devDependencies": {
"@types/node": "^18.15.3",
"@types/yargs": "^17.0.33",
"shx": "^0.3.4",
"typescript": "^5.0.2"
}
}
```
--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "quant_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 8,
"analysis": "Analyzed progress on the multiple regression analysis",
"stageData": {
"summary": "Completed data preparation and initial statistical tests",
"duration": "4 hours",
"project": "Customer Satisfaction Study"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 3: New Analyses Stage
```json
{
"sessionId": "quant_1234567890_abc123",
"stage": "newAnalyses",
"stageNumber": 3,
"totalStages": 8,
"analysis": "Conducted statistical tests on prepared data",
"stageData": {
"analyses": [
{
"name": "Age_Income_Regression",
"type": "multiple_regression",
"result": "Significant relationship found",
"pValue": "0.003",
"variables": ["age", "income", "satisfaction_score"]
},
{
"name": "Gender_Satisfaction_Ttest",
"type": "t_test",
"result": "No significant difference",
"pValue": "0.42",
"variables": ["gender", "satisfaction_score"]
}
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "quant_1234567890_abc123",
"stage": "assembly",
"stageNumber": 8,
"totalStages": 8,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_endsession_examples.txt:
--------------------------------------------------------------------------------
```
## Usage examples
### Stage 1: Summary Stage
```json
{
"sessionId": "quant_1234567890_abc123",
"stage": "summary",
"stageNumber": 1,
"totalStages": 8,
"analysis": "Analyzed progress on the multiple regression analysis",
"stageData": {
"summary": "Completed data preparation and initial statistical tests",
"duration": "4 hours",
"project": "Customer Satisfaction Study"
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Stage 3: New Analyses Stage
```json
{
"sessionId": "quant_1234567890_abc123",
"stage": "newAnalyses",
"stageNumber": 3,
"totalStages": 8,
"analysis": "Conducted statistical tests on prepared data",
"stageData": {
"analyses": [
{
"name": "Age_Income_Regression",
"type": "multiple_regression",
"result": "Significant relationship found",
"pValue": "0.003",
"variables": ["age", "income", "satisfaction_score"]
},
{
"name": "Gender_Satisfaction_Ttest",
"type": "t_test",
"result": "No significant difference",
"pValue": "0.42",
"variables": ["gender", "satisfaction_score"]
}
]
},
"nextStageNeeded": true,
"isRevision": false
}
```
### Final Stage: Assembly
```json
{
"sessionId": "quant_1234567890_abc123",
"stage": "assembly",
"stageNumber": 8,
"totalStages": 8,
"nextStageNeeded": false,
"isRevision": false
}
```
```
--------------------------------------------------------------------------------
/developer/index.d.ts:
--------------------------------------------------------------------------------
```typescript
#!/usr/bin/env node
interface Entity {
name: string;
entityType: string;
observations: string[];
}
interface Relation {
from: string;
to: string;
relationType: string;
}
interface KnowledgeGraph {
entities: Entity[];
relations: Relation[];
}
declare class KnowledgeGraphManager {
private loadGraph;
private saveGraph;
initializeStatusAndPriority(): Promise<void>;
getEntityStatus(entityName: string): Promise<string | null>;
getEntityPriority(entityName: string): Promise<string | null>;
setEntityStatus(entityName: string, statusValue: string): Promise<void>;
setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
createEntities(entities: Entity[]): Promise<Entity[]>;
createRelations(relations: Relation[]): Promise<Relation[]>;
addObservations(observations: {
entityName: string;
contents: string[];
}[]): Promise<{
entityName: string;
addedObservations: string[];
}[]>;
deleteEntities(entityNames: string[]): Promise<void>;
deleteObservations(deletions: {
entityName: string;
observations: string[];
}[]): Promise<void>;
deleteRelations(relations: Relation[]): Promise<void>;
readGraph(): Promise<KnowledgeGraph>;
searchNodes(query: string): Promise<KnowledgeGraph>;
openNodes(names: string[]): Promise<KnowledgeGraph>;
getProjectStatus(projectName: string): Promise<any>;
getComponentContext(componentName: string): Promise<any>;
getRelatedEntities(entityName: string, relationTypes?: string[]): Promise<any>;
getDecisionHistory(projectName: string): Promise<any>;
getMilestoneProgress(milestoneName: string): Promise<any>;
}
export { KnowledgeGraphManager };
```
--------------------------------------------------------------------------------
/developer/developer_startsession.txt:
--------------------------------------------------------------------------------
```
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:
1. Use the generated session ID with the loadcontext tool to load specific entities
2. End the session with endsession when work is complete
```
--------------------------------------------------------------------------------
/main/descriptions/developer_startsession.txt:
--------------------------------------------------------------------------------
```
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:
1. Use the generated session ID with the loadcontext tool to load specific entities
2. End the session with endsession when work is complete
```
--------------------------------------------------------------------------------
/qualitativeresearch/index.d.ts:
--------------------------------------------------------------------------------
```typescript
#!/usr/bin/env node
interface Entity {
name: string;
entityType: string;
observations: string[];
}
interface Relation {
from: string;
to: string;
relationType: string;
}
interface KnowledgeGraph {
entities: Entity[];
relations: Relation[];
}
declare class KnowledgeGraphManager {
private loadGraph;
private saveGraph;
initializeStatusAndPriority(): Promise<void>;
getEntityStatus(entityName: string): Promise<string | null>;
getEntityPriority(entityName: string): Promise<string | null>;
setEntityStatus(entityName: string, statusValue: string): Promise<void>;
setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
createEntities(entities: Entity[]): Promise<Entity[]>;
createRelations(relations: Relation[]): Promise<Relation[]>;
addObservations(observations: {
entityName: string;
contents: string[];
}[]): Promise<{
entityName: string;
addedObservations: string[];
}[]>;
deleteEntities(entityNames: string[]): Promise<void>;
deleteObservations(deletions: {
entityName: string;
observations: string[];
}[]): Promise<void>;
deleteRelations(relations: Relation[]): Promise<void>;
readGraph(): Promise<KnowledgeGraph>;
searchNodes(query: string): Promise<KnowledgeGraph>;
openNodes(names: string[]): Promise<KnowledgeGraph>;
getProjectOverview(projectName: string): Promise<any>;
getParticipantProfile(participantName: string): Promise<any>;
getThematicAnalysis(projectName: string): Promise<any>;
getCodedData(codeName: string): Promise<any>;
getResearchQuestionAnalysis(projectName: string): Promise<any>;
getChronologicalData(projectName: string, dataType?: string): Promise<any>;
getCodeCooccurrence(codeName: string): Promise<any>;
getMemosByFocus(entityName: string): Promise<any>;
getMethodologyDetails(projectName: string): Promise<any>;
getRelatedEntities(entityName: string, relationTypes?: string[]): Promise<any>;
}
export { KnowledgeGraphManager };
```
--------------------------------------------------------------------------------
/student/index.d.ts:
--------------------------------------------------------------------------------
```typescript
#!/usr/bin/env node
declare const validEntityTypes: readonly ["course", "assignment", "exam", "concept", "resource", "note", "lecture", "project", "question", "term", "goal", "professor", "status", "priority"];
type EntityType = typeof validEntityTypes[number];
interface Entity {
name: string;
entityType: EntityType;
observations: string[];
embedding?: any;
}
interface Relation {
from: string;
to: string;
relationType: string;
observations?: string[];
}
interface KnowledgeGraph {
entities: Entity[];
relations: Relation[];
}
declare class KnowledgeGraphManager {
private loadGraph;
private saveGraph;
initializeStatusAndPriority(): Promise<void>;
getEntityStatus(entityName: string): Promise<string | null>;
getEntityPriority(entityName: string): Promise<string | null>;
setEntityStatus(entityName: string, statusValue: string): Promise<void>;
setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
createEntities(entities: Entity[]): Promise<KnowledgeGraph>;
createRelations(relations: Relation[]): Promise<KnowledgeGraph>;
addObservations(entityName: string, observations: string[]): Promise<KnowledgeGraph>;
deleteEntities(entityNames: string[]): Promise<void>;
deleteObservations(deletions: {
entityName: string;
observations: string[];
}[]): Promise<void>;
deleteRelations(relations: Relation[]): Promise<void>;
readGraph(): Promise<KnowledgeGraph>;
searchNodes(query: string): Promise<KnowledgeGraph>;
openNodes(names: string[]): Promise<KnowledgeGraph>;
getCourseOverview(courseName: string): Promise<any>;
getUpcomingDeadlines(termName?: string, courseName?: string, daysAhead?: number): Promise<any>;
getAssignmentStatus(assignmentName: string): Promise<any>;
getExamPrep(examName: string): Promise<any>;
findRelatedConcepts(conceptName: string, depth?: number): Promise<any>;
trackLectureNotes(courseName: string): Promise<any>;
getTermOverview(termName: string): Promise<any>;
}
export { KnowledgeGraphManager };
```
--------------------------------------------------------------------------------
/quantitativeresearch/index.d.ts:
--------------------------------------------------------------------------------
```typescript
#!/usr/bin/env node
declare function loadSessionStates(): Promise<Map<string, any[]>>;
declare function saveSessionStates(sessionsMap: Map<string, any[]>): Promise<void>;
interface Entity {
name: string;
entityType: string;
observations: string[];
}
interface Relation {
from: string;
to: string;
relationType: string;
}
interface KnowledgeGraph {
entities: Entity[];
relations: Relation[];
}
declare class KnowledgeGraphManager {
private loadGraph;
private saveGraph;
createEntities(entities: Entity[]): Promise<Entity[]>;
createRelations(relations: Relation[]): Promise<Relation[]>;
addObservations(observations: {
entityName: string;
contents: string[];
}[]): Promise<{
entityName: string;
addedObservations: string[];
}[]>;
deleteEntities(entityNames: string[]): Promise<void>;
deleteObservations(deletions: {
entityName: string;
observations: string[];
}[]): Promise<void>;
deleteRelations(relations: Relation[]): Promise<void>;
readGraph(): Promise<KnowledgeGraph>;
searchNodes(query: string): Promise<KnowledgeGraph>;
openNodes(names: string[]): Promise<KnowledgeGraph>;
getProjectOverview(projectName: string): Promise<any>;
getDatasetAnalysis(datasetName: string): Promise<any>;
getHypothesisTests(projectName: string, hypothesisName?: string): Promise<any>;
getVariableRelationships(variableName: string): Promise<any>;
getStatisticalResults(projectName: string, testType?: string): Promise<any>;
getVisualizationGallery(projectName: string, datasetName?: string): Promise<any>;
getModelPerformance(modelName: string): Promise<any>;
getResearchQuestionResults(questionName: string): Promise<any>;
getVariableDistribution(variableName: string, datasetName?: string): Promise<any>;
initializeStatusAndPriority(): Promise<void>;
getEntityStatus(entityName: string): Promise<string | null>;
getEntityPriority(entityName: string): Promise<string | null>;
setEntityStatus(entityName: string, statusValue: string): Promise<void>;
setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
}
export { KnowledgeGraphManager, loadSessionStates, saveSessionStates };
```
--------------------------------------------------------------------------------
/project/index.d.ts:
--------------------------------------------------------------------------------
```typescript
#!/usr/bin/env node
declare const validEntityTypes: readonly ["project", "task", "milestone", "resource", "teamMember", "note", "document", "issue", "risk", "decision", "dependency", "component", "stakeholder", "change", "status", "priority"];
type EntityType = typeof validEntityTypes[number];
interface Entity {
name: string;
entityType: EntityType;
observations: string[];
embedding?: Embedding;
}
interface Relation {
from: string;
to: string;
relationType: string;
observations?: string[];
}
interface KnowledgeGraph {
entities: Entity[];
relations: Relation[];
}
type Embedding = number[];
declare class KnowledgeGraphManager {
loadGraph(): Promise<KnowledgeGraph>;
private saveGraph;
initializeStatusAndPriority(): Promise<void>;
getEntityStatus(entityName: string): Promise<string | null>;
getEntityPriority(entityName: string): Promise<string | null>;
setEntityStatus(entityName: string, statusValue: string): Promise<void>;
setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
createEntities(entities: Entity[]): Promise<KnowledgeGraph>;
createRelations(relations: Relation[]): Promise<KnowledgeGraph>;
addObservations(entityName: string, observations: string[]): Promise<KnowledgeGraph>;
deleteEntities(entityNames: string[]): Promise<void>;
deleteObservations(deletions: {
entityName: string;
observations: string[];
}[]): Promise<void>;
deleteRelations(relations: Relation[]): Promise<void>;
readGraph(): Promise<KnowledgeGraph>;
searchNodes(query: string): Promise<KnowledgeGraph>;
openNodes(names: string[]): Promise<KnowledgeGraph>;
getProjectOverview(projectName: string): Promise<any>;
getTaskDependencies(taskName: string, depth?: number): Promise<any>;
private getTaskAssignee;
private calculateCriticalPath;
getTeamMemberAssignments(teamMemberName: string): Promise<any>;
getMilestoneProgress(projectName: string, milestoneName?: string): Promise<any>;
getProjectTimeline(projectName: string): Promise<any>;
getResourceAllocation(projectName: string, resourceName?: string): Promise<any>;
getProjectRisks(projectName: string): Promise<any>;
findRelatedProjects(projectName: string, depth?: number): Promise<any>;
getDecisionLog(projectName: string): Promise<any>;
getProjectHealth(projectName: string): Promise<any>;
private generateHealthRecommendations;
}
export { KnowledgeGraphManager };
```
--------------------------------------------------------------------------------
/main/descriptions/common_startsession.txt:
--------------------------------------------------------------------------------
```
A powerful session initialization tool for establishing context in domain-specific work.
This tool starts a new session and provides a comprehensive overview of the current landscape.
It retrieves recent sessions, active work items, high-priority elements, and upcoming deadlines to help focus work effectively.
When to use this tool:
- Beginning a new work session in your domain
- Getting oriented to your current state across multiple projects/courses/research
- Planning which elements to focus on in the current session
Key features:
- Generates a unique session identifier for tracking activities
- Retrieves and displays recent sessions with summaries
- Formats domain-specific information in a structured, easy-to-read format
Parameters explained:
- No parameters required - the tool automatically retrieves all relevant context
Return information:
- Session ID: A unique identifier for this session
- Recent Sessions: Up to 3 most recent sessions with date, focus area, and session summary (truncated for readability)
- Domain-Specific Elements:
* Developer:
- Active Projects: Software projects with status
- High-Priority Tasks: Task name, status, assigned developer
- Upcoming Milestones: Milestone name, due date
* Student:
- Active Courses: Currently enrolled courses
- Upcoming Deadlines: Assignment/exam name, course, due date, days remaining
- Recently Studied Concepts: List of recently studied topics
* Qualitative Research:
- Active Research Projects: Project name, status, research phase
- Sample Participants: Participant name, demographic information, participation status
- Top Codes: Code name, reference count, code group
- Recent Memos: Memo name, creation date, memo type, brief summary
* Quantitative Research:
- Active Research Projects: Project name, status
- Available Datasets: Dataset name, type of data, associated project
- Research Questions: Question text, associated project
- Recent Statistical Models: Model name, model type, performance metrics
- Recent Visualizations: Name, type (chart, plot, etc.), associated dataset
* Project Management:
- Active Projects: Project name, status, deadline information
- High-Priority Tasks: Task name, associated project, status, assignee
- Upcoming Milestones: Name, associated project, due date, completion percentage
- Project Health Summary: Project name, health status, health score, issue count, risk count
- Top Project Risks: Risk name, associated project, severity level, impact assessment
Session workflow:
1. Starting a session creates a session identifier in the appropriate domain
2. This session can be referenced when loading context with loadcontext
3. Session activities are tracked for later recording
4. Sessions should be ended with endsession to record progress and accomplishments
5. Session history becomes available for future startsession calls
You should:
1. Begin each focused work period with startsession
2. Review the provided context to determine your focus
3. Choose specific elements to work on
4. Use the generated session ID with the loadcontext tool to load specific entities
5. End the session with endsession when work is complete
```
--------------------------------------------------------------------------------
/main/descriptions/common_deletecontext.txt:
--------------------------------------------------------------------------------
```
A precise tool for removing elements from domain-specific knowledge graphs.
This tool allows targeted deletion of entities, relationships between entities, or specific observations from existing entities.
It helps maintain an accurate and current representation of the context as work evolves.
When to use this tool:
- Removing deprecated, completed, or incorrect entities
- Deleting obsolete or erroneous relationships between entities
- Pruning outdated observations that no longer apply
- Correcting errors in the knowledge graph
- Cleaning up test or prototype elements
- Reorganizing your domain structure by removing and recreating elements
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
- Clear error messages when operations fail
Parameters explained:
- type: The deletion operation type to perform, which must be one of:
* "entities" - Remove 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
- Example: ["ProjectX", "Task123", "Course101"]
* For "relations": Array of objects with { from, to, relationType }
- Example: [{ "from": "ProjectX", "to": "Task123", "relationType": "contains" }]
* For "observations": Array of objects with { entityName, observations[] }
- Example: [{ "entityName": "ProjectX", "observations": ["status:completed", "priority:high"] }]
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
- Consider exporting or backing up your knowledge graph before large-scale deletions
Return information:
- JSON response indicating success or failure
- For successful operations:
* Success flag set to true
* Confirmation message with count of deleted items
- For failed operations:
* Success flag set to false
* Error message describing the issue
You should:
1. Identify the specific elements that need to be removed
2. Choose the appropriate deletion type (entities, relations, or observations)
3. Structure your data according to the deletion type's requirements
4. Start with the most specific deletions (observations) before broader ones
5. Consider documenting major deletions as observations on related entities
6. When removing an entire project/course/research component, first delete its sub-elements for cleaner removal
```
--------------------------------------------------------------------------------
/developer/developer_deletecontext.txt:
--------------------------------------------------------------------------------
```
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:
1. Identify the specific elements that need to be removed
2. Choose the appropriate deletion type (entities, relations, or observations)
3. Structure your data according to the deletion type's requirements
4. Start with the most specific deletions (observations) before broader ones
5. Verify the entities or relations exist before attempting deletion
6. To update status or priority, create new has_status or has_priority relations rather than deleting old ones
7. When removing task sequencing, consider how it affects other tasks and milestones
8. Check the operation result to confirm successful deletion
9. Consider documenting major deletions as observations on related entities
10. When removing an entire project, first delete its components for cleaner removal
```
--------------------------------------------------------------------------------
/main/descriptions/developer_deletecontext.txt:
--------------------------------------------------------------------------------
```
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:
1. Identify the specific elements that need to be removed
2. Choose the appropriate deletion type (entities, relations, or observations)
3. Structure your data according to the deletion type's requirements
4. Start with the most specific deletions (observations) before broader ones
5. Verify the entities or relations exist before attempting deletion
6. To update status or priority, create new has_status or has_priority relations rather than deleting old ones
7. When removing task sequencing, consider how it affects other tasks and milestones
8. Check the operation result to confirm successful deletion
9. Consider documenting major deletions as observations on related entities
10. When removing an entire project, first delete its components for cleaner removal
```
--------------------------------------------------------------------------------
/developer/developer_loadcontext.txt:
--------------------------------------------------------------------------------
```
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
```
--------------------------------------------------------------------------------
/main/descriptions/developer_loadcontext.txt:
--------------------------------------------------------------------------------
```
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
```
--------------------------------------------------------------------------------
/main/descriptions/student_startsession.txt:
--------------------------------------------------------------------------------
```
A powerful tool for initializing a new academic study session.
This tool starts a new study session and provides a comprehensive overview of your current educational landscape.
It retrieves recent study sessions, active courses, upcoming deadlines, and recently studied concepts to help focus your learning effectively.
When to use this tool:
- Beginning a new study session or learning period
- Getting oriented in your current academic state
- Planning which courses or assignments to focus on
- Reviewing recent study activity and progress
- Checking upcoming deadlines for assignments and exams
- Deciding which concepts need attention
- Establishing context before diving into specific study work
- Creating a structured record of your study activity
- Identifying high-priority assignments that need attention
- Tracking progress through status information
Key features:
- Generates a unique study session identifier for tracking activity
- Retrieves and displays your most recent study sessions
- Shows active courses (based on has_status relations)
- Highlights high-priority assignments (based on has_priority relations)
- Identifies assignment status (not_started, in_progress, complete)
- Highlights upcoming assignment and exam deadlines
- Lists recently studied concepts for review
- Formats information in a structured, easy-to-read format
- Provides seamless integration with loadcontext tool
- Stores study session data for historical record keeping
Parameters explained:
- No parameters required - the tool automatically retrieves all relevant context
Return information:
- Session ID: A unique identifier for this study session (format: stud_timestamp_randomstring)
- Recent Study Sessions: Up to 3 most recent sessions with:
* Date
* Course focus
* Study session summary (truncated for readability)
- Active Courses: List of courses with active status (via has_status relation), including:
* Course name
* Course code or description
* Status via has_status relation
* Priority if assigned via has_priority relation
- High-Priority Assignments: Assignments with high priority status (via has_priority relation), including:
* Assignment name
* Current status (not_started, in_progress, complete)
* Course it belongs to
* Due date if available
- Upcoming Deadlines: Assignment and exam deadlines in the next 14 days, including:
* Assignment/exam name
* Course it belongs to
* Due date
* Days remaining until due
* Status (not_started, in_progress, complete)
- Recently Studied Concepts: List of concepts you've recently studied
Session workflow:
1. Starting a session creates a session identifier in the student domain
2. This session can be referenced when loading course context with loadcontext
3. Session activities are tracked for later recording
4. Sessions should be ended with endsession to record learning progress
5. Session history becomes available for future startsession calls
Status and Priority:
- Course status is retrieved through has_status relations (not_started, in_progress, complete)
- Assignment priority is retrieved through has_priority relations (low, high)
- This information helps you prioritize your study activities
You should:
1. Begin each focused study period with startsession
2. Review the provided context to determine your study focus
3. Prioritize high-priority assignments with upcoming deadlines
4. Focus on incomplete assignments (not_started or in_progress status)
5. Choose a specific course, assignment, or concept to work on
6. Use the generated session ID with the loadcontext tool to load specific entities
7. Complete your study work on your selected focus area
8. End the session with endsession when work is complete
9. Record concepts learned, assignment status updates, and study accomplishments
10. Use the session history to maintain continuity between study periods
```
--------------------------------------------------------------------------------
/student/student_startsession.txt:
--------------------------------------------------------------------------------
```
A powerful tool for initializing a new academic study session.
This tool starts a new study session and provides a comprehensive overview of your current educational landscape.
It retrieves recent study sessions, active courses, upcoming deadlines, and recently studied concepts to help focus your learning effectively.
When to use this tool:
- Beginning a new study session or learning period
- Getting oriented in your current academic state
- Planning which courses or assignments to focus on
- Reviewing recent study activity and progress
- Checking upcoming deadlines for assignments and exams
- Deciding which concepts need attention
- Establishing context before diving into specific study work
- Creating a structured record of your study activity
- Identifying high-priority assignments that need attention
- Tracking progress through status information
Key features:
- Generates a unique study session identifier for tracking activity
- Retrieves and displays your most recent study sessions
- Shows active courses (based on has_status relations)
- Highlights high-priority assignments (based on has_priority relations)
- Identifies assignment status (not_started, in_progress, complete)
- Highlights upcoming assignment and exam deadlines
- Lists recently studied concepts for review
- Formats information in a structured, easy-to-read format
- Provides seamless integration with loadcontext tool
- Stores study session data for historical record keeping
Parameters explained:
- No parameters required - the tool automatically retrieves all relevant context
Return information:
- Session ID: A unique identifier for this study session (format: stud_timestamp_randomstring)
- Recent Study Sessions: Up to 3 most recent sessions with:
* Date
* Course focus
* Study session summary (truncated for readability)
- Active Courses: List of courses with active status (via has_status relation), including:
* Course name
* Course code or description
* Status via has_status relation
* Priority if assigned via has_priority relation
- High-Priority Assignments: Assignments with high priority status (via has_priority relation), including:
* Assignment name
* Current status (not_started, in_progress, complete)
* Course it belongs to
* Due date if available
- Upcoming Deadlines: Assignment and exam deadlines in the next 14 days, including:
* Assignment/exam name
* Course it belongs to
* Due date
* Days remaining until due
* Status (not_started, in_progress, complete)
- Recently Studied Concepts: List of concepts you've recently studied
Session workflow:
1. Starting a session creates a session identifier in the student domain
2. This session can be referenced when loading course context with loadcontext
3. Session activities are tracked for later recording
4. Sessions should be ended with endsession to record learning progress
5. Session history becomes available for future startsession calls
Status and Priority:
- Course status is retrieved through has_status relations (not_started, in_progress, complete)
- Assignment priority is retrieved through has_priority relations (low, high)
- This information helps you prioritize your study activities
You should:
1. Begin each focused study period with startsession
2. Review the provided context to determine your study focus
3. Prioritize high-priority assignments with upcoming deadlines
4. Focus on incomplete assignments (not_started or in_progress status)
5. Choose a specific course, assignment, or concept to work on
6. Use the generated session ID with the loadcontext tool to load specific entities
7. Complete your study work on your selected focus area
8. End the session with endsession when work is complete
9. Record concepts learned, assignment status updates, and study accomplishments
10. Use the session history to maintain continuity between study periods
```
--------------------------------------------------------------------------------
/main/descriptions/student_deletecontext.txt:
--------------------------------------------------------------------------------
```
A precise tool for removing elements from your educational knowledge graph.
This tool enables targeted deletion of academic entities, relationships between educational components, or specific observations about study materials.
It helps maintain an accurate and current representation of your academic landscape as your learning journey evolves.
When to use this tool:
- Removing completed or dropped courses
- Deleting obsolete relationships between academic entities
- Pruning outdated notes or observations that are no longer relevant
- Correcting errors in your academic knowledge graph
- Cleaning up test or practice entities
- Maintaining graph accuracy as your educational focus changes
- Removing duplicate learning materials or resources
- Archiving completed assignments or exams
- Updating status or priority relations when they change
- Modifying entity sequences
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
- Clear error messages when operations fail
Parameters explained:
- type: The deletion operation type to perform, which must be one of:
* "entities" - Remove academic 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
Status and Priority Management:
- To change an entity's status, delete the old has_status relation and create a new one
- To change priority, delete the old has_priority relation and create a new one
- Status values (not_started, in_progress, complete) are managed through relations, not direct properties
- Priority values (low, high) are managed through relations, not direct properties
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 of your academic knowledge
- Relations require entities on both ends to exist
- Deleting status or priority relations without replacing them can lead to inconsistent state
- Consider creating new status/priority relations before deleting old ones
You should:
1. Identify the specific elements in your academic graph that need to be removed
2. Choose the appropriate deletion type (entities, relations, or observations)
3. Structure your data according to the deletion type's requirements
4. Start with more specific deletions (observations) before broader ones
5. Verify the entities or relations exist before attempting deletion
6. When updating status, create a new has_status relation before deleting the old one
7. When updating priority, create a new has_priority relation before deleting the old one
8. Consider the impact on entity sequences when deleting follows relations
9. Check the operation result to confirm successful deletion
10. Consider documenting major deletions as observations on related entities
11. When removing an entire course, first delete its components for cleaner removal
```
--------------------------------------------------------------------------------
/student/student_deletecontext.txt:
--------------------------------------------------------------------------------
```
A precise tool for removing elements from your educational knowledge graph.
This tool enables targeted deletion of academic entities, relationships between educational components, or specific observations about study materials.
It helps maintain an accurate and current representation of your academic landscape as your learning journey evolves.
When to use this tool:
- Removing completed or dropped courses
- Deleting obsolete relationships between academic entities
- Pruning outdated notes or observations that are no longer relevant
- Correcting errors in your academic knowledge graph
- Cleaning up test or practice entities
- Maintaining graph accuracy as your educational focus changes
- Removing duplicate learning materials or resources
- Archiving completed assignments or exams
- Updating status or priority relations when they change
- Modifying entity sequences
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
- Clear error messages when operations fail
Parameters explained:
- type: The deletion operation type to perform, which must be one of:
* "entities" - Remove academic 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
Status and Priority Management:
- To change an entity's status, delete the old has_status relation and create a new one
- To change priority, delete the old has_priority relation and create a new one
- Status values (not_started, in_progress, complete) are managed through relations, not direct properties
- Priority values (low, high) are managed through relations, not direct properties
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 of your academic knowledge
- Relations require entities on both ends to exist
- Deleting status or priority relations without replacing them can lead to inconsistent state
- Consider creating new status/priority relations before deleting old ones
You should:
1. Identify the specific elements in your academic graph that need to be removed
2. Choose the appropriate deletion type (entities, relations, or observations)
3. Structure your data according to the deletion type's requirements
4. Start with more specific deletions (observations) before broader ones
5. Verify the entities or relations exist before attempting deletion
6. When updating status, create a new has_status relation before deleting the old one
7. When updating priority, create a new has_priority relation before deleting the old one
8. Consider the impact on entity sequences when deleting follows relations
9. Check the operation result to confirm successful deletion
10. Consider documenting major deletions as observations on related entities
11. When removing an entire course, first delete its components for cleaner removal
```
--------------------------------------------------------------------------------
/developer/developer_advancedcontext.txt:
--------------------------------------------------------------------------------
```
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:
1. Select the most appropriate query type for your information need
2. Provide the required parameters for your chosen operation type
3. Start with broader queries and refine to more specific ones
4. Use "search" for exploratory investigation when entity names are unknown
5. Use "related" to explore the neighborhood of a known entity
6. Use "decisions" to understand the rationale behind project changes
7. Use "milestone" to evaluate project progress and identify blockers
8. Analyze task sequencing to understand dependencies and critical paths
9. Filter entities by status to focus on active, inactive, or completed items
10. Consider entity priorities when planning work or resolving issues
11. Combine query results to build comprehensive understanding
```
--------------------------------------------------------------------------------
/main/descriptions/developer_advancedcontext.txt:
--------------------------------------------------------------------------------
```
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:
1. Select the most appropriate query type for your information need
2. Provide the required parameters for your chosen operation type
3. Start with broader queries and refine to more specific ones
4. Use "search" for exploratory investigation when entity names are unknown
5. Use "related" to explore the neighborhood of a known entity
6. Use "decisions" to understand the rationale behind project changes
7. Use "milestone" to evaluate project progress and identify blockers
8. Analyze task sequencing to understand dependencies and critical paths
9. Filter entities by status to focus on active, inactive, or completed items
10. Consider entity priorities when planning work or resolving issues
11. Combine query results to build comprehensive understanding
```
--------------------------------------------------------------------------------
/developer/developer_buildcontext.txt:
--------------------------------------------------------------------------------
```
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:
1. Specify the operation type based on what you need to create (entities, relations, or observations)
2. Structure your data according to the operation type's requirements
3. Use valid entity types and relation types from the software development domain
4. Ensure entities exist before creating relations between them
5. Provide meaningful names and descriptions for new entities
6. Use observations to add metadata about entities
7. Create complete structures rather than adding entities/relations piecemeal
8. For task sequencing, use the 'precedes' relation to define which tasks must be completed before others
9. Set status values using the has_status relation (valid values: inactive, active, complete)
10. Set priority values using the has_priority relation (valid values: low, high)
```
--------------------------------------------------------------------------------
/main/descriptions/developer_buildcontext.txt:
--------------------------------------------------------------------------------
```
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:
1. Specify the operation type based on what you need to create (entities, relations, or observations)
2. Structure your data according to the operation type's requirements
3. Use valid entity types and relation types from the software development domain
4. Ensure entities exist before creating relations between them
5. Provide meaningful names and descriptions for new entities
6. Use observations to add metadata about entities
7. Create complete structures rather than adding entities/relations piecemeal
8. For task sequencing, use the 'precedes' relation to define which tasks must be completed before others
9. Set status values using the has_status relation (valid values: inactive, active, complete)
10. Set priority values using the has_priority relation (valid values: low, high)
```
--------------------------------------------------------------------------------
/main/descriptions/student_buildcontext.txt:
--------------------------------------------------------------------------------
```
A flexible tool for constructing and enhancing your educational knowledge graph.
This tool allows you to add new academic entities, create relationships between educational components, or add observations to existing study materials.
Each operation type serves a specific purpose in building a comprehensive representation of your academic journey.
When to use this tool:
- Creating new educational entities like courses, assignments, and exams
- Establishing relationships between academic entities (e.g., assignment is part of a course)
- Documenting observations about your academic materials
- Building a connected graph of your educational experience
- Organizing your study resources and materials
- Tracking relationships between concepts and learning materials
- Recording course-specific details like schedules and due dates
- Creating structured representations of your academic knowledge
- Setting status values for educational entities
- Assigning priority to assignments and tasks
Key features:
- Three distinct operation types (entities, relations, observations)
- Type validation against academic domain standards
- Automatic rejection of invalid entity or relation types
- Safe addition of new observations to existing academic entities
- Status and priority assignment through entity-relation model
- 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 academic 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:
- course - Academic courses you're taking
- assignment - Homework, projects, and other submitted work
- exam - Tests, quizzes, and other assessments
- concept - Knowledge topics and learning objectives
- resource - Textbooks, articles, videos, and other learning materials
- note - Personal study notes and observations
- lecture - Individual class sessions
- project - Larger educational projects
- question - Specific questions for study or review
- term - Academic terms or semesters
- goal - Learning objectives and targets
- professor - Course instructors and teachers
- status - Entity status (not_started, in_progress, complete)
- priority - Entity priority (low, high)
Relation Types include:
- enrolled_in - Student is taking a course
- assigned_in - Assignment is part of a course
- due_on - Assignment/exam has specific due date
- covers - Lecture/resource covers concept
- references - Note references concept
- prerequisite_for - Concept is foundation for another
- taught_by - Course taught by professor
- scheduled_for - Lecture/exam scheduled for specific time
- contains - Course contains lectures/assignments
- has_status - Links entity to its status (not_started, in_progress, complete)
- has_priority - Links entity to its priority (low, high)
- follows - Entity follows another in a sequence
Status Values:
- not_started - Work on the entity has not begun
- in_progress - Work is actively underway
- complete - Work has been finished
Priority Values:
- low - Lower priority item
- high - Higher priority item
You should:
1. Specify the operation type based on what you need to create (entities, relations, or observations)
2. Structure your data according to the operation type's requirements
3. Use valid entity types and relation types from the academic domain
4. Ensure entities exist before creating relations between them
5. Provide meaningful names and descriptions for new entities
6. Use observations to add general metadata about entities
7. Use has_status relations to track progress (not_started, in_progress, complete)
8. Use has_priority relations to indicate importance (low, high)
9. Use follows relations to establish sequences between related entities
10. Create complete structures rather than adding entities/relations piecemeal
11. Check the operation result to confirm successful creation
```
--------------------------------------------------------------------------------
/student/student_buildcontext.txt:
--------------------------------------------------------------------------------
```
A flexible tool for constructing and enhancing your educational knowledge graph.
This tool allows you to add new academic entities, create relationships between educational components, or add observations to existing study materials.
Each operation type serves a specific purpose in building a comprehensive representation of your academic journey.
When to use this tool:
- Creating new educational entities like courses, assignments, and exams
- Establishing relationships between academic entities (e.g., assignment is part of a course)
- Documenting observations about your academic materials
- Building a connected graph of your educational experience
- Organizing your study resources and materials
- Tracking relationships between concepts and learning materials
- Recording course-specific details like schedules and due dates
- Creating structured representations of your academic knowledge
- Setting status values for educational entities
- Assigning priority to assignments and tasks
Key features:
- Three distinct operation types (entities, relations, observations)
- Type validation against academic domain standards
- Automatic rejection of invalid entity or relation types
- Safe addition of new observations to existing academic entities
- Status and priority assignment through entity-relation model
- 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 academic 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:
- course - Academic courses you're taking
- assignment - Homework, projects, and other submitted work
- exam - Tests, quizzes, and other assessments
- concept - Knowledge topics and learning objectives
- resource - Textbooks, articles, videos, and other learning materials
- note - Personal study notes and observations
- lecture - Individual class sessions
- project - Larger educational projects
- question - Specific questions for study or review
- term - Academic terms or semesters
- goal - Learning objectives and targets
- professor - Course instructors and teachers
- status - Entity status (not_started, in_progress, complete)
- priority - Entity priority (low, high)
Relation Types include:
- enrolled_in - Student is taking a course
- assigned_in - Assignment is part of a course
- due_on - Assignment/exam has specific due date
- covers - Lecture/resource covers concept
- references - Note references concept
- prerequisite_for - Concept is foundation for another
- taught_by - Course taught by professor
- scheduled_for - Lecture/exam scheduled for specific time
- contains - Course contains lectures/assignments
- has_status - Links entity to its status (not_started, in_progress, complete)
- has_priority - Links entity to its priority (low, high)
- follows - Entity follows another in a sequence
Status Values:
- not_started - Work on the entity has not begun
- in_progress - Work is actively underway
- complete - Work has been finished
Priority Values:
- low - Lower priority item
- high - Higher priority item
You should:
1. Specify the operation type based on what you need to create (entities, relations, or observations)
2. Structure your data according to the operation type's requirements
3. Use valid entity types and relation types from the academic domain
4. Ensure entities exist before creating relations between them
5. Provide meaningful names and descriptions for new entities
6. Use observations to add general metadata about entities
7. Use has_status relations to track progress (not_started, in_progress, complete)
8. Use has_priority relations to indicate importance (low, high)
9. Use follows relations to establish sequences between related entities
10. Create complete structures rather than adding entities/relations piecemeal
11. Check the operation result to confirm successful creation
```
--------------------------------------------------------------------------------
/main/descriptions/common_buildcontext.txt:
--------------------------------------------------------------------------------
```
Build Context Tool
A versatile tool for constructing and enhancing domain-specific knowledge graphs through creation operations.
This tool allows you to add new entities, create relationships between entities, or add observations to existing entities.
Each operation type serves a specific purpose in building a comprehensive contextual model.
When to use this tool:
- Creating new entities specific to your domain (projects, tasks, courses, datasets, etc.)
- Establishing relationships between entities (e.g., dependencies, assignments, hierarchies)
- Adding observations, properties, or metadata to existing entities
- Building a connected graph of domain-specific elements
- Recording new information as it becomes available
- Tracking structure, dependencies, and status information
Key features:
- Three distinct operation types (entities, relations, observations)
- Type validation against domain-specific 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 domain-specific 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[] }
Valid entity types by domain:
- Developer:
* project, component, feature, issue, task, developer, technology, decision, milestone, environment, documentation, requirement
- Student:
* course, assignment, exam, concept, resource, note, lecture, project, question, term, goal, professor
- Qualitative Research:
* project, participant, interview, observation, document, code, codeGroup, memo, theme, quote, literature, researchQuestion, finding
- Quantitative Research:
* project, dataset, variable, hypothesis, statisticalTest, result, analysisScript, visualization, model, literature, researchQuestion, finding, participant
- Project Management:
* project, task, milestone, teamMember, risk, decision, resource, issue, dependency, meeting, document, stakeholder
Valid relation types by domain:
- Developer:
* depends_on, implements, assigned_to, blocked_by, uses, part_of, contains, works_on
- Student:
* enrolled_in, assigned_in, due_on, covers, references, prerequisite_for, taught_by, scheduled_for, contains
- Qualitative Research:
* part_of, contains, participates_in, codes, groups, references, supports, contradicts, emerges_from, relates_to, precedes, follows, associated_with
- Quantitative Research:
* correlates_with, predicts, tests, analyzes, produces, visualizes, contains, part_of, depends_on, supports, contradicts, derived_from, controls_for, moderates, mediates, implements, compares, includes, validates, cites
- Project Management:
* part_of, depends_on, assigned_to, responsible_for, created_by, leads_to, blocks, reports_to, collaborates_with, decides_on, impacts
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 "added" field (for observations)
- For failed operations:
* Success flag set to false
* Error message describing the issue
Error handling:
- Validates entity types against the predefined list for the specific domain
- Validates relation types against domain-specific standards
- Returns descriptive error messages for invalid inputs
- Gracefully handles type mismatches and formatting errors
You should:
1. Specify the operation type based on what you need to create (entities, relations, or observations)
2. Structure your data according to the operation type's requirements
3. Use valid entity types and relation types from your specific domain
4. Ensure entities exist before creating relations between them
5. Provide meaningful names and descriptions for new entities
6. Create complete structures rather than adding entities/relations piecemeal
7. Check the operation result to confirm successful creation
```
--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_startsession.txt:
--------------------------------------------------------------------------------
```
A comprehensive tool for initializing a new qualitative research session, providing structured information about ongoing research projects, participants, analytical elements, and recent research activities.
When to use this tool:
- Beginning a new research analysis session
- Getting oriented to your current research state across multiple projects
- Planning which research elements to focus on in the current session
- Reviewing recent research activities and progress
- Identifying active research projects and their status
- Exploring available participants for analysis
- Reviewing your most frequently used codes
- Accessing recent analytical memos
- Establishing research context before diving into specific analysis tasks
- Re-engaging with your research after time away
- Prioritizing high-priority research tasks
- Tracking the status of various research activities
- Understanding sequential research processes
Key features:
- Generates a unique session identifier for tracking research activities
- Retrieves and displays recent research sessions with summaries
- Lists active research projects with status and phase information
- Provides a sample of research participants with demographic information
- Presents your most frequently used codes with reference counts
- Highlights recent analytical memos with type and summary information
- Formats information in an easily scannable format for quick orientation
- Integrates with the loadcontext tool for deeper exploration
- Maintains continuity between research sessions
- Tracks research session history for progress review
- Displays high-priority research tasks needing attention
- Shows status information for key research activities
- Presents sequential relationships between research processes
Parameters explained:
No parameters required - the tool automatically retrieves all relevant context.
Return information:
- A unique session identifier
- Recent research sessions (up to 3) with:
* Date
* Project name
* Brief summary
- Active research projects with:
* Project name
* Current status
* Research phase
- Sample participants (up to 5) with:
* Participant name
* Demographic information
* Participation status
- Top codes (up to 10) with:
* Code name
* Reference count
* Code group
- Recent memos (up to 3) with:
* Memo name
* Creation date
* Memo type
* Brief summary
- High-priority research tasks (up to 5) with:
* Task name
* Current status
* Associated project
- Upcoming research activities (up to 3) with:
* Activity name
* Scheduled date
* Prerequisite activities
* Current status
Status and Priority Information:
- Research activities are displayed with their current status values
- High-priority tasks are prominently highlighted for attention
- Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Priority values (high, low) help indicate which tasks need immediate attention
Sequential Process Information:
- Upcoming activities show prerequisite tasks that must be completed first
- Research phases are presented in their logical sequence
- The precedes relation is used to determine activity ordering
- Sequential relationships help visualize the research workflow
Session Workflow:
1. Start a research session with startsession
2. Review the provided context to decide what to focus on
3. Use loadcontext to retrieve detailed information about specific research elements
4. Conduct your analysis, adding new elements with buildcontext as needed
5. End the session with endsession to record your research progress
You should:
- Begin each focused research period with startsession to establish context
- Review recent sessions to maintain continuity in your research
- Identify active projects that require attention
- Note available participants for interview analysis
- Consider frequently used codes that may indicate important patterns
- Review recent memos to reconnect with your analytical thinking
- Prioritize high-priority tasks for immediate attention
- Check the status of research activities to maintain progress awareness
- Consider sequential relationships when planning your research activities
- Use the session ID when using other tools to maintain session tracking
- After completing a session, record your progress using endsession
- Establish a regular cadence of research sessions to maintain momentum
- Use the structured overview to make deliberate choices about where to focus your analytical effort
```
--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_startsession.txt:
--------------------------------------------------------------------------------
```
A comprehensive tool for initializing a new qualitative research session, providing structured information about ongoing research projects, participants, analytical elements, and recent research activities.
When to use this tool:
- Beginning a new research analysis session
- Getting oriented to your current research state across multiple projects
- Planning which research elements to focus on in the current session
- Reviewing recent research activities and progress
- Identifying active research projects and their status
- Exploring available participants for analysis
- Reviewing your most frequently used codes
- Accessing recent analytical memos
- Establishing research context before diving into specific analysis tasks
- Re-engaging with your research after time away
- Prioritizing high-priority research tasks
- Tracking the status of various research activities
- Understanding sequential research processes
Key features:
- Generates a unique session identifier for tracking research activities
- Retrieves and displays recent research sessions with summaries
- Lists active research projects with status and phase information
- Provides a sample of research participants with demographic information
- Presents your most frequently used codes with reference counts
- Highlights recent analytical memos with type and summary information
- Formats information in an easily scannable format for quick orientation
- Integrates with the loadcontext tool for deeper exploration
- Maintains continuity between research sessions
- Tracks research session history for progress review
- Displays high-priority research tasks needing attention
- Shows status information for key research activities
- Presents sequential relationships between research processes
Parameters explained:
No parameters required - the tool automatically retrieves all relevant context.
Return information:
- A unique session identifier
- Recent research sessions (up to 3) with:
* Date
* Project name
* Brief summary
- Active research projects with:
* Project name
* Current status
* Research phase
- Sample participants (up to 5) with:
* Participant name
* Demographic information
* Participation status
- Top codes (up to 10) with:
* Code name
* Reference count
* Code group
- Recent memos (up to 3) with:
* Memo name
* Creation date
* Memo type
* Brief summary
- High-priority research tasks (up to 5) with:
* Task name
* Current status
* Associated project
- Upcoming research activities (up to 3) with:
* Activity name
* Scheduled date
* Prerequisite activities
* Current status
Status and Priority Information:
- Research activities are displayed with their current status values
- High-priority tasks are prominently highlighted for attention
- Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Priority values (high, low) help indicate which tasks need immediate attention
Sequential Process Information:
- Upcoming activities show prerequisite tasks that must be completed first
- Research phases are presented in their logical sequence
- The precedes relation is used to determine activity ordering
- Sequential relationships help visualize the research workflow
Session Workflow:
1. Start a research session with startsession
2. Review the provided context to decide what to focus on
3. Use loadcontext to retrieve detailed information about specific research elements
4. Conduct your analysis, adding new elements with buildcontext as needed
5. End the session with endsession to record your research progress
You should:
- Begin each focused research period with startsession to establish context
- Review recent sessions to maintain continuity in your research
- Identify active projects that require attention
- Note available participants for interview analysis
- Consider frequently used codes that may indicate important patterns
- Review recent memos to reconnect with your analytical thinking
- Prioritize high-priority tasks for immediate attention
- Check the status of research activities to maintain progress awareness
- Consider sequential relationships when planning your research activities
- Use the session ID when using other tools to maintain session tracking
- After completing a session, record your progress using endsession
- Establish a regular cadence of research sessions to maintain momentum
- Use the structured overview to make deliberate choices about where to focus your analytical effort
```
--------------------------------------------------------------------------------
/developer/developer_endsession.txt:
--------------------------------------------------------------------------------
```
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:
1. Summary Stage: Records basic session information
2. Achievements Stage: Documents specific accomplishments
3. Task Updates Stage: Records status and priority changes to existing tasks
4. New Tasks Stage: Defines new tasks created during the session
5. Project Status Stage: Updates the overall project status
6. 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
```
--------------------------------------------------------------------------------
/main/descriptions/developer_endsession.txt:
--------------------------------------------------------------------------------
```
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:
1. Summary Stage: Records basic session information
2. Achievements Stage: Documents specific accomplishments
3. Task Updates Stage: Records status and priority changes to existing tasks
4. New Tasks Stage: Defines new tasks created during the session
5. Project Status Stage: Updates the overall project status
6. 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
```
--------------------------------------------------------------------------------
/main/descriptions/project_startsession.txt:
--------------------------------------------------------------------------------
```
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:
1. Start a project management session with startsession
2. Review the provided context to decide what to focus on
3. Use loadcontext to retrieve detailed information about specific projects
4. Conduct your project management work, adding new elements with buildcontext as needed
5. End the session when work is complete
6. 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
```
--------------------------------------------------------------------------------
/project/project_startsession.txt:
--------------------------------------------------------------------------------
```
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:
1. Start a project management session with startsession
2. Review the provided context to decide what to focus on
3. Use loadcontext to retrieve detailed information about specific projects
4. Conduct your project management work, adding new elements with buildcontext as needed
5. End the session when work is complete
6. 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
```
--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_startsession.txt:
--------------------------------------------------------------------------------
```
A comprehensive tool for initializing a new quantitative research session, providing structured information about ongoing research projects, datasets, statistical models, and recent research activities.
When to use this tool:
- Beginning a new quantitative analysis session
- Getting oriented to your current research state across multiple projects
- Planning which research elements to focus on in the current session
- Reviewing recent research activities and progress
- Identifying active research projects and their status
- Exploring available datasets for analysis
- Reviewing current research questions
- Examining statistical models and their performance
- Viewing recent visualizations of your data
- Establishing research context before diving into specific analysis tasks
- Re-engaging with your research after time away
- Prioritizing high-priority research tasks
- Tracking the status of various research activities
- Understanding sequential research processes
Key features:
- Generates a unique session identifier for tracking research activities
- Retrieves and displays recent research sessions with summaries
- Lists active research projects with status information
- Provides a sample of available datasets with key information
- Presents current research questions guiding your studies
- Highlights recent statistical models with performance metrics
- Displays recent visualizations with brief descriptions
- Formats information in an easily scannable format for quick orientation
- Integrates with the loadcontext tool for deeper exploration
- Maintains continuity between research sessions
- Tracks research session history for progress review
- Displays high-priority research tasks needing attention
- Shows status information for key research activities
- Presents sequential relationships between research processes
Parameters explained:
No parameters required - the tool automatically retrieves all relevant context.
Return information:
- Recent research sessions (up to 3) with:
- Date
- Project name
- Brief summary
- Active research projects with:
- Project name
- Current status (via has_status relation)
- Priority (if assigned via has_priority relation)
- Available datasets (up to 5) with:
- Dataset name
- Type of data
- Associated project
- Status (active, completed, pending, abandoned)
- Research questions (up to 5) with:
- Question text
- Associated project
- Status (via has_status relation)
- Recent statistical models with:
- Model name
- Model type
- Performance metrics
- Status (via has_status relation)
- Recent visualizations with:
- Visualization name
- Type (chart, plot, etc.)
- Associated dataset
- High-priority research tasks (up to 5) with:
- Task name
- Current status (active, completed, pending, abandoned)
- Associated project
- Upcoming research activities (up to 3) with:
- Activity name
- Prerequisite activities (via precedes relation)
- Current status (via has_status relation)
Status and Priority Information:
- Research activities are displayed with their current status values
- High-priority tasks are prominently highlighted for attention
- Valid status values include: active, completed, pending, abandoned
- Priority values (high, low) help indicate which tasks need immediate attention
- Status is retrieved through has_status relations
- Priority is retrieved through has_priority relations
Sequential Process Information:
- Upcoming activities show prerequisite tasks that must be completed first
- Research phases are presented in their logical sequence
- The precedes relation is used to determine activity ordering
- Sequential relationships help visualize the research workflow
Session Workflow:
1. Start a research session with startsession
2. Review the provided context to decide what to focus on
3. Use loadcontext to retrieve detailed information about specific research elements
4. Conduct your analysis, adding new elements with buildcontext as needed
5. End the session with endsession to record your research progress
You should:
- Begin each focused research period with startsession to establish context
- Review recent sessions to maintain continuity in your research
- Identify active projects that require attention
- Note available datasets for potential analysis
- Consider current research questions that need investigation
- Review existing statistical models before creating new ones
- Examine recent visualizations to understand data representation
- Prioritize high-priority tasks for immediate attention
- Check the status of research activities to maintain progress awareness
- Consider sequential relationships when planning your research activities
- Use the session ID when using other tools to maintain session tracking
- After completing a session, record your progress using endsession
- Establish a regular cadence of research sessions to maintain momentum
- Use the structured overview to make deliberate choices about where to focus your analytical effort
```