This is page 1 of 13. Use http://codebase.md/tejpalvirk/contextmanager?lines=true&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:
--------------------------------------------------------------------------------
```
1 | *.ts linguist-language=TypeScript
2 | *.js linguist-generated=true
```
--------------------------------------------------------------------------------
/developer/.gitattributes:
--------------------------------------------------------------------------------
```
1 | *.ts linguist-language=TypeScript
2 | *.js linguist-generated=true
```
--------------------------------------------------------------------------------
/project/.gitattributes:
--------------------------------------------------------------------------------
```
1 | *.ts linguist-language=TypeScript
2 | *.js linguist-generated=true
```
--------------------------------------------------------------------------------
/qualitativeresearch/.gitattributes:
--------------------------------------------------------------------------------
```
1 | *.ts linguist-language=TypeScript
2 | *.js linguist-generated=true
```
--------------------------------------------------------------------------------
/quantitativeresearch/.gitattributes:
--------------------------------------------------------------------------------
```
1 | *.ts linguist-language=TypeScript
2 | *.js linguist-generated=true
```
--------------------------------------------------------------------------------
/student/.gitattributes:
--------------------------------------------------------------------------------
```
1 | *.ts linguist-language=TypeScript
2 | *.js linguist-generated=true
```
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
```
1 | # Directories
2 | backup/
3 | backup_built/
4 | backup_domains/
5 | docs/
6 | tests/
7 | node_modules/
8 | coverage/
9 | .vscode/
10 | .idea/
11 | .DS_Store
12 | *.py
13 |
14 | # Logs
15 | logs
16 | *.log
17 | npm-debug.log*
18 | yarn-debug.log*
19 | yarn-error.log*
20 | lerna-debug.log*
21 |
22 | # Diagnostic reports
23 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
24 |
25 | # Runtime data
26 | pids
27 | *.pid
28 | *.seed
29 | *.pid.lock
30 |
31 | # Environment variables
32 | .env
33 | .env.local
34 | .env.development.local
35 | .env.test.local
36 | .env.production.local
37 |
38 | # Build artifacts
39 | *.js.map
40 | *.tsbuildinfo
41 | **/*.js.map
42 |
43 | # Tests
44 | /tests
45 | /coverage
46 |
47 | # Documentation
48 | /docs
49 |
50 | # Temporary files
51 | .tmp/
52 | .temp/
```
--------------------------------------------------------------------------------
/main/README.md:
--------------------------------------------------------------------------------
```markdown
1 | # MCP Context Manager
2 |
3 | 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.
4 |
5 | ## Features
6 |
7 | - **Domain Management**: Set and switch between different context domains (developer, project, student, etc.)
8 | - **Session Management**: Create and manage sessions for different domains
9 | - **Context Operations**: Build, load, and manipulate context for different entity types
10 | - **Cross-Domain Support**: Work with multiple knowledge domains through a single interface, including creating relationships between entities in different domains
11 | - **Domain Discovery**: Explore available domains and their entity types
12 | - **Direct Integration**: Communicates directly with domain-specific MCP servers
13 |
14 | ## Implementation
15 |
16 | The Context Manager uses the MCP Client SDK to communicate with domain-specific MCP servers. It:
17 |
18 | 1. Maintains a registry of domain servers with their connection information
19 | 2. Creates MCP clients to connect to each domain server
20 | 3. Routes requests to the appropriate domain server based on the active domain
21 | 4. Provides cross-domain functionality for relating entities across domains
22 |
23 | ## Path Resolution
24 |
25 | The Context Manager uses absolute paths constructed at runtime to locate domain servers. This approach:
26 |
27 | - Ensures consistent path resolution regardless of the current working directory
28 | - Makes the code portable and sharable on GitHub
29 | - Uses Node.js's `path.resolve()` with `import.meta.url` to create absolute paths relative to the context manager's location
30 |
31 | If you need to modify paths to domain servers, update the `domains` array in `main/index.ts`.
32 |
33 | ## Available Domains
34 |
35 | The context manager provides access to the following domains:
36 |
37 | 1. **Developer Domain**: Software development context with entities like projects, components, and tasks
38 | 2. **Project Domain**: Project management context with entities like projects, tasks, and resources
39 | 3. **Student Domain**: Educational context with entities like courses, assignments, and exams
40 | 4. **Qualitative Research Domain**: Qualitative research context with entities like studies, participants, and interviews
41 | 5. **Quantitative Research Domain**: Quantitative research context with entities like datasets, variables, and analyses
42 |
43 | ## Usage
44 |
45 | ### Starting the Server
46 |
47 | ```bash
48 | npm install
49 | npm run build
50 | npm start
51 | ```
52 |
53 | ### Command-Line Arguments
54 |
55 | The Context Manager accepts the following command-line arguments:
56 |
57 | ```bash
58 | # Run on a specific port (default: 3000)
59 | npm start -- --port 3001
60 |
61 | # Enable debug logging
62 | npm start -- --debug
63 |
64 | # Specify a config file
65 | npm start -- --config ./my-config.json
66 |
67 | # Run only specific domain servers
68 | npm start -- --domains developer,project
69 | ```
70 |
71 | ### Domain Management
72 |
73 | Use the `setActiveDomain` tool to select which domain you want to work with:
74 |
75 | ```
76 | setActiveDomain(domain="developer")
77 | ```
78 |
79 | ### Session Management
80 |
81 | Start a new session for the active domain:
82 |
83 | ```
84 | startsession(domain="developer")
85 | ```
86 |
87 | End a session when you're done:
88 |
89 | ```
90 | endsession(sessionId="session_id_here", stage="completed", stageNumber=1, totalStages=1, nextStageNeeded=false)
91 | ```
92 |
93 | ### Context Operations
94 |
95 | Build context for the active domain:
96 |
97 | ```
98 | buildcontext(type="entities", data={...})
99 | ```
100 |
101 | Load context for a specific entity:
102 |
103 | ```
104 | loadcontext(entityName="MyProject", entityType="project")
105 | ```
106 |
107 | Delete context:
108 |
109 | ```
110 | deletecontext(type="entities", data={...})
111 | ```
112 |
113 | ### Cross-Domain Operations
114 |
115 | Create relationships between entities in different domains:
116 |
117 | ```
118 | relateCrossDomain(fromDomain="developer", fromEntity="ProjectX", toDomain="project", toEntity="ProjectX", relationType="manages")
119 | ```
120 |
121 | ## Troubleshooting
122 |
123 | ### Common Issues
124 |
125 | 1. **Path Resolution Errors**:
126 | ```
127 | Error: Cannot find module '...'
128 | ```
129 | Solution: Ensure all paths in the `domains` array in `main/index.ts` are correctly specified.
130 |
131 | 2. **Connection to Domain Server Failed**:
132 | ```
133 | Error: Failed to connect to domain server: 'developer'
134 | ```
135 | Solution: Check that the domain server is running and accessible.
136 |
137 | 3. **Method Not Found**:
138 | ```
139 | Error: Method 'buildcontext' not found in domain 'developer'
140 | ```
141 | Solution: Verify the method name and ensure it is supported by the domain server.
142 |
143 | ## Architecture
144 |
145 | The Context Manager is a proxy that:
146 |
147 | 1. Receives MCP protocol messages from clients
148 | 2. Routes these messages to the appropriate domain server
149 | 3. Returns responses back to the client
150 |
151 | Each domain server runs as a separate process, and the Context Manager communicates with them using the MCP protocol.
152 |
153 | ## Versioning
154 |
155 | This package follows [Semantic Versioning](https://semver.org/):
156 |
157 | - **MAJOR**: Incompatible API changes
158 | - **MINOR**: Backwards-compatible functionality additions
159 | - **PATCH**: Backwards-compatible bug fixes
160 |
161 | Current version: 1.0.0
162 |
163 | ## Contributing
164 |
165 | Contributions are welcome! Please follow these steps:
166 |
167 | 1. Fork the repository
168 | 2. Create a feature branch (`git checkout -b feature/amazing-feature`)
169 | 3. Commit your changes (`git commit -m 'Add some amazing feature'`)
170 | 4. Push to the branch (`git push origin feature/amazing-feature`)
171 | 5. Open a Pull Request
172 |
173 | ### Coding Standards
174 |
175 | - Use TypeScript for all new code
176 | - Follow the existing code style
177 | - Add tests for new functionality
178 | - Update documentation as needed
179 |
180 | ## Development
181 |
182 | To extend the Context Manager with new domains or functionality:
183 |
184 | 1. Add the new domain to the `domains` array in `main/index.ts`
185 | 2. Specify the connection information for the domain server
186 | 3. Update tests and documentation
187 |
188 | ## License
189 |
190 | MIT
```
--------------------------------------------------------------------------------
/project/README.md:
--------------------------------------------------------------------------------
```markdown
1 | # Project MCP Server
2 |
3 | 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.
4 |
5 | ## Features
6 |
7 | - **Persistent Project Context**: Maintain a structured knowledge graph of project entities and relationships across multiple sessions
8 | - **Session Management**: Track project management sessions with unique IDs and record progress over time
9 | - **Project Status Tracking**: Monitor project health, risks, and issue status in real time
10 | - **Task Dependencies**: Visualize and manage dependencies between tasks to identify bottlenecks
11 | - **Milestone Progress**: Track progress towards key project milestones
12 | - **Resource Allocation**: Monitor how resources are distributed across projects and tasks
13 | - **Risk Assessment**: Identify, monitor, and mitigate project risks
14 | - **Decision Logging**: Record important project decisions and their context
15 | - **Team Member Management**: Track assignments and workloads for team members
16 | - **Project Timeline Analysis**: Analyze project timelines including critical paths
17 |
18 | ## Entities
19 |
20 | The Project MCP Server recognizes the following entity types:
21 |
22 | - **project**: The main container for all related entities
23 | - **task**: Individual work items that need to be completed
24 | - **milestone**: Key checkpoints or deliverables in the project
25 | - **resource**: Materials, tools, or assets needed for the project
26 | - **teamMember**: People involved in the project
27 | - **note**: Documentation, ideas, or observations
28 | - **document**: Formal project documents
29 | - **issue**: Problems or blockers
30 | - **risk**: Potential future problems
31 | - **decision**: Important choices made during the project
32 | - **dependency**: External requirements or prerequisites
33 | - **component**: Parts or modules of the project
34 | - **stakeholder**: People affected by or interested in the project
35 | - **change**: Modifications to project scope or requirements
36 | - **status**: Entity status values (inactive, active, complete)
37 | - **priority**: Priority level values (high, low)
38 |
39 | ## Relationships
40 |
41 | Entities can be connected through the following relationship types:
42 |
43 | - **part_of**: Indicates an entity is a component/subset of another
44 | - **depends_on**: Shows dependencies between entities
45 | - **assigned_to**: Links tasks to team members
46 | - **created_by**: Tracks who created an entity
47 | - **modified_by**: Records who changed an entity
48 | - **related_to**: Shows general connections between entities
49 | - **blocks**: Indicates one entity is blocking another
50 | - **manages**: Shows management relationships
51 | - **contributes_to**: Shows contributions to entities
52 | - **documents**: Links documentation to entities
53 | - **scheduled_for**: Connects entities to dates or timeframes
54 | - **responsible_for**: Assigns ownership/responsibility
55 | - **reports_to**: Indicates reporting relationships
56 | - **categorized_as**: Links entities to categories or types
57 | - **required_for**: Shows requirements for completion
58 | - **discovered_in**: Links issues to their discovery context
59 | - **resolved_by**: Shows what resolved an issue
60 | - **impacted_by**: Shows impact relationships
61 | - **stakeholder_of**: Links stakeholders to projects/components
62 | - **prioritized_as**: Indicates priority levels
63 | - **has_status**: Links entities to their current status (inactive, active, complete)
64 | - **has_priority**: Links entities to their priority level (high, low)
65 | - **precedes**: Indicates that one task comes before another in a sequence
66 |
67 | ## Available Tools
68 |
69 | The Project MCP Server provides these tools for interacting with project knowledge:
70 |
71 | ### startsession
72 | 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.
73 |
74 | ### loadcontext
75 | 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.
76 |
77 | ### endsession
78 | Records the results of a project management session through a structured, multi-stage process:
79 | 1. **summary**: Records session summary, duration, and project focus
80 | 2. **achievements**: Documents key achievements from the session
81 | 3. **taskUpdates**: Tracks updates to existing tasks
82 | 4. **newTasks**: Records new tasks created during the session
83 | 5. **statusUpdates**: Records changes to entity status values
84 | 6. **projectStatus**: Updates overall project status, priority assignments, and sequential relationships
85 | 7. **assembly**: Final assembly of all session data
86 |
87 | ### buildcontext
88 | Creates new entities, relations, or observations in the knowledge graph:
89 | - **entities**: Add new project-related entities (projects, tasks, milestones, status, priority, etc.)
90 | - **relations**: Create relationships between entities (including has_status, has_priority, precedes)
91 | - **observations**: Add observations to existing entities
92 |
93 | ### deletecontext
94 | Removes entities, relations, or observations from the knowledge graph:
95 | - **entities**: Remove project entities
96 | - **relations**: Remove relationships between entities (including status, priority, and sequential relations)
97 | - **observations**: Remove specific observations from entities
98 |
99 | ### advancedcontext
100 | Retrieves information from the knowledge graph:
101 | - **graph**: Get the entire knowledge graph
102 | - **search**: Search for nodes based on query criteria
103 | - **nodes**: Get specific nodes by name
104 | - **related**: Find related entities
105 | - **status**: Find entities with a specific status value (inactive, active, complete)
106 | - **priority**: Find entities with a specific priority value (high, low)
107 | - **sequence**: Identify sequential relationships for tasks
108 |
109 | ## Domain-Specific Functions
110 |
111 | The Project MCP Server includes specialized domain functions for project management:
112 |
113 | - **getProjectOverview**: Comprehensive view of a project including tasks, milestones, team members, issues, etc.
114 | - **getTaskDependencies**: Analyze task dependencies to identify blocked tasks and critical paths
115 | - **getTeamMemberAssignments**: View all assignments for a specific team member
116 | - **getMilestoneProgress**: Track progress towards project milestones
117 | - **getProjectTimeline**: Analyze project timeline and key dates
118 | - **getResourceAllocation**: Examine how resources are allocated across the project
119 | - **getProjectRisks**: Identify and assess project risks
120 | - **findRelatedProjects**: Discover connections between different projects
121 | - **getDecisionLog**: Track decision history and context
122 | - **getProjectHealth**: Assess overall project health with metrics and recommendations
123 | - **getStatusOverview**: View all entities with a specific status (inactive, active, complete)
124 | - **getPriorityItems**: Identify high-priority tasks and activities
125 | - **getTaskSequence**: Visualize the sequence of tasks based on precedes relations
126 |
127 | ## Example Prompts
128 |
129 | ### Starting a Session
130 | ```
131 | Let's start a new project management session to review the Mobile App Development project.
132 | ```
133 |
134 | ### Loading Project Context
135 | ```
136 | Load the context for the Mobile App Development project so I can see its current status.
137 | ```
138 |
139 | ### Recording Session Results
140 | ```
141 | 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.
142 | ```
143 |
144 | ### Managing Project Knowledge
145 | ```
146 | 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.
147 | ```
148 |
149 | ```
150 | Update the status of the "Database Migration" task to "completed" and add an observation that it was finished ahead of schedule.
151 | ```
152 |
153 | ## Usage
154 |
155 | This MCP server enables project managers to:
156 |
157 | - **Maintain Context Continuity**: Keep track of project details across multiple planning sessions
158 | - **Onboard New Team Members**: Quickly get new team members up to speed on project status
159 | - **Record Session Results**: Document the outcomes of meetings and work sessions
160 | - **Track Dependencies**: Identify and manage critical dependencies and bottlenecks
161 | - **Monitor Risk**: Keep track of project risks and implement mitigation strategies
162 | - **Allocate Resources**: Optimize resource allocation across projects and tasks
163 | - **Make Informed Decisions**: Base decisions on comprehensive project data
164 | - **Track Progress**: Monitor entity status throughout the project lifecycle
165 | - **Prioritize Work**: Identify and focus on high-priority tasks
166 | - **Sequence Tasks**: Plan and visualize the logical order of project tasks
167 |
168 | ## Configuration
169 |
170 | ### Usage with Claude Desktop
171 |
172 | Add this to your `claude_desktop_config.json`:
173 |
174 | #### Install from GitHub and run with npx
175 |
176 | ```json
177 | {
178 | "mcpServers": {
179 | "project": {
180 | "command": "npx",
181 | "args": [
182 | "-y",
183 | "github:tejpalvirk/project"
184 | ]
185 | }
186 | }
187 | }
188 | ```
189 |
190 | #### Install globally and run directly
191 |
192 | First, install the package globally:
193 |
194 | ```bash
195 | npm install -g github:tejpalvirk/project
196 | ```
197 |
198 | Then configure Claude Desktop:
199 |
200 | ```json
201 | {
202 | "mcpServers": {
203 | "project": {
204 | "command": "contextmanager-project"
205 | }
206 | }
207 | }
208 | ```
209 |
210 | #### docker
211 |
212 | ```json
213 | {
214 | "mcpServers": {
215 | "project": {
216 | "command": "docker",
217 | "args": [
218 | "run",
219 | "--rm",
220 | "-i",
221 | "mcp/project"
222 | ]
223 | }
224 | }
225 | }
226 | ```
227 |
228 | ## Building
229 |
230 | ### From Source
231 |
232 | ```bash
233 | # Clone the repository
234 | git clone https://github.com/tejpalvirk/contextmanager.git
235 | cd contextmanager
236 |
237 | # Install dependencies
238 | npm install
239 |
240 | # Build the server
241 | npm run build
242 |
243 | # Run the server
244 | cd project
245 | node project_index.js
246 | ```
247 |
248 | ### Docker:
249 |
250 | ```bash
251 | docker build -t mcp/project -f project/Dockerfile .
252 | ```
253 |
254 | ## License
255 |
256 | 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.
257 |
258 | ## Environment Variables
259 |
260 | The Project MCP Server supports the following environment variables to customize where data is stored:
261 |
262 | - **MEMORY_FILE_PATH**: Path where the knowledge graph data will be stored
263 | - Can be absolute or relative (relative paths use current working directory)
264 | - Default: `./project/memory.json`
265 |
266 | - **SESSIONS_FILE_PATH**: Path where session data will be stored
267 | - Can be absolute or relative (relative paths use current working directory)
268 | - Default: `./project/sessions.json`
269 |
270 | Example usage:
271 |
272 | ```bash
273 | # Store data in the current directory
274 | MEMORY_FILE_PATH="./pm-memory.json" SESSIONS_FILE_PATH="./pm-sessions.json" npx github:tejpalvirk/contextmanager-project
275 |
276 | # Store data in a specific location (absolute path)
277 | MEMORY_FILE_PATH="/path/to/data/project-memory.json" npx github:tejpalvirk/contextmanager-project
278 |
279 | # Store data in user's home directory
280 | MEMORY_FILE_PATH="$HOME/contextmanager/project-memory.json" npx github:tejpalvirk/contextmanager-project
281 | ```
```
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
```markdown
1 | # MCP Context Manager
2 |
3 | A collection of Model Context Protocol (MCP) servers to enhance AI models with persistent context across work sessions throughout the project lifecycle.
4 |
5 | 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.
6 |
7 | Each domain server is also a standalone MCP Server that you can use on its own without the Context Manager.
8 |
9 | ## Features
10 |
11 | - **Persistent Context**: Easily `buildcontext`, `loadcontext`, and `deletecontext` as you progress from idea to production/publication/completion
12 | - **Efficienct Access**: Let AI models grab the exact context they need when they need it
13 | - **Session Management**:
14 | 1. `startsession` tool to get an overview of what you've been working on in past sessions
15 | 2. `endsession` tool to analyze the entire session and update knowledge graph for future sessions
16 | - **Cross-Domain Support**: Work with multiple knowledge domains through a single interface, including creating relationships between entities in different domains
17 |
18 | ## Why knowledge graphs?
19 |
20 | To free up the context window (performance), and minimize token cost (efficiency).
21 |
22 | ## Available Servers
23 |
24 | The contextmanager orchestrates several domain-specific MCP servers:
25 |
26 | 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.
27 |
28 | 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.
29 |
30 | 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.
31 |
32 | 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.
33 |
34 | 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.
35 |
36 | For detailed documentation on each domain server, see the README files in their respective directories:
37 | - [Developer Server](./developer/README.md)
38 | - [Project Server](./project/README.md)
39 | - [Student Server](./student/README.md)
40 | - [Qualitative Research Server](./qualitativeresearch/README.md)
41 | - [Quantitative Research Server](./quantitativeresearch/README.md)
42 |
43 | ## Context Manager Benefits
44 |
45 | The Context Manager provides:
46 |
47 | - **Unified Interface**: Access all domain servers through a single interface.
48 | - **Smart Routing**: Automatically routes requests to the appropriate domain server.
49 | - **Cross-Domain Context**: Maintains references across different domains.
50 | - **Consistent Status Management**: Standardized approach to status tracking across domains.
51 | - **Unified Priority System**: Consistent priority management across different contexts.
52 | - **Integrated Sequencing**: Harmonized approach to sequential workflows across domains.
53 |
54 | ## Implementation
55 |
56 | The Context Manager uses the MCP Client SDK to communicate with domain-specific MCP servers. It:
57 |
58 | 1. Maintains a registry of domain servers with their connection information
59 | 2. Creates MCP clients to connect to each domain server
60 | 3. Routes requests to the appropriate domain server based on the active domain
61 | 4. Provides cross-domain functionality for relating entities across domains
62 | 5. Ensures consistent handling of status, priority, and sequential relations
63 |
64 | ## Path Resolution
65 |
66 | 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`.
67 |
68 | ## Installation & Usage
69 |
70 | You can use the MCP Context Manager in several ways:
71 |
72 | ### Using npx (Recommended)
73 |
74 | Run directly with npx:
75 |
76 | ```bash
77 | npx github:tejpalvirk/contextmanager
78 | ```
79 |
80 | ### Global Installation
81 |
82 | Install globally to make all servers available as commands:
83 |
84 | ```bash
85 | npm install -g github:tejpalvirk/contextmanager
86 | ```
87 |
88 | Then run:
89 |
90 | ```bash
91 | mcp-server-contextmanager
92 | ```
93 |
94 | Or run a specific domain server directly:
95 |
96 | ```bash
97 | contextmanager-developer
98 | contextmanager-project
99 | contextmanager-student
100 | contextmanager-qualitativeresearch
101 | contextmanager-quantitativeresearch
102 | ```
103 |
104 | ### Clone and Build from Source
105 |
106 | For development or customization:
107 |
108 | ```bash
109 | git clone https://github.com/tejpalvirk/contextmanager.git
110 | cd contextmanager
111 | npm install
112 | npm run build
113 | ```
114 |
115 | Then run:
116 |
117 | ```bash
118 | node main/index.js
119 | ```
120 |
121 | ## Command-Line Arguments
122 |
123 | The Context Manager and domain servers accept the following command-line arguments:
124 |
125 | ```bash
126 | # Run on a specific port (default: 3000)
127 | npx github:tejpalvirk/contextmanager --port 3001
128 |
129 | # Enable debug logging
130 | npx github:tejpalvirk/contextmanager --debug
131 |
132 | # Specify a config file
133 | npx github:tejpalvirk/contextmanager --config ./my-config.json
134 |
135 | # Run only specific domain servers
136 | npx github:tejpalvirk/contextmanager --domains developer,project
137 | ```
138 |
139 | ## Environment Variables
140 |
141 | Each domain server supports the following environment variables to customize where data is stored:
142 |
143 | - **MEMORY_FILE_PATH**: Path where the knowledge graph data will be stored
144 | - Can be absolute or relative (relative paths use current working directory)
145 | - Default: `<domain_directory>/memory.json`
146 |
147 | - **SESSIONS_FILE_PATH**: Path where session data will be stored
148 | - Can be absolute or relative (relative paths use current working directory)
149 | - Default: `<domain_directory>/sessions.json`
150 |
151 | Example usage:
152 |
153 | ```bash
154 | # Store data in the current directory
155 | MEMORY_FILE_PATH="./my-dev-memory.json" SESSIONS_FILE_PATH="./my-dev-sessions.json" npx github:tejpalvirk/contextmanager
156 |
157 | # Store data in a specific location (absolute path)
158 | MEMORY_FILE_PATH="/path/to/data/developer-memory.json" npx github:tejpalvirk/contextmanager
159 |
160 | # Store data in user's home directory
161 | MEMORY_FILE_PATH="$HOME/contextmanager/memory.json" npx github:tejpalvirk/contextmanager
162 | ```
163 |
164 | ## Interacting with Domain Servers
165 |
166 | ### Domain Management
167 |
168 | Use the `setActiveDomain` tool to select which domain you want to work with:
169 |
170 | ```
171 | setActiveDomain(domain="developer")
172 | ```
173 |
174 | ### Session Management
175 |
176 | Start a new session for the active domain:
177 |
178 | ```
179 | startsession(domain="developer")
180 | ```
181 |
182 | End a session when you're done:
183 |
184 | ```
185 | endsession(sessionId="session_id_here", stage="assembly", stageNumber=6, totalStages=6, nextStageNeeded=false)
186 | ```
187 |
188 | ### Context Operations
189 |
190 | Build context for the active domain:
191 |
192 | ```
193 | buildcontext(type="entities", data={...})
194 | ```
195 |
196 | Load context for a specific entity:
197 |
198 | ```
199 | loadcontext(entityName="MyProject", entityType="project")
200 | ```
201 |
202 | Delete context:
203 |
204 | ```
205 | deletecontext(type="entities", data={...})
206 | ```
207 |
208 | ### Entity Status and Priority Management
209 |
210 | Assign status to entities:
211 |
212 | ```
213 | buildcontext(type="relations", data=[
214 | { from: "LoginFeature", to: "active", relationType: "has_status" }
215 | ])
216 | ```
217 |
218 | Set entity priorities:
219 |
220 | ```
221 | buildcontext(type="relations", data=[
222 | { from: "BugFix", to: "high", relationType: "has_priority" }
223 | ])
224 | ```
225 |
226 | Define sequential relationships:
227 |
228 | ```
229 | buildcontext(type="relations", data=[
230 | { from: "DataModel", to: "UserInterface", relationType: "precedes" }
231 | ])
232 | ```
233 |
234 | ### Example: Working with the Developer Domain
235 |
236 | ```javascript
237 | // Set the active domain to developer
238 | setActiveDomain(domain="developer")
239 |
240 | // Start a new session
241 | startsession(domain="developer")
242 |
243 | // Create a new project entity
244 | buildcontext(type="entities", data={
245 | "entityType": "project",
246 | "name": "MyProject",
247 | "description": "A sample project",
248 | "language": "TypeScript",
249 | "framework": "React"
250 | })
251 |
252 | // Load context for the project
253 | loadcontext(entityName="MyProject", entityType="project")
254 |
255 | // Create a component for the project and set its status to active
256 | buildcontext(type="entities", data={
257 | "entityType": "component",
258 | "name": "AuthService",
259 | "project": "MyProject",
260 | "description": "Authentication service component",
261 | "dependencies": ["UserService"]
262 | })
263 |
264 | buildcontext(type="relations", data=[
265 | { from: "AuthService", to: "active", relationType: "has_status" },
266 | { from: "AuthService", to: "high", relationType: "has_priority" }
267 | ])
268 | ```
269 |
270 | ### Cross-Domain Operations
271 |
272 | Create relationships between entities in different domains:
273 |
274 | ```
275 | relateCrossDomain(fromDomain="developer", fromEntity="ProjectX", toDomain="project", toEntity="ProjectX", relationType="manages")
276 | ```
277 |
278 | ### Example: Cross-Domain Integration
279 |
280 | ```javascript
281 | // Create relationship between developer project and project management task
282 | relateCrossDomain(
283 | fromDomain="developer",
284 | fromEntity="MyProject",
285 | toDomain="project",
286 | toEntity="ProjectX",
287 | relationType="manages"
288 | )
289 | ```
290 |
291 | ## Integration with Claude
292 |
293 | In Claude Desktop, configure the Context Manager in settings:
294 |
295 | ```json
296 | {
297 | "mcpServers": {
298 | "contextmanager": {
299 | "command": "npx",
300 | "args": [
301 | "-y",
302 | "github:tejpalvirk/contextmanager"
303 | ],
304 | "options": {
305 | "port": 3000,
306 | "domains": ["developer", "project", "student"]
307 | }
308 | }
309 | }
310 | }
311 | ```
312 |
313 | ## Troubleshooting
314 |
315 | ### Common Issues
316 |
317 | 1. **Port Already in Use**:
318 | ```
319 | Error: listen EADDRINUSE: address already in use :::3000
320 | ```
321 | Solution: Use the `--port` option to specify a different port.
322 |
323 | 2. **Connection Refused**:
324 | ```
325 | Error: connect ECONNREFUSED 127.0.0.1:3000
326 | ```
327 | Solution: Ensure the server is running and accessible at the specified address.
328 |
329 | 3. **Domain Server Not Found**:
330 | ```
331 | Error: Domain server 'developer' not found
332 | ```
333 | Solution: Check that the domain name is correct and the server is registered in the Context Manager.
334 |
335 | 4. **Path Resolution Errors**:
336 | ```
337 | Error: Cannot find module '...'
338 | ```
339 | Solution: Ensure all paths in the `domains` array in `main/index.ts` are correctly specified.
340 |
341 | 5. **Method Not Found**:
342 | ```
343 | Error: Method 'buildcontext' not found in domain 'developer'
344 | ```
345 | Solution: Verify the method name and ensure it is supported by the domain server.
346 |
347 | 6. **Invalid Status or Priority Value**:
348 | ```
349 | Error: Invalid status value 'in_progress'. Valid values are: inactive, active, complete
350 | ```
351 | Solution: Ensure you're using the correct status values for the specific domain.
352 |
353 | ## Next Steps
354 | - Replace JSON for YAML for 20-30% improvement in token efficiency
355 | - Explore Knowledge Graphs in Markdown
356 |
357 | ## Versioning
358 |
359 | This package follows [Semantic Versioning](https://semver.org/):
360 |
361 | - **MAJOR**: Incompatible API changes
362 | - **MINOR**: Backwards-compatible functionality additions
363 | - **PATCH**: Backwards-compatible bug fixes
364 |
365 | Current version: 1.0.0
366 |
367 | ## Contributing
368 |
369 | Contributions are welcome! Please follow these steps:
370 |
371 | 1. Fork the repository
372 | 2. Create a feature branch (`git checkout -b feature/amazing-feature`)
373 | 3. Commit your changes (`git commit -m 'Add some amazing feature'`)
374 | 4. Push to the branch (`git push origin feature/amazing-feature`)
375 | 5. Open a Pull Request
376 |
377 | ### Coding Standards
378 |
379 | - Use TypeScript for all new code
380 | - Follow the existing code style
381 | - Add tests for new functionality
382 | - Update documentation as needed
383 |
384 | ## Development
385 |
386 | ### Prerequisites
387 |
388 | - Node.js v16 or higher
389 | - npm v7 or higher
390 |
391 | ### Building
392 |
393 | ```bash
394 | npm install
395 | npm run build
396 | ```
397 |
398 | ### Testing
399 |
400 | ```bash
401 | npm test
402 | ```
403 |
404 | ## License
405 |
406 | MIT
407 |
408 | ## Acknowledgments
409 |
410 | This project builds on the Model Context Protocol created by Anthropic for Claude.
411 |
```
--------------------------------------------------------------------------------
/qualitativeresearch/README.md:
--------------------------------------------------------------------------------
```markdown
1 | # Qualitative Researcher MCP Server
2 |
3 | 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.
4 |
5 | ## Features
6 |
7 | - **Persistent Research Context**: Maintain a structured knowledge graph of research entities and relationships across multiple analysis sessions
8 | - **Study Session Management**: Track research analysis sessions with unique IDs and record progress over time
9 | - **Thematic Analysis**: Organize and track emergent themes across data sources
10 | - **Coding Framework**: Manage hierarchical coding structures and track code applications
11 | - **Participant Management**: Track participant data, demographics, and contributions
12 | - **Data Source Organization**: Organize interviews, observations, and documents
13 | - **Research Question Tracking**: Link data to specific research questions
14 | - **Memo Writing**: Document analytical insights throughout the research process
15 | - **Chronological Data Analysis**: Explore data in temporal sequence
16 | - **Code Co-occurrence Analysis**: Identify relationships between different codes
17 | - **Methodology Documentation**: Track methodological decisions and approaches
18 |
19 | ## Entities
20 |
21 | The Qualitative Researcher MCP Server recognizes the following entity types:
22 |
23 | - **project**: Overall research study
24 | - **participant**: Research subjects
25 | - **interview**: Formal conversation with participants
26 | - **observation**: Field notes from observational research
27 | - **document**: External materials being analyzed
28 | - **code**: Labels applied to data segments
29 | - **codeGroup**: Categories or families of related codes
30 | - **memo**: Researcher's analytical notes
31 | - **theme**: Emergent patterns across data
32 | - **quote**: Notable excerpts from data sources
33 | - **literature**: Academic sources
34 | - **researchQuestion**: Formal questions guiding the study
35 | - **finding**: Results or conclusions
36 | - **status**: Entity status values (active, completed, pending, abandoned)
37 | - **priority**: Priority level values (high, low)
38 |
39 | ## Relationships
40 |
41 | Entities can be connected through the following relationship types:
42 |
43 | - **participated_in**: Links participants to interviews/observations
44 | - **codes**: Shows which codes apply to which data
45 | - **contains**: Hierarchical relationship (e.g., codegroup contains codes)
46 | - **supports**: Data supporting a theme or finding
47 | - **contradicts**: Data contradicting a theme or finding
48 | - **answers**: Data addressing a research question
49 | - **cites**: References to literature
50 | - **followed_by**: Temporal sequence
51 | - **related_to**: General connection
52 | - **reflects_on**: Memo reflecting on data/code/theme
53 | - **compares**: Comparative relationship
54 | - **conducted_by**: Person who conducted data collection
55 | - **transcribed_by**: Person who transcribed data
56 | - **part_of**: Entity is part of another entity
57 | - **derived_from**: Entity is derived from another entity
58 | - **collected_on**: Data collection date
59 | - **analyzes**: Analysis relationship
60 | - **triangulates_with**: Triangulation between data sources
61 | - **has_status**: Links entities to their current status (active, completed, pending, abandoned)
62 | - **has_priority**: Links entities to their priority level (high, low)
63 | - **precedes**: Indicates that one analysis activity comes before another in a sequence
64 |
65 | ## Available Tools
66 |
67 | The Qualitative Researcher MCP Server provides these tools for interacting with research knowledge:
68 |
69 | ### startsession
70 | 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.
71 |
72 | ### loadcontext
73 | 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.
74 |
75 | ### endsession
76 | Records the results of a research session through a structured, multi-stage process:
77 | 1. **summary**: Records session summary, duration, and project focus
78 | 2. **interviewData**: Documents new interview data processed during the session
79 | 3. **memos**: Records analytical memos created during the session
80 | 4. **codingActivity**: Tracks new and revised codes applied to data
81 | 5. **themes**: Documents emergent or developed themes from analysis
82 | 6. **statusUpdates**: Records changes to entity status values
83 | 7. **projectStatus**: Updates overall project status, priority assignments, and sequential relationships
84 | 8. **assembly**: Final assembly of all session data
85 |
86 | ### buildcontext
87 | Creates new entities, relations, or observations in the knowledge graph:
88 | - **entities**: Add new research entities (projects, participants, interviews, status, priority, etc.)
89 | - **relations**: Create relationships between entities (including has_status, has_priority, precedes)
90 | - **observations**: Add observations to existing entities
91 |
92 | ### deletecontext
93 | Removes entities, relations, or observations from the knowledge graph:
94 | - **entities**: Remove research entities
95 | - **relations**: Remove relationships between entities (including status, priority, and sequential relations)
96 | - **observations**: Remove specific observations from entities
97 |
98 | ### advancedcontext
99 | Retrieves information from the knowledge graph:
100 | - **graph**: Get the entire knowledge graph
101 | - **search**: Search for nodes based on query criteria
102 | - **nodes**: Get specific nodes by name
103 | - **related**: Find related entities
104 | - **status**: Find entities with a specific status value (active, completed, pending, abandoned)
105 | - **priority**: Find entities with a specific priority value (high, low)
106 | - **sequence**: Identify sequential relationships for analysis activities
107 |
108 | ## Domain-Specific Functions
109 |
110 | The Qualitative Researcher MCP Server includes specialized domain functions for qualitative research:
111 |
112 | - **getProjectOverview**: Comprehensive view of a project including research questions, methodology, participants, data sources
113 | - **getParticipantProfile**: Detailed profile of a participant including demographics, interviews, and quotes
114 | - **getThematicAnalysis**: Analysis of themes with supporting codes and data
115 | - **getCodedData**: View all data segments tagged with a specific code
116 | - **getResearchQuestionAnalysis**: Organize data by research questions with related findings
117 | - **getChronologicalData**: View data in temporal sequence
118 | - **getCodeCooccurrence**: Analyze where multiple codes appear together
119 | - **getMemosByFocus**: Retrieve all memos related to a specific entity
120 | - **getMethodologyDetails**: Review methodological approach, sampling, and analysis techniques
121 | - **getRelatedEntities**: Find entities related to a specific entity by relationship type
122 | - **getStatusOverview**: View all entities with a specific status (active, completed, pending, abandoned)
123 | - **getPriorityItems**: Identify high-priority research tasks and activities
124 | - **getAnalysisSequence**: Visualize the sequence of analysis activities based on precedes relations
125 |
126 | ## Example Prompts
127 |
128 | ### Starting a Session
129 | ```
130 | Let's start a new qualitative research session for my Health Behavior Study project.
131 | ```
132 |
133 | ### Loading Research Context
134 | ```
135 | Load the context for the Health Behavior Study project so I can see the current state of my analysis.
136 | ```
137 |
138 | ### Recording Session Results
139 | ```
140 | 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.
141 | ```
142 |
143 | ### Managing Research Knowledge
144 | ```
145 | 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.
146 | ```
147 |
148 | ```
149 | Update the status of the "Participant Recruitment" process to "completed" and add an observation that we've reached our target sample size.
150 | ```
151 |
152 | ## Usage
153 |
154 | This MCP server enables qualitative researchers to:
155 |
156 | - **Maintain Analytical Continuity**: Keep track of analysis progress across multiple research sessions
157 | - **Develop Coding Frameworks**: Build, refine, and apply coding structures to qualitative data
158 | - **Track Thematic Development**: Observe how themes emerge and evolve during analysis
159 | - **Manage Rich Data Sources**: Organize and connect interview transcripts, field notes, and documents
160 | - **Support Theoretical Development**: Document theoretical insights through the memo writing process
161 | - **Prepare Research Findings**: Connect findings to supporting evidence and research questions
162 | - **Enhance Methodological Rigor**: Document methodological decisions and analysis process
163 | - **Track Research Progress**: Monitor entity status throughout the research lifecycle
164 | - **Prioritize Research Tasks**: Identify and focus on high-priority research activities
165 | - **Sequence Analysis Activities**: Plan and visualize the logical order of research and analytical steps
166 |
167 | ## Configuration
168 |
169 | ### Usage with Claude Desktop
170 |
171 | Add this to your `claude_desktop_config.json`:
172 |
173 | #### Install from GitHub and run with npx
174 |
175 | ```json
176 | {
177 | "mcpServers": {
178 | "qualitativeresearch": {
179 | "command": "npx",
180 | "args": [
181 | "-y",
182 | "github:tejpalvirk/qualitativeresearch"
183 | ]
184 | }
185 | }
186 | }
187 | ```
188 |
189 | #### Install globally and run directly
190 |
191 | First, install the package globally:
192 |
193 | ```bash
194 | npm install -g github:tejpalvirk/qualitativeresearch
195 | ```
196 |
197 | Then configure Claude Desktop:
198 |
199 | ```json
200 | {
201 | "mcpServers": {
202 | "qualitativeresearch": {
203 | "command": "contextmanager-qualitativeresearch"
204 | }
205 | }
206 | }
207 | ```
208 |
209 | #### docker
210 |
211 | ```json
212 | {
213 | "mcpServers": {
214 | "qualitativeresearch": {
215 | "command": "docker",
216 | "args": [
217 | "run",
218 | "--rm",
219 | "-i",
220 | "mcp/qualitativeresearch"
221 | ]
222 | }
223 | }
224 | }
225 | ```
226 |
227 | ## Building
228 |
229 | ### From Source
230 |
231 | ```bash
232 | # Clone the repository
233 | git clone https://github.com/tejpalvirk/contextmanager.git
234 | cd contextmanager
235 |
236 | # Install dependencies
237 | npm install
238 |
239 | # Build the server
240 | npm run build
241 |
242 | # Run the server
243 | cd qualitativeresearch
244 | node qualitativeresearch_index.js
245 | ```
246 |
247 | ### Docker:
248 |
249 | ```bash
250 | docker build -t mcp/qualitativeresearch -f qualitativeresearch/Dockerfile .
251 | ```
252 |
253 | ## License
254 |
255 | 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.
256 |
257 | ## Environment Variables
258 |
259 | The Qualitative Research MCP Server supports the following environment variables to customize where data is stored:
260 |
261 | - **MEMORY_FILE_PATH**: Path where the knowledge graph data will be stored
262 | - Can be absolute or relative (relative paths use current working directory)
263 | - Default: `./qualitativeresearch/memory.json`
264 |
265 | - **SESSIONS_FILE_PATH**: Path where session data will be stored
266 | - Can be absolute or relative (relative paths use current working directory)
267 | - Default: `./qualitativeresearch/sessions.json`
268 |
269 | Example usage:
270 |
271 | ```bash
272 | # Store data in the current directory
273 | MEMORY_FILE_PATH="./qualitative-memory.json" SESSIONS_FILE_PATH="./qualitative-sessions.json" npx github:tejpalvirk/contextmanager-qualitativeresearch
274 |
275 | # Store data in a specific location (absolute path)
276 | MEMORY_FILE_PATH="/path/to/data/qualitative-memory.json" npx github:tejpalvirk/contextmanager-qualitativeresearch
277 |
278 | # Store data in user's home directory
279 | MEMORY_FILE_PATH="$HOME/contextmanager/qualitative-memory.json" npx github:tejpalvirk/contextmanager-qualitativeresearch
280 | ```
```
--------------------------------------------------------------------------------
/developer/README.md:
--------------------------------------------------------------------------------
```markdown
1 | # Developer MCP Server
2 |
3 | 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.
4 |
5 | ## Features
6 |
7 | - **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.
8 |
9 | - **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.
10 |
11 | - **Dependency Tracking**: Understand how components, features, and technologies relate to each other with a comprehensive dependency model.
12 |
13 | - **Project Status Insights**: Get immediate visibility into project progress, including status of components, features, issues, and milestones.
14 |
15 | - **Component Context Retrieval**: Understand any component's purpose, implementation details, dependencies, and related issues at a glance.
16 |
17 | - **Decision History**: Track why architectural and implementation decisions were made, when, and by whom—no more guessing why something was built a certain way.
18 |
19 | - **Milestone Progress Tracking**: Monitor progress toward project milestones and identify potential bottlenecks before they derail your timeline.
20 |
21 | - **Related Entity Discovery**: Quickly find all related entities for any component, feature, or task to understand its complete context.
22 |
23 | ## Entities
24 |
25 | The Developer MCP Server recognizes the following types of entities in your software development context:
26 |
27 | - **Project**: Overall software project or product
28 | - **Component**: Module, service, package, or logical unit within a project
29 | - **Feature**: Specific functionality being developed
30 | - **Issue**: Bug, problem, or defect to be addressed
31 | - **Task**: Work item or activity needed for development
32 | - **Developer**: Team member working on the project
33 | - **Technology**: Programming language, framework, library, or tool
34 | - **Decision**: Important technical or architectural decision
35 | - **Milestone**: Key project deadline or phase
36 | - **Environment**: Development, staging, or production environment
37 | - **Documentation**: Project documentation resource
38 | - **Requirement**: Project requirement or specification
39 | - **Status**: Entity status values (inactive, active, complete)
40 | - **Priority**: Priority level values (high, low)
41 |
42 | ## Relationships
43 |
44 | The Developer MCP Server models the following relationships between entities, mirroring real-world software development dynamics:
45 |
46 | - **depends_on**: Entity A requires Entity B to function
47 | - **implements**: Component implements a feature
48 | - **assigned_to**: Task is assigned to a developer
49 | - **blocked_by**: Task is blocked by an issue
50 | - **uses**: Component uses a technology
51 | - **part_of**: Component is part of a project
52 | - **contains**: Project contains a component
53 | - **works_on**: Developer works on a project/component
54 | - **related_to**: General relationship between entities
55 | - **affects**: Issue affects a component
56 | - **resolves**: Task resolves an issue
57 | - **created_by**: Entity was created by a developer
58 | - **documented_in**: Component is documented in documentation
59 | - **decided_in**: Decision was made in a meeting
60 | - **required_by**: Feature is required by a requirement
61 | - **has_status**: Links entities to their current status (inactive, active, complete)
62 | - **has_priority**: Links entities to their priority level (high, low)
63 | - **depends_on_milestone**: Task depends on reaching a milestone
64 | - **precedes**: Indicates that one task comes before another in a sequence
65 | - **reviews**: Developer reviews a component
66 | - **tested_in**: Component is tested in an environment
67 |
68 | ## Status and Priority Management
69 |
70 | The Developer MCP Server provides robust status and priority tracking capabilities:
71 |
72 | - **Status Values**:
73 | - **inactive**: Entity has not yet been started or is currently paused
74 | - **active**: Entity is currently being worked on
75 | - **complete**: Entity has been finished
76 |
77 | - **Priority Values**:
78 | - **high**: Entity requires immediate attention or has significant impact
79 | - **low**: Entity can be addressed when higher priority items are complete
80 |
81 | - **Sequential Task Management**:
82 | - Define which tasks must be completed before others can begin
83 | - Visualize the natural workflow of development tasks
84 | - Identify critical path dependencies in your development process
85 |
86 | ## Environment Variables
87 |
88 | The Developer MCP Server supports the following environment variables to customize where data is stored:
89 |
90 | - **MEMORY_FILE_PATH**: Path where the knowledge graph data will be stored
91 | - Can be absolute or relative (relative paths use current working directory)
92 | - Default: `./developer/memory.json`
93 |
94 | - **SESSIONS_FILE_PATH**: Path where session data will be stored
95 | - Can be absolute or relative (relative paths use current working directory)
96 | - Default: `./developer/sessions.json`
97 |
98 | Example usage:
99 |
100 | ```bash
101 | # Store data in the current directory
102 | MEMORY_FILE_PATH="./dev-memory.json" SESSIONS_FILE_PATH="./dev-sessions.json" npx github:tejpalvirk/contextmanager-developer
103 |
104 | # Store data in a specific location (absolute path)
105 | MEMORY_FILE_PATH="/path/to/data/developer-memory.json" npx github:tejpalvirk/contextmanager-developer
106 |
107 | # Store data in user's home directory
108 | MEMORY_FILE_PATH="$HOME/contextmanager/developer-memory.json" npx github:tejpalvirk/contextmanager-developer
109 | ```
110 |
111 | ## Available Tools
112 |
113 | The Developer MCP Server provides the following tools:
114 |
115 | - **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.
116 |
117 | - **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.
118 |
119 | - **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.
120 |
121 | - **buildcontext**: Creates new entities, relations (including has_status, has_priority, and precedes), or observations in the knowledge graph.
122 |
123 | - **deletecontext**: Removes entities, relations (including status, priority, and sequential relations), or observations from the knowledge graph.
124 |
125 | - **advancedcontext**: Retrieves information from the knowledge graph with different query types (graph, search, nodes, related, decisions, milestone, status, priority, sequence).
126 |
127 | ## Prompts
128 |
129 | Here are some example prompts to use with the Developer MCP Server:
130 |
131 | ### Starting a Session
132 | ```
133 | "Start a new development session for me."
134 | ```
135 |
136 | ### Loading Context
137 | ```
138 | "Show me the current status of the AuthService project."
139 | "Load the context for the UserProfile component."
140 | "What are the open issues affecting the Payment feature?"
141 | "Show me details about the upcoming Q2 Release milestone."
142 | "Show me all tasks with high priority status in the Authentication module."
143 | "What tasks need to be completed before we can start implementing the checkout flow?"
144 | ```
145 |
146 | ### Recording Session Progress
147 | ```
148 | "End my development session. I've been working on AuthService for 3 hours and completed user authentication flow implementation."
149 | "Record my achievements for today: implemented password reset feature and fixed login redirect bug."
150 | "Update the status of these tasks: Login Form is complete, User Registration is in progress."
151 | "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."
152 | ```
153 |
154 | ### Knowledge Graph Management
155 | ```
156 | "Create a new feature called 'BillingSystem' in the ProjectX project with status active and high priority."
157 | "Create a relationship showing that PaymentComponent implements BillingSystem feature."
158 | "Show me all components that depend on the DatabaseService."
159 | "What decisions have been made about the authentication approach for ProjectX?"
160 | "Update the status of the API Documentation task to complete."
161 | "Set the User Profile feature as a prerequisite for the Payment Processing feature."
162 | ```
163 |
164 | ## Usage
165 |
166 | The Developer MCP Server excels in scenarios like:
167 |
168 | ### Context Continuity
169 | ```
170 | "Let me see the component I was working on yesterday and all its dependencies."
171 | ```
172 | 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.
173 |
174 | ### Onboarding New Team Members
175 | ```
176 | "Give me an overview of Project X's architecture and component structure."
177 | ```
178 | 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.
179 |
180 | ### Session Recording
181 | ```
182 | "End my development session and record what I accomplished."
183 | ```
184 | 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.
185 |
186 | ### Architectural Decision Context
187 | ```
188 | "Why was GraphQL chosen over REST for the API layer?"
189 | ```
190 | 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.
191 |
192 | ### Dependency Analysis
193 | ```
194 | "What would be affected if we modify the authentication service?"
195 | ```
196 | Before making changes, developers can understand all components, features, and tasks that depend on a particular component, reducing the risk of unexpected breakages.
197 |
198 | ### Project Progress Tracking
199 | ```
200 | "What's our progress toward the Q2 release milestone?"
201 | ```
202 | 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.
203 |
204 | ### Status and Priority Management
205 | ```
206 | "Show me all high-priority tasks that are still active."
207 | ```
208 | Quickly identify the most important work that needs attention, ensuring that critical tasks are addressed first.
209 |
210 | ### Task Sequencing
211 | ```
212 | "What tasks are blocked because they depend on incomplete prerequisite tasks?"
213 | ```
214 | Identify and resolve bottlenecks in the development process by understanding the sequential dependencies between tasks.
215 |
216 | ## Configuration
217 |
218 | ### Usage with Claude Desktop
219 |
220 | Add this to your `claude_desktop_config.json`:
221 |
222 | #### Install from GitHub and run with npx
223 |
224 | ```json
225 | {
226 | "mcpServers": {
227 | "developer": {
228 | "command": "npx",
229 | "args": [
230 | "-y",
231 | "github:tejpalvirk/developer"
232 | ]
233 | }
234 | }
235 | }
236 | ```
237 |
238 | #### Install globally and run directly
239 |
240 | First, install the package globally:
241 |
242 | ```bash
243 | npm install -g github:tejpalvirk/contextmanager/developer
244 | ```
245 |
246 | Then configure Claude Desktop:
247 |
248 | ```json
249 | {
250 | "mcpServers": {
251 | "developer": {
252 | "command": "contextmanager-developer"
253 | }
254 | }
255 | }
256 | ```
257 |
258 | #### docker
259 |
260 | ```json
261 | {
262 | "mcpServers": {
263 | "developer": {
264 | "command": "docker",
265 | "args": [
266 | "run",
267 | "--rm",
268 | "-i",
269 | "mcp/developer"
270 | ]
271 | }
272 | }
273 | }
274 | ```
275 |
276 | ## Building
277 |
278 | ### From Source
279 |
280 | ```bash
281 | # Clone the repository
282 | git clone https://github.com/tejpalvirk/contextmanager.git
283 | cd contextmanager
284 |
285 | # Install dependencies
286 | npm install
287 |
288 | # Build the server
289 | npm run build
290 |
291 | # Run the server
292 | cd developer
293 | node developer_index.js
294 | ```
295 |
296 | ### Docker:
297 |
298 | ```bash
299 | docker build -t mcp/developer -f developer/Dockerfile .
300 | ```
301 |
302 | ## License
303 |
304 | 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
1 | # Student MCP Server
2 |
3 | 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.
4 |
5 | ## Features
6 |
7 | - **Persistent Educational Context**: Maintain a structured knowledge graph of educational entities and relationships across multiple sessions
8 | - **Study Session Management**: Track study sessions with unique IDs and record progress over time
9 | - **Course Management**: Organize courses, lectures, assignments, and exams in a structured format
10 | - **Concept Mapping**: Connect learning concepts to show relationships and prerequisites
11 | - **Assignment Tracking**: Monitor assignment status, due dates, and related resources
12 | - **Exam Preparation**: Track exam dates and organize study materials
13 | - **Deadline Management**: Keep track of upcoming due dates for assignments and exams
14 | - **Resource Organization**: Connect learning resources to specific courses and concepts
15 | - **Progress Monitoring**: Track completion status of courses, assignments, and exams
16 | - **Knowledge Connections**: Visualize relationships between different educational concepts
17 |
18 | ## Entities
19 |
20 | The Student MCP Server recognizes the following entity types:
21 |
22 | - **course**: Academic courses being taken
23 | - **assignment**: Homework, projects, and other submitted work
24 | - **exam**: Tests, quizzes, and other assessments
25 | - **concept**: Knowledge topics and learning objectives
26 | - **resource**: Textbooks, articles, videos, and other learning materials
27 | - **note**: Personal study notes and observations
28 | - **lecture**: Individual class sessions
29 | - **project**: Larger educational projects or undertakings
30 | - **question**: Specific questions for study or review
31 | - **term**: Academic terms or semesters
32 | - **goal**: Learning objectives and targets
33 | - **professor**: Course instructors and teachers
34 | - **status**: Entity status values (active, completed, pending, abandoned)
35 | - **priority**: Priority level values (high, low)
36 |
37 | ## Relationships
38 |
39 | Entities can be connected through the following relationship types:
40 |
41 | - **enrolled_in**: Student is taking a course
42 | - **assigned_in**: Assignment is part of a course
43 | - **due_on**: Assignment/exam has specific due date
44 | - **covers**: Lecture/resource covers concept
45 | - **references**: Note references concept
46 | - **prerequisite_for**: Concept is foundation for another
47 | - **taught_by**: Course taught by professor
48 | - **scheduled_for**: Lecture/exam scheduled for specific time
49 | - **contains**: Course contains lectures/assignments
50 | - **requires**: Assignment requires specific concepts
51 | - **related_to**: Concept related to another concept
52 | - **created_for**: Note created for specific lecture
53 | - **studies**: Study session focuses on concept/exam
54 | - **helps_with**: Resource helps with assignment/concept
55 | - **submitted**: Assignment submitted on date
56 | - **part_of**: Entity is part of another entity
57 | - **included_in**: Included in a larger component
58 | - **follows**: Entity follows another in sequence
59 | - **attends**: Student attends lecture
60 | - **graded_with**: Assignment/exam graded with specific criteria
61 | - **has_status**: Links entities to their current status (active, completed, pending, abandoned)
62 | - **has_priority**: Links entities to their priority level (high, low)
63 | - **precedes**: Indicates that one task or assignment comes before another in a sequence
64 |
65 | ## Status and Priority Management
66 |
67 | The Student MCP Server provides comprehensive status and priority tracking capabilities:
68 |
69 | - **Status Values**:
70 | - **active**: Currently being worked on or studied
71 | - **completed**: Finished or successfully submitted
72 | - **pending**: Not yet started but planned
73 | - **abandoned**: No longer being pursued
74 |
75 | - **Priority Values**:
76 | - **high**: Requires immediate attention or has significant impact on grades
77 | - **low**: Can be addressed after higher priority items are complete
78 |
79 | - **Sequential Learning Management**:
80 | - Define which assignments or concepts must be completed before others
81 | - Organize study activities in a logical progression
82 | - Create dependencies between related learning tasks
83 | - Build structured learning paths through course material
84 |
85 | ## Available Tools
86 |
87 | The Student MCP Server provides these tools for interacting with educational knowledge:
88 |
89 | ### startsession
90 | 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.
91 |
92 | ### loadcontext
93 | 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.
94 |
95 | ### endsession
96 | Records the results of a study session through a structured, multi-stage process:
97 | 1. **summary**: Records session summary, duration, and course focus
98 | 2. **conceptsLearned**: Documents concepts studied during the session
99 | 3. **assignmentUpdates**: Tracks updates to assignments
100 | 4. **statusUpdates**: Records changes to entity status values
101 | 5. **courseStatus**: Updates overall course status, priority assignments, and sequential relationships
102 | 6. **newConcepts**: Records new concepts learned during the session
103 | 7. **assembly**: Final assembly of all session data
104 |
105 | ### buildcontext
106 | Creates new entities, relations, or observations in the knowledge graph:
107 | - **entities**: Add new educational entities (courses, assignments, concepts, status, priority, etc.)
108 | - **relations**: Create relationships between entities (including has_status, has_priority, precedes)
109 | - **observations**: Add observations to existing entities
110 |
111 | ### deletecontext
112 | Removes entities, relations, or observations from the knowledge graph:
113 | - **entities**: Remove educational entities
114 | - **relations**: Remove relationships between entities (including status, priority, and sequential relations)
115 | - **observations**: Remove specific observations from entities
116 |
117 | ### advancedcontext
118 | Retrieves information from the knowledge graph:
119 | - **graph**: Get the entire knowledge graph
120 | - **search**: Search for nodes based on query criteria
121 | - **nodes**: Get specific nodes by name
122 | - **course**: Get details about a specific course
123 | - **deadlines**: Get upcoming deadlines
124 | - **assignment**: Get details about a specific assignment
125 | - **exam**: Get details about a specific exam
126 | - **concepts**: Get information about concepts
127 | - **lecture**: Get information about lectures
128 | - **term**: Get details about an academic term
129 | - **status**: Find entities with a specific status value
130 | - **priority**: Find entities with a specific priority value
131 | - **sequence**: Identify sequential relationships for learning activities
132 |
133 | ## Domain-Specific Functions
134 |
135 | The Student MCP Server includes specialized domain functions for education:
136 |
137 | - **getCourseOverview**: Comprehensive view of a course including lectures, assignments, exams, and resources
138 | - **getUpcomingDeadlines**: Find assignments and exams with approaching due dates
139 | - **getAssignmentStatus**: Get detailed status of assignments, including progress and related concepts
140 | - **getExamPrep**: Get exam preparation materials and related concepts
141 | - **findRelatedConcepts**: Discover connections between different educational concepts
142 | - **getStudyProgress**: Track study progress across courses
143 | - **getTermOverview**: Get overview of courses and work for an academic term
144 | - **getConceptMastery**: Assess level of understanding for specific concepts
145 | - **getStatusOverview**: View all entities with a specific status (active, completed, pending, abandoned)
146 | - **getPriorityItems**: Identify high-priority assignments and study tasks
147 | - **getLearningSequence**: Visualize the sequence of learning activities based on precedes relations
148 |
149 | ## Example Prompts
150 |
151 | ### Starting a Session
152 | ```
153 | Let's start a new study session for my Computer Science course.
154 | ```
155 |
156 | ### Loading Course Context
157 | ```
158 | Load the context for my Calculus 101 course so I can see upcoming assignments and exams.
159 | ```
160 |
161 | ### Recording Study Progress
162 | ```
163 | 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.
164 | ```
165 |
166 | ### Managing Learning Materials
167 | ```
168 | 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.
169 | ```
170 |
171 | ```
172 | 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.
173 | ```
174 |
175 | ## Usage
176 |
177 | This MCP server enables students to:
178 |
179 | - **Maintain Study Continuity**: Keep track of what you've learned across multiple study sessions
180 | - **Optimize Learning Time**: Focus on high-priority assignments and concepts
181 | - **Track Academic Progress**: Monitor completion of courses, assignments, and mastery of concepts
182 | - **Prepare for Exams**: Organize study materials and track progress towards exam readiness
183 | - **Manage Deadlines**: Stay on top of upcoming due dates for assignments and exams
184 | - **Connect Knowledge**: See relationships between different concepts across courses
185 | - **Prioritize Work**: Focus on high-priority assignments and learning tasks
186 | - **Structure Learning**: Create logical sequences for learning related concepts
187 | - **Track Status**: Monitor the status of assignments, projects, and learning activities
188 |
189 | ## Configuration
190 |
191 | ### Usage with Claude Desktop
192 |
193 | Add this to your `claude_desktop_config.json`:
194 |
195 | #### Install from GitHub and run with npx
196 |
197 | ```json
198 | {
199 | "mcpServers": {
200 | "student": {
201 | "command": "npx",
202 | "args": [
203 | "-y",
204 | "github:tejpalvirk/student"
205 | ]
206 | }
207 | }
208 | }
209 | ```
210 |
211 | #### Install globally and run directly
212 |
213 | First, install the package globally:
214 |
215 | ```bash
216 | npm install -g github:tejpalvirk/student
217 | ```
218 |
219 | Then configure Claude Desktop:
220 |
221 | ```json
222 | {
223 | "mcpServers": {
224 | "student": {
225 | "command": "contextmanager-student"
226 | }
227 | }
228 | }
229 | ```
230 |
231 | #### docker
232 |
233 | ```json
234 | {
235 | "mcpServers": {
236 | "student": {
237 | "command": "docker",
238 | "args": [
239 | "run",
240 | "--rm",
241 | "-i",
242 | "mcp/student"
243 | ]
244 | }
245 | }
246 | }
247 | ```
248 |
249 | ## Building
250 |
251 | ### From Source
252 |
253 | ```bash
254 | # Clone the repository
255 | git clone https://github.com/tejpalvirk/contextmanager.git
256 | cd contextmanager
257 |
258 | # Install dependencies
259 | npm install
260 |
261 | # Build the server
262 | npm run build
263 |
264 | # Run the server
265 | cd student
266 | node student_index.js
267 | ```
268 |
269 | ### Docker:
270 |
271 | ```bash
272 | docker build -t mcp/student -f student/Dockerfile .
273 | ```
274 |
275 | ## License
276 |
277 | 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.
278 |
279 | ## Environment Variables
280 |
281 | The Student MCP Server supports the following environment variables to customize where data is stored:
282 |
283 | - **MEMORY_FILE_PATH**: Path where the knowledge graph data will be stored
284 | - Can be absolute or relative (relative paths use current working directory)
285 | - Default: `./student/memory.json`
286 |
287 | - **SESSIONS_FILE_PATH**: Path where session data will be stored
288 | - Can be absolute or relative (relative paths use current working directory)
289 | - Default: `./student/sessions.json`
290 |
291 | Example usage:
292 |
293 | ```bash
294 | # Store data in the current directory
295 | MEMORY_FILE_PATH="./student-memory.json" SESSIONS_FILE_PATH="./student-sessions.json" npx github:tejpalvirk/contextmanager-student
296 |
297 | # Store data in a specific location (absolute path)
298 | MEMORY_FILE_PATH="/path/to/data/student-memory.json" npx github:tejpalvirk/contextmanager-student
299 |
300 | # Store data in user's home directory
301 | MEMORY_FILE_PATH="$HOME/contextmanager/student-memory.json" npx github:tejpalvirk/contextmanager-student
302 | ```
```
--------------------------------------------------------------------------------
/quantitativeresearch/README.md:
--------------------------------------------------------------------------------
```markdown
1 | # Quantitative Researcher MCP Server
2 |
3 | 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.
4 |
5 | ## Features
6 |
7 | - **Persistent Research Context**: Maintain a structured knowledge graph of research entities and relationships across multiple analysis sessions
8 | - **Study Session Management**: Track research analysis sessions with unique IDs and record progress over time
9 | - **Hypothesis Testing**: Track hypotheses, their associated tests, and resulting conclusions
10 | - **Dataset Management**: Organize and track descriptive statistics and variables within datasets
11 | - **Statistical Analysis**: Record statistical tests, models, and their results
12 | - **Variable Relationships**: Track correlations, predictions, and other relationships between variables
13 | - **Research Question Tracking**: Link data analyses to specific research questions
14 | - **Data Visualization**: Document visualizations created from datasets and results
15 | - **Model Performance**: Monitor statistical model performance metrics
16 | - **Research Finding Documentation**: Link findings to supporting statistical evidence
17 | - **Research Methodology Documentation**: Track methodological decisions and approaches
18 |
19 | ## Entities
20 |
21 | The Quantitative Researcher MCP Server recognizes the following entity types:
22 |
23 | - **project**: Overall research study
24 | - **dataset**: Collection of data used for analysis
25 | - **variable**: Specific measurable attribute in a dataset
26 | - **hypothesis**: Formal testable statement
27 | - **statisticalTest**: Analysis method applied to data
28 | - **result**: Outcome of statistical analysis
29 | - **analysisScript**: Code used to perform analysis
30 | - **visualization**: Visual representation of data
31 | - **model**: Statistical/mathematical model
32 | - **literature**: Academic sources
33 | - **researchQuestion**: Formal questions guiding the study
34 | - **finding**: Results or conclusions
35 | - **participant**: Research subjects
36 | - **status**: Entity status values (active, completed, pending, abandoned)
37 | - **priority**: Priority level values (high, low)
38 |
39 | ## Relationships
40 |
41 | Entities can be connected through the following relationship types:
42 |
43 | - **correlates_with**: Statistical correlation between variables
44 | - **predicts**: Predictive relationship from independent to dependent variable
45 | - **tests**: Statistical test examines hypothesis
46 | - **analyzes**: Analysis performed on dataset
47 | - **produces**: Analysis produces result
48 | - **visualizes**: Visualization displays data or result
49 | - **contains**: Hierarchical relationship
50 | - **part_of**: Entity is part of another entity
51 | - **depends_on**: Dependency relationship
52 | - **supports**: Evidence supporting a hypothesis or finding
53 | - **contradicts**: Evidence contradicting a hypothesis or finding
54 | - **derived_from**: Entity is derived from another entity
55 | - **controls_for**: Variable/method controls for confounds
56 | - **moderates**: Variable moderates a relationship
57 | - **mediates**: Variable mediates a relationship
58 | - **implements**: Script implements statistical test/model
59 | - **compares**: Statistical comparison between groups/variables
60 | - **includes**: Model includes variables
61 | - **validates**: Validates a model or result
62 | - **cites**: References literature
63 | - **has_status**: Links entities to their current status (active, completed, pending, abandoned)
64 | - **has_priority**: Links entities to their priority level (high, low)
65 | - **precedes**: Indicates that one process or activity comes before another in a sequence
66 |
67 | ## Available Tools
68 |
69 | The Quantitative Researcher MCP Server provides these tools for interacting with research knowledge:
70 |
71 | ### startsession
72 | 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.
73 |
74 | ### loadcontext
75 | 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.
76 |
77 | ### endsession
78 | Records the results of a research session through a structured, multi-stage process:
79 | 1. **summary**: Records session summary, duration, and project focus
80 | 2. **datasetUpdates**: Documents updates to datasets during the session
81 | 3. **newAnalyses**: Records new statistical analyses performed
82 | 4. **newVisualizations**: Tracks new data visualizations created
83 | 5. **hypothesisResults**: Documents results of hypothesis testing
84 | 6. **modelUpdates**: Records updates to statistical models
85 | 7. **statusUpdates**: Records changes to entity status values
86 | 8. **projectStatus**: Updates overall project status, priority assignments, and sequential relationships
87 | 9. **assembly**: Final assembly of all session data
88 |
89 | ### buildcontext
90 | Creates new entities, relations, or observations in the knowledge graph:
91 | - **entities**: Add new research entities (projects, datasets, variables, status, priority, etc.)
92 | - **relations**: Create relationships between entities (including has_status, has_priority, precedes)
93 | - **observations**: Add observations to existing entities
94 |
95 | ### deletecontext
96 | Removes entities, relations, or observations from the knowledge graph:
97 | - **entities**: Remove research entities
98 | - **relations**: Remove relationships between entities (including status, priority, and sequential relations)
99 | - **observations**: Remove specific observations from entities
100 |
101 | ### advancedcontext
102 | Retrieves information from the knowledge graph:
103 | - **graph**: Get the entire knowledge graph
104 | - **search**: Search for nodes based on query criteria
105 | - **nodes**: Get specific nodes by name
106 | - **related**: Find related entities
107 | - **status**: Find entities with a specific status value (active, completed, pending, abandoned)
108 | - **priority**: Find entities with a specific priority value (high, low)
109 | - **sequence**: Identify sequential relationships for research processes
110 |
111 | ## Domain-Specific Functions
112 |
113 | The Quantitative Researcher MCP Server includes specialized domain functions for quantitative research:
114 |
115 | - **getProjectOverview**: Comprehensive view of a project including research questions, methodology, datasets, variables
116 | - **getDatasetAnalysis**: Analysis of dataset contents including variables, descriptive statistics, and data quality
117 | - **getHypothesisTests**: Review of hypothesis tests and their outcomes
118 | - **getVariableRelationships**: Examine correlations, predictions, and other relationships between variables
119 | - **getStatisticalResults**: Summarize the results of statistical analyses
120 | - **getVisualizationGallery**: View visualizations created for datasets and results
121 | - **getModelPerformance**: Assess performance metrics for statistical models
122 | - **getResearchQuestionResults**: Organize analyses and results by research questions
123 | - **getVariableDistribution**: Examine the distribution and properties of individual variables
124 | - **getStatusOverview**: View all entities with a specific status (active, completed, pending, abandoned)
125 | - **getPriorityItems**: Identify high-priority research tasks and activities
126 | - **getResearchSequence**: Visualize the sequence of research processes based on precedes relations
127 |
128 | ## Example Prompts
129 |
130 | ### Starting a Session
131 | ```
132 | Let's start a new quantitative research session for my Climate Impact Study project.
133 | ```
134 |
135 | ### Loading Research Context
136 | ```
137 | Load the context for the Climate Impact Study project so I can see the current state of my statistical analyses.
138 | ```
139 |
140 | ### Recording Session Results
141 | ```
142 | 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.
143 | ```
144 |
145 | ### Managing Research Knowledge
146 | ```
147 | 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.
148 | ```
149 |
150 | ```
151 | Update the status of the "Data Cleaning" process to "completed" and add an observation that all outliers have been properly handled.
152 | ```
153 |
154 | ## Usage
155 |
156 | This MCP server enables quantitative researchers to:
157 |
158 | - **Maintain Analytical Continuity**: Track analyses and results across multiple research sessions
159 | - **Organize Statistical Evidence**: Link hypotheses to supporting statistical tests and results
160 | - **Document Variable Relationships**: Record how variables correlate, predict, or influence each other
161 | - **Track Model Development**: Document the evolution of statistical models and their performance
162 | - **Support Result Interpretation**: Connect statistical findings to research questions and theoretical frameworks
163 | - **Ensure Methodological Rigor**: Document methodological decisions and analytical approaches
164 | - **Prepare Research Reports**: Organize statistical evidence to support research findings
165 | - **Track Research Progress**: Monitor entity status throughout the research lifecycle
166 | - **Prioritize Research Tasks**: Identify and focus on high-priority research activities
167 | - **Sequence Research Processes**: Plan and visualize the logical order of research and analytical steps
168 |
169 | ## Configuration
170 |
171 | ### Usage with Claude Desktop
172 |
173 | Add this to your `claude_desktop_config.json`:
174 |
175 | #### Install from GitHub and run with npx
176 |
177 | ```json
178 | {
179 | "mcpServers": {
180 | "quantitativeresearch": {
181 | "command": "npx",
182 | "args": [
183 | "-y",
184 | "github:tejpalvirk/quantitativeresearch"
185 | ]
186 | }
187 | }
188 | }
189 | ```
190 |
191 | #### Install globally and run directly
192 |
193 | First, install the package globally:
194 |
195 | ```bash
196 | npm install -g github:tejpalvirk/quantitativeresearch
197 | ```
198 |
199 | Then configure Claude Desktop:
200 |
201 | ```json
202 | {
203 | "mcpServers": {
204 | "quantitativeresearch": {
205 | "command": "contextmanager-quantitativeresearch"
206 | }
207 | }
208 | }
209 | ```
210 |
211 | #### docker
212 |
213 | ```json
214 | {
215 | "mcpServers": {
216 | "quantitativeresearch": {
217 | "command": "docker",
218 | "args": [
219 | "run",
220 | "--rm",
221 | "-i",
222 | "mcp/quantitativeresearch"
223 | ]
224 | }
225 | }
226 | }
227 | ```
228 |
229 | ## Building
230 |
231 | ### From Source
232 |
233 | ```bash
234 | # Clone the repository
235 | git clone https://github.com/tejpalvirk/contextmanager.git
236 | cd contextmanager
237 |
238 | # Install dependencies
239 | npm install
240 |
241 | # Build the server
242 | npm run build
243 |
244 | # Run the server
245 | cd quantitativeresearch
246 | node quantitativeresearch_index.js
247 | ```
248 |
249 | ### Docker:
250 |
251 | ```bash
252 | docker build -t mcp/quantitativeresearch -f quantitativeresearch/Dockerfile .
253 | ```
254 |
255 | ## License
256 |
257 | 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.
258 |
259 | ## Environment Variables
260 |
261 | The Quantitative Research MCP Server supports the following environment variables to customize where data is stored:
262 |
263 | - **MEMORY_FILE_PATH**: Path where the knowledge graph data will be stored
264 | - Can be absolute or relative (relative paths use current working directory)
265 | - Default: `./quantitativeresearch/memory.json`
266 |
267 | - **SESSIONS_FILE_PATH**: Path where session data will be stored
268 | - Can be absolute or relative (relative paths use current working directory)
269 | - Default: `./quantitativeresearch/sessions.json`
270 |
271 | Example usage:
272 |
273 | ```bash
274 | # Store data in the current directory
275 | MEMORY_FILE_PATH="./quantitative-memory.json" SESSIONS_FILE_PATH="./quantitative-sessions.json" npx github:tejpalvirk/contextmanager-quantitativeresearch
276 |
277 | # Store data in a specific location (absolute path)
278 | MEMORY_FILE_PATH="/path/to/data/quantitative-memory.json" npx github:tejpalvirk/contextmanager-quantitativeresearch
279 |
280 | # Store data in user's home directory
281 | MEMORY_FILE_PATH="$HOME/contextmanager/quantitative-memory.json" npx github:tejpalvirk/contextmanager-quantitativeresearch
282 | ```
```
--------------------------------------------------------------------------------
/developer/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "es2020",
4 | "module": "NodeNext",
5 | "moduleResolution": "NodeNext",
6 | "esModuleInterop": true,
7 | "strict": true,
8 | "outDir": "./",
9 | "declaration": true,
10 | "skipLibCheck": true
11 | },
12 | "include": ["./**/*.ts"],
13 | "exclude": []
14 | }
```
--------------------------------------------------------------------------------
/project/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "es2020",
4 | "module": "NodeNext",
5 | "moduleResolution": "NodeNext",
6 | "esModuleInterop": true,
7 | "strict": true,
8 | "outDir": "./",
9 | "declaration": true,
10 | "skipLibCheck": true
11 | },
12 | "include": ["./**/*.ts"],
13 | "exclude": []
14 | }
```
--------------------------------------------------------------------------------
/qualitativeresearch/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "es2020",
4 | "module": "NodeNext",
5 | "moduleResolution": "NodeNext",
6 | "esModuleInterop": true,
7 | "strict": true,
8 | "outDir": "./",
9 | "declaration": true,
10 | "skipLibCheck": true
11 | },
12 | "include": ["./**/*.ts"],
13 | "exclude": []
14 | }
```
--------------------------------------------------------------------------------
/quantitativeresearch/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "es2020",
4 | "module": "NodeNext",
5 | "moduleResolution": "NodeNext",
6 | "esModuleInterop": true,
7 | "strict": true,
8 | "outDir": "./",
9 | "declaration": true,
10 | "skipLibCheck": true
11 | },
12 | "include": ["./**/*.ts"],
13 | "exclude": []
14 | }
```
--------------------------------------------------------------------------------
/student/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "es2020",
4 | "module": "NodeNext",
5 | "moduleResolution": "NodeNext",
6 | "esModuleInterop": true,
7 | "strict": true,
8 | "outDir": "./",
9 | "declaration": true,
10 | "skipLibCheck": true
11 | },
12 | "include": ["./**/*.ts"],
13 | "exclude": []
14 | }
```
--------------------------------------------------------------------------------
/main/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "es2020",
4 | "module": "NodeNext",
5 | "moduleResolution": "NodeNext",
6 | "esModuleInterop": true,
7 | "strict": true,
8 | "outDir": "../dist/main",
9 | "declaration": true,
10 | "skipLibCheck": true
11 | },
12 | "include": ["./**/*.ts"],
13 | "exclude": ["node_modules", "dist"]
14 | }
```
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "es2020",
4 | "module": "NodeNext",
5 | "moduleResolution": "NodeNext",
6 | "esModuleInterop": true,
7 | "strict": true,
8 | "outDir": "./dist",
9 | "declaration": true,
10 | "skipLibCheck": true
11 | },
12 | "include": ["main/**/*.ts", "developer/**/*.ts", "student/**/*.ts", "qualitativeresearch/**/*.ts", "quantitativeresearch/**/*.ts", "project/**/*.ts"],
13 | "exclude": ["node_modules", "dist", "tests", "backup", "backup_built"]
14 | }
```
--------------------------------------------------------------------------------
/project/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
1 | FROM node:22.12-alpine AS builder
2 |
3 | COPY project /app
4 | COPY tsconfig.json /tsconfig.json
5 |
6 | WORKDIR /app
7 |
8 | RUN --mount=type=cache,target=/root/.npm npm install
9 |
10 | RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
11 |
12 | FROM node:22-alpine AS release
13 |
14 | COPY --from=builder /app/dist /app/dist
15 | COPY --from=builder /app/package.json /app/package.json
16 | COPY --from=builder /app/package-lock.json /app/package-lock.json
17 | COPY --from=builder /app/memory.json /app/memory.json
18 |
19 | ENV NODE_ENV=production
20 | ENV MEMORY_FILE_PATH=/app/memory.json
21 |
22 | WORKDIR /app
23 |
24 | RUN npm ci --ignore-scripts --omit-dev
25 |
26 | ENTRYPOINT ["node", "dist/project_index.js"]
```
--------------------------------------------------------------------------------
/student/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
1 | FROM node:22.12-alpine AS builder
2 |
3 | COPY student /app
4 | COPY tsconfig.json /tsconfig.json
5 |
6 | WORKDIR /app
7 |
8 | RUN --mount=type=cache,target=/root/.npm npm install
9 |
10 | RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
11 |
12 | FROM node:22-alpine AS release
13 |
14 | COPY --from=builder /app/dist /app/dist
15 | COPY --from=builder /app/package.json /app/package.json
16 | COPY --from=builder /app/package-lock.json /app/package-lock.json
17 | COPY --from=builder /app/memory.json /app/memory.json
18 |
19 | ENV NODE_ENV=production
20 | ENV MEMORY_FILE_PATH=/app/memory.json
21 |
22 | WORKDIR /app
23 |
24 | RUN npm ci --ignore-scripts --omit-dev
25 |
26 | ENTRYPOINT ["node", "dist/student_index.js"]
```
--------------------------------------------------------------------------------
/developer/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
1 | FROM node:22.12-alpine AS builder
2 |
3 | COPY developer /app
4 | COPY tsconfig.json /tsconfig.json
5 |
6 | WORKDIR /app
7 |
8 | RUN --mount=type=cache,target=/root/.npm npm install
9 |
10 | RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
11 |
12 | FROM node:22-alpine AS release
13 |
14 | COPY --from=builder /app/dist /app/dist
15 | COPY --from=builder /app/package.json /app/package.json
16 | COPY --from=builder /app/package-lock.json /app/package-lock.json
17 | COPY --from=builder /app/memory.json /app/memory.json
18 |
19 | ENV NODE_ENV=production
20 | ENV MEMORY_FILE_PATH=/app/memory.json
21 |
22 | WORKDIR /app
23 |
24 | RUN npm ci --ignore-scripts --omit-dev
25 |
26 | ENTRYPOINT ["node", "dist/developer_index.js"]
```
--------------------------------------------------------------------------------
/qualitativeresearch/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
1 | FROM node:22.12-alpine AS builder
2 |
3 | COPY qualitativeresearch /app
4 | COPY tsconfig.json /tsconfig.json
5 |
6 | WORKDIR /app
7 |
8 | RUN --mount=type=cache,target=/root/.npm npm install
9 |
10 | RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
11 |
12 | FROM node:22-alpine AS release
13 |
14 | COPY --from=builder /app/dist /app/dist
15 | COPY --from=builder /app/package.json /app/package.json
16 | COPY --from=builder /app/package-lock.json /app/package-lock.json
17 | COPY --from=builder /app/memory.json /app/memory.json
18 | COPY --from=builder /app/qualitative_research_memory.json /app/qualitative_research_memory.json
19 |
20 | ENV NODE_ENV=production
21 | ENV MEMORY_FILE_PATH=/app/memory.json
22 |
23 | WORKDIR /app
24 |
25 | RUN npm ci --ignore-scripts --omit-dev
26 |
27 | ENTRYPOINT ["node", "dist/qualitativeresearch_index.js"]
```
--------------------------------------------------------------------------------
/quantitativeresearch/Dockerfile:
--------------------------------------------------------------------------------
```dockerfile
1 | FROM node:22.12-alpine AS builder
2 |
3 | COPY quantitativeresearch /app
4 | COPY tsconfig.json /tsconfig.json
5 |
6 | WORKDIR /app
7 |
8 | RUN --mount=type=cache,target=/root/.npm npm install
9 |
10 | RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
11 |
12 | FROM node:22-alpine AS release
13 |
14 | COPY --from=builder /app/dist /app/dist
15 | COPY --from=builder /app/package.json /app/package.json
16 | COPY --from=builder /app/package-lock.json /app/package-lock.json
17 | COPY --from=builder /app/memory.json /app/memory.json
18 | COPY --from=builder /app/quantitative_research_memory.json /app/quantitative_research_memory.json
19 |
20 | ENV NODE_ENV=production
21 | ENV MEMORY_FILE_PATH=/app/memory.json
22 |
23 | WORKDIR /app
24 |
25 | RUN npm ci --ignore-scripts --omit-dev
26 |
27 | ENTRYPOINT ["node", "dist/quantitativeresearch_index.js"]
```
--------------------------------------------------------------------------------
/main/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "contextmanager-main",
3 | "version": "1.0.0",
4 | "description": "A unified MCP server that manages multiple domain-specific MCP servers",
5 | "type": "module",
6 | "main": "index.js",
7 | "bin": {
8 | "mcp-server-contextmanager": "index.js"
9 | },
10 | "files": [
11 | "index.js",
12 | "README.md",
13 | "descriptions/**/*"
14 | ],
15 | "scripts": {
16 | "build": "tsc && cp -r descriptions ../dist/main/",
17 | "start": "node index.js",
18 | "prepare": "npm run build"
19 | },
20 | "dependencies": {
21 | "@modelcontextprotocol/sdk": "^1.7.0",
22 | "zod": "^3.22.4",
23 | "yargs": "^17.7.2",
24 | "chalk": "^5.3.0"
25 | },
26 | "devDependencies": {
27 | "@types/node": "^18.15.3",
28 | "@types/yargs": "^17.0.32",
29 | "typescript": "^5.0.2"
30 | },
31 | "keywords": [
32 | "mcp",
33 | "claude",
34 | "context",
35 | "manager"
36 | ],
37 | "author": "tejpalvirk",
38 | "license": "MIT"
39 | }
```
--------------------------------------------------------------------------------
/main/descriptions/student_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "stu_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 6,
10 | "analysis": "Analyzed progress on studying for the final exam",
11 | "stageData": {
12 | "summary": "Reviewed course materials and completed practice problems",
13 | "duration": "2 hours",
14 | "course": "Data Structures"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 2: Concepts Learned Stage
22 | ```json
23 | {
24 | "sessionId": "stu_1234567890_abc123",
25 | "stage": "conceptsLearned",
26 | "stageNumber": 2,
27 | "totalStages": 6,
28 | "analysis": "Listed key concepts studied",
29 | "stageData": {
30 | "concepts": [
31 | "Balanced binary trees",
32 | "Red-black trees",
33 | "Tree traversal algorithms"
34 | ]
35 | },
36 | "nextStageNeeded": true,
37 | "isRevision": false
38 | }
39 | ```
40 |
41 | ### Final Stage: Assembly
42 | ```json
43 | {
44 | "sessionId": "stu_1234567890_abc123",
45 | "stage": "assembly",
46 | "stageNumber": 6,
47 | "totalStages": 6,
48 | "nextStageNeeded": false,
49 | "isRevision": false
50 | }
51 | ```
```
--------------------------------------------------------------------------------
/student/student_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "stu_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 6,
10 | "analysis": "Analyzed progress on studying for the final exam",
11 | "stageData": {
12 | "summary": "Reviewed course materials and completed practice problems",
13 | "duration": "2 hours",
14 | "course": "Data Structures"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 2: Concepts Learned Stage
22 | ```json
23 | {
24 | "sessionId": "stu_1234567890_abc123",
25 | "stage": "conceptsLearned",
26 | "stageNumber": 2,
27 | "totalStages": 6,
28 | "analysis": "Listed key concepts studied",
29 | "stageData": {
30 | "concepts": [
31 | "Balanced binary trees",
32 | "Red-black trees",
33 | "Tree traversal algorithms"
34 | ]
35 | },
36 | "nextStageNeeded": true,
37 | "isRevision": false
38 | }
39 | ```
40 |
41 | ### Final Stage: Assembly
42 | ```json
43 | {
44 | "sessionId": "stu_1234567890_abc123",
45 | "stage": "assembly",
46 | "stageNumber": 6,
47 | "totalStages": 6,
48 | "nextStageNeeded": false,
49 | "isRevision": false
50 | }
51 | ```
```
--------------------------------------------------------------------------------
/developer/developer_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "dev_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 6,
10 | "analysis": "Analyzed progress on the authentication system",
11 | "stageData": {
12 | "summary": "Completed the login functionality and fixed related bugs",
13 | "duration": "3 hours",
14 | "focus": "AuthSystem"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 2: Achievements Stage
22 | ```json
23 | {
24 | "sessionId": "dev_1234567890_abc123",
25 | "stage": "achievements",
26 | "stageNumber": 2,
27 | "totalStages": 6,
28 | "analysis": "Listed key accomplishments",
29 | "stageData": {
30 | "achievements": [
31 | "Implemented password reset functionality",
32 | "Fixed login redirect bug",
33 | "Added error handling for authentication failures"
34 | ]
35 | },
36 | "nextStageNeeded": true,
37 | "isRevision": false
38 | }
39 | ```
40 |
41 | ### Final Stage: Assembly
42 | ```json
43 | {
44 | "sessionId": "dev_1234567890_abc123",
45 | "stage": "assembly",
46 | "stageNumber": 6,
47 | "totalStages": 6,
48 | "nextStageNeeded": false,
49 | "isRevision": false
50 | }
51 | ```
```
--------------------------------------------------------------------------------
/main/descriptions/developer_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "dev_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 6,
10 | "analysis": "Analyzed progress on the authentication system",
11 | "stageData": {
12 | "summary": "Completed the login functionality and fixed related bugs",
13 | "duration": "3 hours",
14 | "focus": "AuthSystem"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 2: Achievements Stage
22 | ```json
23 | {
24 | "sessionId": "dev_1234567890_abc123",
25 | "stage": "achievements",
26 | "stageNumber": 2,
27 | "totalStages": 6,
28 | "analysis": "Listed key accomplishments",
29 | "stageData": {
30 | "achievements": [
31 | "Implemented password reset functionality",
32 | "Fixed login redirect bug",
33 | "Added error handling for authentication failures"
34 | ]
35 | },
36 | "nextStageNeeded": true,
37 | "isRevision": false
38 | }
39 | ```
40 |
41 | ### Final Stage: Assembly
42 | ```json
43 | {
44 | "sessionId": "dev_1234567890_abc123",
45 | "stage": "assembly",
46 | "stageNumber": 6,
47 | "totalStages": 6,
48 | "nextStageNeeded": false,
49 | "isRevision": false
50 | }
51 | ```
```
--------------------------------------------------------------------------------
/build-all-domains.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | # Script to build all domain packages
4 |
5 | # Store the current directory
6 | ORIGINAL_DIR=$(pwd)
7 |
8 | # Define the domains to build
9 | DOMAINS=("developer" "student" "project" "qualitativeresearch" "quantitativeresearch")
10 |
11 | # Print header
12 | echo "====================================="
13 | echo "Building all domain packages"
14 | echo "====================================="
15 |
16 | # Loop through each domain and build
17 | for domain in "${DOMAINS[@]}"; do
18 | echo ""
19 | echo "Building $domain..."
20 |
21 | # Check if domain directory exists
22 | if [ -d "$domain" ]; then
23 | # Navigate to the domain directory
24 | cd "$domain"
25 |
26 | # Run npm build
27 | npm run build
28 |
29 | # Capture the exit status
30 | BUILD_STATUS=$?
31 |
32 | # Check if build was successful
33 | if [ $BUILD_STATUS -eq 0 ]; then
34 | echo "✅ $domain built successfully"
35 | else
36 | echo "❌ $domain build failed with status $BUILD_STATUS"
37 | fi
38 |
39 | # Return to the original directory
40 | cd "$ORIGINAL_DIR"
41 | else
42 | echo "❌ $domain directory not found"
43 | fi
44 | done
45 |
46 | echo ""
47 | echo "====================================="
48 | echo "Build process completed"
49 | echo "====================================="
```
--------------------------------------------------------------------------------
/main/descriptions/project_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "proj_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 6,
10 | "analysis": "Analyzed progress on the marketing campaign project",
11 | "stageData": {
12 | "summary": "Completed the social media strategy components",
13 | "duration": "4 hours",
14 | "project": "Q4 Marketing Campaign"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 3: Task Updates Stage
22 | ```json
23 | {
24 | "sessionId": "proj_1234567890_abc123",
25 | "stage": "taskUpdates",
26 | "stageNumber": 3,
27 | "totalStages": 6,
28 | "analysis": "Updated status of in-progress tasks",
29 | "stageData": {
30 | "updates": [
31 | {
32 | "name": "Design Website Homepage",
33 | "status": "in_progress",
34 | "progress": "70%"
35 | },
36 | {
37 | "name": "Create Social Media Posts",
38 | "status": "completed"
39 | }
40 | ]
41 | },
42 | "nextStageNeeded": true,
43 | "isRevision": false
44 | }
45 | ```
46 |
47 | ### Final Stage: Assembly
48 | ```json
49 | {
50 | "sessionId": "proj_1234567890_abc123",
51 | "stage": "assembly",
52 | "stageNumber": 6,
53 | "totalStages": 6,
54 | "nextStageNeeded": false,
55 | "isRevision": false
56 | }
57 | ```
```
--------------------------------------------------------------------------------
/project/project_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "proj_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 6,
10 | "analysis": "Analyzed progress on the marketing campaign project",
11 | "stageData": {
12 | "summary": "Completed the social media strategy components",
13 | "duration": "4 hours",
14 | "project": "Q4 Marketing Campaign"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 3: Task Updates Stage
22 | ```json
23 | {
24 | "sessionId": "proj_1234567890_abc123",
25 | "stage": "taskUpdates",
26 | "stageNumber": 3,
27 | "totalStages": 6,
28 | "analysis": "Updated status of in-progress tasks",
29 | "stageData": {
30 | "updates": [
31 | {
32 | "name": "Design Website Homepage",
33 | "status": "in_progress",
34 | "progress": "70%"
35 | },
36 | {
37 | "name": "Create Social Media Posts",
38 | "status": "completed"
39 | }
40 | ]
41 | },
42 | "nextStageNeeded": true,
43 | "isRevision": false
44 | }
45 | ```
46 |
47 | ### Final Stage: Assembly
48 | ```json
49 | {
50 | "sessionId": "proj_1234567890_abc123",
51 | "stage": "assembly",
52 | "stageNumber": 6,
53 | "totalStages": 6,
54 | "nextStageNeeded": false,
55 | "isRevision": false
56 | }
57 | ```
```
--------------------------------------------------------------------------------
/student/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "contextmanager-student",
3 | "version": "1.0.0",
4 | "description": "MCP Server implementations for managing context of students",
5 | "type": "module",
6 | "main": "./index.js",
7 | "bin": {
8 | "contextmanager-student": "./index.js"
9 | },
10 | "files": [
11 | "index.js",
12 | "README.md",
13 | "*.txt"
14 | ],
15 | "scripts": {
16 | "build": "tsc && shx chmod +x index.js && cp student_*.txt ../main/descriptions",
17 | "prepare": "npm run build",
18 | "start": "node index.js"
19 | },
20 | "repository": {
21 | "type": "git",
22 | "url": "git+https://github.com/tejpalvirk/contextmanager.git"
23 | },
24 | "keywords": [
25 | "mcp",
26 | "claude",
27 | "context"
28 | ],
29 | "author": "Tejpal Virk",
30 | "license": "MIT",
31 | "bugs": {
32 | "url": "https://github.com/tejpalvirk/contextmanager/issues"
33 | },
34 | "homepage": "https://github.com/tejpalvirk/contextmanager#readme",
35 | "dependencies": {
36 | "@modelcontextprotocol/sdk": "^1.7.0",
37 | "zod": "^3.22.4",
38 | "yargs": "^17.7.2",
39 | "chalk": "^5.3.0"
40 | },
41 | "bundledDependencies": [
42 | "@modelcontextprotocol/sdk",
43 | "zod",
44 | "yargs",
45 | "chalk"
46 | ],
47 | "devDependencies": {
48 | "@types/node": "^18.15.3",
49 | "@types/yargs": "^17.0.33",
50 | "shx": "^0.3.4",
51 | "typescript": "^5.0.2"
52 | }
53 | }
```
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "contextmanager",
3 | "version": "1.0.0",
4 | "description": "MCP Server implementations for various domains",
5 | "type": "module",
6 | "bin": {
7 | "mcp-server-contextmanager": "./dist/main/index.js"
8 | },
9 | "files": [
10 | "dist",
11 | "README.md"
12 | ],
13 | "workspaces": [
14 | "main"
15 | ],
16 | "scripts": {
17 | "build": "tsc && shx chmod +x dist/main/index.js && cp -r main/descriptions dist/main/",
18 | "prepare": "npm run build",
19 | "start": "node dist/main/index.js"
20 | },
21 | "repository": {
22 | "type": "git",
23 | "url": "git+https://github.com/tejpalvirk/contextmanager.git"
24 | },
25 | "keywords": [
26 | "mcp",
27 | "claude",
28 | "context"
29 | ],
30 | "author": "tejpalvirk",
31 | "license": "MIT",
32 | "bugs": {
33 | "url": "https://github.com/tejpalvirk/contextmanager/issues"
34 | },
35 | "homepage": "https://github.com/tejpalvirk/contextmanager#readme",
36 | "dependencies": {
37 | "@modelcontextprotocol/sdk": "^1.7.0",
38 | "zod": "^3.22.4",
39 | "yargs": "^17.7.2",
40 | "chalk": "^5.3.0"
41 | },
42 | "bundledDependencies": [
43 | "@modelcontextprotocol/sdk",
44 | "zod",
45 | "yargs",
46 | "chalk"
47 | ],
48 | "devDependencies": {
49 | "@types/node": "^18.15.3",
50 | "@types/yargs": "^17.0.33",
51 | "shx": "^0.3.4",
52 | "typescript": "^5.0.2"
53 | }
54 | }
55 |
```
--------------------------------------------------------------------------------
/project/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "contextmanager-project",
3 | "version": "1.0.0",
4 | "description": "MCP Server implementations for handling context for project management",
5 | "type": "module",
6 | "main": "./index.js",
7 | "bin": {
8 | "contextmanager-project": "./index.js"
9 | },
10 | "files": [
11 | "index.js",
12 | "README.md",
13 | "*.txt"
14 | ],
15 | "scripts": {
16 | "build": "tsc && shx chmod +x index.js && cp project_*.txt ../main/descriptions",
17 | "prepare": "npm run build",
18 | "start": "node index.js"
19 | },
20 | "repository": {
21 | "type": "git",
22 | "url": "git+https://github.com/tejpalvirk/contextmanager.git"
23 | },
24 | "keywords": [
25 | "mcp",
26 | "claude",
27 | "context"
28 | ],
29 | "author": "Tejpal Virk",
30 | "license": "MIT",
31 | "bugs": {
32 | "url": "https://github.com/tejpalvirk/contextmanager/issues"
33 | },
34 | "homepage": "https://github.com/tejpalvirk/contextmanager#readme",
35 | "dependencies": {
36 | "@modelcontextprotocol/sdk": "^1.7.0",
37 | "zod": "^3.22.4",
38 | "yargs": "^17.7.2",
39 | "chalk": "^5.3.0"
40 | },
41 | "bundledDependencies": [
42 | "@modelcontextprotocol/sdk",
43 | "zod",
44 | "yargs",
45 | "chalk"
46 | ],
47 | "devDependencies": {
48 | "@types/node": "^18.15.3",
49 | "@types/yargs": "^17.0.33",
50 | "shx": "^0.3.4",
51 | "typescript": "^5.0.2"
52 | }
53 | }
```
--------------------------------------------------------------------------------
/developer/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "contextmanager-developer",
3 | "version": "1.0.0",
4 | "description": "MCP Server implementations for managing context of software development projects",
5 | "type": "module",
6 | "main": "./index.js",
7 | "bin": {
8 | "contextmanager-developer": "./index.js"
9 | },
10 | "files": [
11 | "index.js",
12 | "README.md",
13 | "*.txt"
14 | ],
15 | "scripts": {
16 | "build": "tsc && shx chmod +x index.js && cp developer_*.txt ../main/descriptions",
17 | "prepare": "npm run build",
18 | "start": "node index.js"
19 | },
20 | "repository": {
21 | "type": "git",
22 | "url": "git+https://github.com/tejpalvirk/contextmanager.git"
23 | },
24 | "keywords": [
25 | "mcp",
26 | "claude",
27 | "context"
28 | ],
29 | "author": "Tejpal Virk",
30 | "license": "MIT",
31 | "bugs": {
32 | "url": "https://github.com/tejpalvirk/contextmanager/issues"
33 | },
34 | "homepage": "https://github.com/tejpalvirk/contextmanager#readme",
35 | "dependencies": {
36 | "@modelcontextprotocol/sdk": "^1.7.0",
37 | "zod": "^3.22.4",
38 | "yargs": "^17.7.2",
39 | "chalk": "^5.3.0"
40 | },
41 | "bundledDependencies": [
42 | "@modelcontextprotocol/sdk",
43 | "zod",
44 | "yargs",
45 | "chalk"
46 | ],
47 | "devDependencies": {
48 | "@types/node": "^18.15.3",
49 | "@types/yargs": "^17.0.33",
50 | "shx": "^0.3.4",
51 | "typescript": "^5.0.2"
52 | }
53 | }
```
--------------------------------------------------------------------------------
/qualitativeresearch/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "contextmanager-qualitativeresearch",
3 | "version": "1.0.0",
4 | "description": "MCP Server implementations for managing context of qualitative research projects",
5 | "type": "module",
6 | "main": "./index.js",
7 | "bin": {
8 | "contextmanager-qualitativeresearch": "./index.js"
9 | },
10 | "files": [
11 | "index.js",
12 | "README.md",
13 | "*.txt"
14 | ],
15 | "scripts": {
16 | "build": "tsc && shx chmod +x index.js && cp qualitativeresearch_*.txt ../main/descriptions",
17 | "prepare": "npm run build",
18 | "start": "node index.js"
19 | },
20 | "repository": {
21 | "type": "git",
22 | "url": "git+https://github.com/tejpalvirk/contextmanager.git"
23 | },
24 | "keywords": [
25 | "mcp",
26 | "claude",
27 | "context"
28 | ],
29 | "author": "Tejpal Virk",
30 | "license": "MIT",
31 | "bugs": {
32 | "url": "https://github.com/tejpalvirk/contextmanager/issues"
33 | },
34 | "homepage": "https://github.com/tejpalvirk/contextmanager#readme",
35 | "dependencies": {
36 | "@modelcontextprotocol/sdk": "^1.7.0",
37 | "zod": "^3.22.4",
38 | "yargs": "^17.7.2",
39 | "chalk": "^5.3.0"
40 | },
41 | "bundledDependencies": [
42 | "@modelcontextprotocol/sdk",
43 | "zod",
44 | "yargs",
45 | "chalk"
46 | ],
47 | "devDependencies": {
48 | "@types/node": "^18.15.3",
49 | "@types/yargs": "^17.0.33",
50 | "shx": "^0.3.4",
51 | "typescript": "^5.0.2"
52 | }
53 | }
```
--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "qual_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 7,
10 | "analysis": "Analyzed progress on the interview data coding",
11 | "stageData": {
12 | "summary": "Completed initial coding of participant interviews",
13 | "duration": "3 hours",
14 | "project": "Health Behavior Study"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 5: Themes Stage
22 | ```json
23 | {
24 | "sessionId": "qual_1234567890_abc123",
25 | "stage": "themes",
26 | "stageNumber": 5,
27 | "totalStages": 7,
28 | "analysis": "Identified emerging themes",
29 | "stageData": {
30 | "themes": [
31 | {
32 | "name": "Perceived Barriers",
33 | "codes": ["time_constraints", "financial_concerns"],
34 | "description": "Factors preventing healthy behaviors"
35 | },
36 | {
37 | "name": "Social Support",
38 | "codes": ["family_influence", "peer_encouragement"],
39 | "description": "External motivation from relationships"
40 | }
41 | ]
42 | },
43 | "nextStageNeeded": true,
44 | "isRevision": false
45 | }
46 | ```
47 |
48 | ### Final Stage: Assembly
49 | ```json
50 | {
51 | "sessionId": "qual_1234567890_abc123",
52 | "stage": "assembly",
53 | "stageNumber": 7,
54 | "totalStages": 7,
55 | "nextStageNeeded": false,
56 | "isRevision": false
57 | }
58 | ```
```
--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "qual_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 7,
10 | "analysis": "Analyzed progress on the interview data coding",
11 | "stageData": {
12 | "summary": "Completed initial coding of participant interviews",
13 | "duration": "3 hours",
14 | "project": "Health Behavior Study"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 5: Themes Stage
22 | ```json
23 | {
24 | "sessionId": "qual_1234567890_abc123",
25 | "stage": "themes",
26 | "stageNumber": 5,
27 | "totalStages": 7,
28 | "analysis": "Identified emerging themes",
29 | "stageData": {
30 | "themes": [
31 | {
32 | "name": "Perceived Barriers",
33 | "codes": ["time_constraints", "financial_concerns"],
34 | "description": "Factors preventing healthy behaviors"
35 | },
36 | {
37 | "name": "Social Support",
38 | "codes": ["family_influence", "peer_encouragement"],
39 | "description": "External motivation from relationships"
40 | }
41 | ]
42 | },
43 | "nextStageNeeded": true,
44 | "isRevision": false
45 | }
46 | ```
47 |
48 | ### Final Stage: Assembly
49 | ```json
50 | {
51 | "sessionId": "qual_1234567890_abc123",
52 | "stage": "assembly",
53 | "stageNumber": 7,
54 | "totalStages": 7,
55 | "nextStageNeeded": false,
56 | "isRevision": false
57 | }
58 | ```
```
--------------------------------------------------------------------------------
/quantitativeresearch/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "contextmanager-quantitativeresearch",
3 | "version": "1.0.0",
4 | "description": "MCP Server implementations for managing context of quantitative research projects",
5 | "type": "module",
6 | "main": "./index.js",
7 | "bin": {
8 | "contextmanager-quantitativeresearch": "./index.js"
9 | },
10 | "files": [
11 | "index.js",
12 | "README.md",
13 | "*.txt"
14 | ],
15 | "scripts": {
16 | "build": "tsc && shx chmod +x index.js && cp quantitativeresearch_*.txt ../main/descriptions",
17 | "prepare": "npm run build",
18 | "start": "node index.js"
19 | },
20 | "repository": {
21 | "type": "git",
22 | "url": "git+https://github.com/tejpalvirk/contextmanager.git"
23 | },
24 | "keywords": [
25 | "mcp",
26 | "claude",
27 | "context"
28 | ],
29 | "author": "Tejpal Virk",
30 | "license": "MIT",
31 | "bugs": {
32 | "url": "https://github.com/tejpalvirk/contextmanager/issues"
33 | },
34 | "homepage": "https://github.com/tejpalvirk/contextmanager#readme",
35 | "dependencies": {
36 | "@modelcontextprotocol/sdk": "^1.7.0",
37 | "zod": "^3.22.4",
38 | "yargs": "^17.7.2",
39 | "chalk": "^5.3.0"
40 | },
41 | "bundledDependencies": [
42 | "@modelcontextprotocol/sdk",
43 | "zod",
44 | "yargs",
45 | "chalk"
46 | ],
47 | "devDependencies": {
48 | "@types/node": "^18.15.3",
49 | "@types/yargs": "^17.0.33",
50 | "shx": "^0.3.4",
51 | "typescript": "^5.0.2"
52 | }
53 | }
```
--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "quant_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 8,
10 | "analysis": "Analyzed progress on the multiple regression analysis",
11 | "stageData": {
12 | "summary": "Completed data preparation and initial statistical tests",
13 | "duration": "4 hours",
14 | "project": "Customer Satisfaction Study"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 3: New Analyses Stage
22 | ```json
23 | {
24 | "sessionId": "quant_1234567890_abc123",
25 | "stage": "newAnalyses",
26 | "stageNumber": 3,
27 | "totalStages": 8,
28 | "analysis": "Conducted statistical tests on prepared data",
29 | "stageData": {
30 | "analyses": [
31 | {
32 | "name": "Age_Income_Regression",
33 | "type": "multiple_regression",
34 | "result": "Significant relationship found",
35 | "pValue": "0.003",
36 | "variables": ["age", "income", "satisfaction_score"]
37 | },
38 | {
39 | "name": "Gender_Satisfaction_Ttest",
40 | "type": "t_test",
41 | "result": "No significant difference",
42 | "pValue": "0.42",
43 | "variables": ["gender", "satisfaction_score"]
44 | }
45 | ]
46 | },
47 | "nextStageNeeded": true,
48 | "isRevision": false
49 | }
50 | ```
51 |
52 | ### Final Stage: Assembly
53 | ```json
54 | {
55 | "sessionId": "quant_1234567890_abc123",
56 | "stage": "assembly",
57 | "stageNumber": 8,
58 | "totalStages": 8,
59 | "nextStageNeeded": false,
60 | "isRevision": false
61 | }
62 | ```
```
--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_endsession_examples.txt:
--------------------------------------------------------------------------------
```
1 | ## Usage examples
2 |
3 | ### Stage 1: Summary Stage
4 | ```json
5 | {
6 | "sessionId": "quant_1234567890_abc123",
7 | "stage": "summary",
8 | "stageNumber": 1,
9 | "totalStages": 8,
10 | "analysis": "Analyzed progress on the multiple regression analysis",
11 | "stageData": {
12 | "summary": "Completed data preparation and initial statistical tests",
13 | "duration": "4 hours",
14 | "project": "Customer Satisfaction Study"
15 | },
16 | "nextStageNeeded": true,
17 | "isRevision": false
18 | }
19 | ```
20 |
21 | ### Stage 3: New Analyses Stage
22 | ```json
23 | {
24 | "sessionId": "quant_1234567890_abc123",
25 | "stage": "newAnalyses",
26 | "stageNumber": 3,
27 | "totalStages": 8,
28 | "analysis": "Conducted statistical tests on prepared data",
29 | "stageData": {
30 | "analyses": [
31 | {
32 | "name": "Age_Income_Regression",
33 | "type": "multiple_regression",
34 | "result": "Significant relationship found",
35 | "pValue": "0.003",
36 | "variables": ["age", "income", "satisfaction_score"]
37 | },
38 | {
39 | "name": "Gender_Satisfaction_Ttest",
40 | "type": "t_test",
41 | "result": "No significant difference",
42 | "pValue": "0.42",
43 | "variables": ["gender", "satisfaction_score"]
44 | }
45 | ]
46 | },
47 | "nextStageNeeded": true,
48 | "isRevision": false
49 | }
50 | ```
51 |
52 | ### Final Stage: Assembly
53 | ```json
54 | {
55 | "sessionId": "quant_1234567890_abc123",
56 | "stage": "assembly",
57 | "stageNumber": 8,
58 | "totalStages": 8,
59 | "nextStageNeeded": false,
60 | "isRevision": false
61 | }
62 | ```
```
--------------------------------------------------------------------------------
/developer/index.d.ts:
--------------------------------------------------------------------------------
```typescript
1 | #!/usr/bin/env node
2 | interface Entity {
3 | name: string;
4 | entityType: string;
5 | observations: string[];
6 | }
7 | interface Relation {
8 | from: string;
9 | to: string;
10 | relationType: string;
11 | }
12 | interface KnowledgeGraph {
13 | entities: Entity[];
14 | relations: Relation[];
15 | }
16 | declare class KnowledgeGraphManager {
17 | private loadGraph;
18 | private saveGraph;
19 | initializeStatusAndPriority(): Promise<void>;
20 | getEntityStatus(entityName: string): Promise<string | null>;
21 | getEntityPriority(entityName: string): Promise<string | null>;
22 | setEntityStatus(entityName: string, statusValue: string): Promise<void>;
23 | setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
24 | createEntities(entities: Entity[]): Promise<Entity[]>;
25 | createRelations(relations: Relation[]): Promise<Relation[]>;
26 | addObservations(observations: {
27 | entityName: string;
28 | contents: string[];
29 | }[]): Promise<{
30 | entityName: string;
31 | addedObservations: string[];
32 | }[]>;
33 | deleteEntities(entityNames: string[]): Promise<void>;
34 | deleteObservations(deletions: {
35 | entityName: string;
36 | observations: string[];
37 | }[]): Promise<void>;
38 | deleteRelations(relations: Relation[]): Promise<void>;
39 | readGraph(): Promise<KnowledgeGraph>;
40 | searchNodes(query: string): Promise<KnowledgeGraph>;
41 | openNodes(names: string[]): Promise<KnowledgeGraph>;
42 | getProjectStatus(projectName: string): Promise<any>;
43 | getComponentContext(componentName: string): Promise<any>;
44 | getRelatedEntities(entityName: string, relationTypes?: string[]): Promise<any>;
45 | getDecisionHistory(projectName: string): Promise<any>;
46 | getMilestoneProgress(milestoneName: string): Promise<any>;
47 | }
48 | export { KnowledgeGraphManager };
49 |
```
--------------------------------------------------------------------------------
/developer/developer_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A powerful session initialization tool for software development contextual work.
2 | This tool starts a new development session and provides a comprehensive overview of the current development landscape.
3 | It retrieves recent sessions, active projects, high-priority tasks, and upcoming milestones to help focus the work effectively.
4 |
5 | When to use this tool:
6 | - Beginning a new development work session
7 | - Establishing context before diving into specific development work
8 |
9 | Key features:
10 | - Generates a unique session identifier for tracking activity
11 | - Retrieves and displays recent development sessions
12 | - Shows active software development projects (based on has_status relations)
13 | - Highlights high-priority tasks (based on has_priority relations)
14 | - Lists upcoming project milestones with progress tracking
15 | - Displays task dependencies and sequencing information
16 |
17 | Parameters explained:
18 | - No parameters required - the tool automatically retrieves all relevant context
19 |
20 | Return information:
21 | - Session ID: A unique identifier for this development session (format: dev_timestamp_randomstring)
22 | - Recent Development Sessions: Up to 3 most recent sessions with:
23 | * Date
24 | * Project focus
25 | * Session summary (truncated to 100 characters)
26 | - Active Projects: List of active software projects with their status
27 | - High-Priority Tasks: Tasks with high priority status (via has_priority relation) including:
28 | * Task name
29 | * Current status (via has_status relation)
30 | * Task sequencing information (preceding and following tasks)
31 | - Upcoming Milestones: Milestones with active status including:
32 | * Milestone name
33 | * Progress percentage based on completed tasks
34 |
35 | You should:
36 | 1. Use the generated session ID with the loadcontext tool to load specific entities
37 | 2. End the session with endsession when work is complete
```
--------------------------------------------------------------------------------
/main/descriptions/developer_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A powerful session initialization tool for software development contextual work.
2 | This tool starts a new development session and provides a comprehensive overview of the current development landscape.
3 | It retrieves recent sessions, active projects, high-priority tasks, and upcoming milestones to help focus the work effectively.
4 |
5 | When to use this tool:
6 | - Beginning a new development work session
7 | - Establishing context before diving into specific development work
8 |
9 | Key features:
10 | - Generates a unique session identifier for tracking activity
11 | - Retrieves and displays recent development sessions
12 | - Shows active software development projects (based on has_status relations)
13 | - Highlights high-priority tasks (based on has_priority relations)
14 | - Lists upcoming project milestones with progress tracking
15 | - Displays task dependencies and sequencing information
16 |
17 | Parameters explained:
18 | - No parameters required - the tool automatically retrieves all relevant context
19 |
20 | Return information:
21 | - Session ID: A unique identifier for this development session (format: dev_timestamp_randomstring)
22 | - Recent Development Sessions: Up to 3 most recent sessions with:
23 | * Date
24 | * Project focus
25 | * Session summary (truncated to 100 characters)
26 | - Active Projects: List of active software projects with their status
27 | - High-Priority Tasks: Tasks with high priority status (via has_priority relation) including:
28 | * Task name
29 | * Current status (via has_status relation)
30 | * Task sequencing information (preceding and following tasks)
31 | - Upcoming Milestones: Milestones with active status including:
32 | * Milestone name
33 | * Progress percentage based on completed tasks
34 |
35 | You should:
36 | 1. Use the generated session ID with the loadcontext tool to load specific entities
37 | 2. End the session with endsession when work is complete
```
--------------------------------------------------------------------------------
/qualitativeresearch/index.d.ts:
--------------------------------------------------------------------------------
```typescript
1 | #!/usr/bin/env node
2 | interface Entity {
3 | name: string;
4 | entityType: string;
5 | observations: string[];
6 | }
7 | interface Relation {
8 | from: string;
9 | to: string;
10 | relationType: string;
11 | }
12 | interface KnowledgeGraph {
13 | entities: Entity[];
14 | relations: Relation[];
15 | }
16 | declare class KnowledgeGraphManager {
17 | private loadGraph;
18 | private saveGraph;
19 | initializeStatusAndPriority(): Promise<void>;
20 | getEntityStatus(entityName: string): Promise<string | null>;
21 | getEntityPriority(entityName: string): Promise<string | null>;
22 | setEntityStatus(entityName: string, statusValue: string): Promise<void>;
23 | setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
24 | createEntities(entities: Entity[]): Promise<Entity[]>;
25 | createRelations(relations: Relation[]): Promise<Relation[]>;
26 | addObservations(observations: {
27 | entityName: string;
28 | contents: string[];
29 | }[]): Promise<{
30 | entityName: string;
31 | addedObservations: string[];
32 | }[]>;
33 | deleteEntities(entityNames: string[]): Promise<void>;
34 | deleteObservations(deletions: {
35 | entityName: string;
36 | observations: string[];
37 | }[]): Promise<void>;
38 | deleteRelations(relations: Relation[]): Promise<void>;
39 | readGraph(): Promise<KnowledgeGraph>;
40 | searchNodes(query: string): Promise<KnowledgeGraph>;
41 | openNodes(names: string[]): Promise<KnowledgeGraph>;
42 | getProjectOverview(projectName: string): Promise<any>;
43 | getParticipantProfile(participantName: string): Promise<any>;
44 | getThematicAnalysis(projectName: string): Promise<any>;
45 | getCodedData(codeName: string): Promise<any>;
46 | getResearchQuestionAnalysis(projectName: string): Promise<any>;
47 | getChronologicalData(projectName: string, dataType?: string): Promise<any>;
48 | getCodeCooccurrence(codeName: string): Promise<any>;
49 | getMemosByFocus(entityName: string): Promise<any>;
50 | getMethodologyDetails(projectName: string): Promise<any>;
51 | getRelatedEntities(entityName: string, relationTypes?: string[]): Promise<any>;
52 | }
53 | export { KnowledgeGraphManager };
54 |
```
--------------------------------------------------------------------------------
/student/index.d.ts:
--------------------------------------------------------------------------------
```typescript
1 | #!/usr/bin/env node
2 | declare const validEntityTypes: readonly ["course", "assignment", "exam", "concept", "resource", "note", "lecture", "project", "question", "term", "goal", "professor", "status", "priority"];
3 | type EntityType = typeof validEntityTypes[number];
4 | interface Entity {
5 | name: string;
6 | entityType: EntityType;
7 | observations: string[];
8 | embedding?: any;
9 | }
10 | interface Relation {
11 | from: string;
12 | to: string;
13 | relationType: string;
14 | observations?: string[];
15 | }
16 | interface KnowledgeGraph {
17 | entities: Entity[];
18 | relations: Relation[];
19 | }
20 | declare class KnowledgeGraphManager {
21 | private loadGraph;
22 | private saveGraph;
23 | initializeStatusAndPriority(): Promise<void>;
24 | getEntityStatus(entityName: string): Promise<string | null>;
25 | getEntityPriority(entityName: string): Promise<string | null>;
26 | setEntityStatus(entityName: string, statusValue: string): Promise<void>;
27 | setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
28 | createEntities(entities: Entity[]): Promise<KnowledgeGraph>;
29 | createRelations(relations: Relation[]): Promise<KnowledgeGraph>;
30 | addObservations(entityName: string, observations: string[]): Promise<KnowledgeGraph>;
31 | deleteEntities(entityNames: string[]): Promise<void>;
32 | deleteObservations(deletions: {
33 | entityName: string;
34 | observations: string[];
35 | }[]): Promise<void>;
36 | deleteRelations(relations: Relation[]): Promise<void>;
37 | readGraph(): Promise<KnowledgeGraph>;
38 | searchNodes(query: string): Promise<KnowledgeGraph>;
39 | openNodes(names: string[]): Promise<KnowledgeGraph>;
40 | getCourseOverview(courseName: string): Promise<any>;
41 | getUpcomingDeadlines(termName?: string, courseName?: string, daysAhead?: number): Promise<any>;
42 | getAssignmentStatus(assignmentName: string): Promise<any>;
43 | getExamPrep(examName: string): Promise<any>;
44 | findRelatedConcepts(conceptName: string, depth?: number): Promise<any>;
45 | trackLectureNotes(courseName: string): Promise<any>;
46 | getTermOverview(termName: string): Promise<any>;
47 | }
48 | export { KnowledgeGraphManager };
49 |
```
--------------------------------------------------------------------------------
/quantitativeresearch/index.d.ts:
--------------------------------------------------------------------------------
```typescript
1 | #!/usr/bin/env node
2 | declare function loadSessionStates(): Promise<Map<string, any[]>>;
3 | declare function saveSessionStates(sessionsMap: Map<string, any[]>): Promise<void>;
4 | interface Entity {
5 | name: string;
6 | entityType: string;
7 | observations: string[];
8 | }
9 | interface Relation {
10 | from: string;
11 | to: string;
12 | relationType: string;
13 | }
14 | interface KnowledgeGraph {
15 | entities: Entity[];
16 | relations: Relation[];
17 | }
18 | declare class KnowledgeGraphManager {
19 | private loadGraph;
20 | private saveGraph;
21 | createEntities(entities: Entity[]): Promise<Entity[]>;
22 | createRelations(relations: Relation[]): Promise<Relation[]>;
23 | addObservations(observations: {
24 | entityName: string;
25 | contents: string[];
26 | }[]): Promise<{
27 | entityName: string;
28 | addedObservations: string[];
29 | }[]>;
30 | deleteEntities(entityNames: string[]): Promise<void>;
31 | deleteObservations(deletions: {
32 | entityName: string;
33 | observations: string[];
34 | }[]): Promise<void>;
35 | deleteRelations(relations: Relation[]): Promise<void>;
36 | readGraph(): Promise<KnowledgeGraph>;
37 | searchNodes(query: string): Promise<KnowledgeGraph>;
38 | openNodes(names: string[]): Promise<KnowledgeGraph>;
39 | getProjectOverview(projectName: string): Promise<any>;
40 | getDatasetAnalysis(datasetName: string): Promise<any>;
41 | getHypothesisTests(projectName: string, hypothesisName?: string): Promise<any>;
42 | getVariableRelationships(variableName: string): Promise<any>;
43 | getStatisticalResults(projectName: string, testType?: string): Promise<any>;
44 | getVisualizationGallery(projectName: string, datasetName?: string): Promise<any>;
45 | getModelPerformance(modelName: string): Promise<any>;
46 | getResearchQuestionResults(questionName: string): Promise<any>;
47 | getVariableDistribution(variableName: string, datasetName?: string): Promise<any>;
48 | initializeStatusAndPriority(): Promise<void>;
49 | getEntityStatus(entityName: string): Promise<string | null>;
50 | getEntityPriority(entityName: string): Promise<string | null>;
51 | setEntityStatus(entityName: string, statusValue: string): Promise<void>;
52 | setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
53 | }
54 | export { KnowledgeGraphManager, loadSessionStates, saveSessionStates };
55 |
```
--------------------------------------------------------------------------------
/project/index.d.ts:
--------------------------------------------------------------------------------
```typescript
1 | #!/usr/bin/env node
2 | declare const validEntityTypes: readonly ["project", "task", "milestone", "resource", "teamMember", "note", "document", "issue", "risk", "decision", "dependency", "component", "stakeholder", "change", "status", "priority"];
3 | type EntityType = typeof validEntityTypes[number];
4 | interface Entity {
5 | name: string;
6 | entityType: EntityType;
7 | observations: string[];
8 | embedding?: Embedding;
9 | }
10 | interface Relation {
11 | from: string;
12 | to: string;
13 | relationType: string;
14 | observations?: string[];
15 | }
16 | interface KnowledgeGraph {
17 | entities: Entity[];
18 | relations: Relation[];
19 | }
20 | type Embedding = number[];
21 | declare class KnowledgeGraphManager {
22 | loadGraph(): Promise<KnowledgeGraph>;
23 | private saveGraph;
24 | initializeStatusAndPriority(): Promise<void>;
25 | getEntityStatus(entityName: string): Promise<string | null>;
26 | getEntityPriority(entityName: string): Promise<string | null>;
27 | setEntityStatus(entityName: string, statusValue: string): Promise<void>;
28 | setEntityPriority(entityName: string, priorityValue: string): Promise<void>;
29 | createEntities(entities: Entity[]): Promise<KnowledgeGraph>;
30 | createRelations(relations: Relation[]): Promise<KnowledgeGraph>;
31 | addObservations(entityName: string, observations: string[]): Promise<KnowledgeGraph>;
32 | deleteEntities(entityNames: string[]): Promise<void>;
33 | deleteObservations(deletions: {
34 | entityName: string;
35 | observations: string[];
36 | }[]): Promise<void>;
37 | deleteRelations(relations: Relation[]): Promise<void>;
38 | readGraph(): Promise<KnowledgeGraph>;
39 | searchNodes(query: string): Promise<KnowledgeGraph>;
40 | openNodes(names: string[]): Promise<KnowledgeGraph>;
41 | getProjectOverview(projectName: string): Promise<any>;
42 | getTaskDependencies(taskName: string, depth?: number): Promise<any>;
43 | private getTaskAssignee;
44 | private calculateCriticalPath;
45 | getTeamMemberAssignments(teamMemberName: string): Promise<any>;
46 | getMilestoneProgress(projectName: string, milestoneName?: string): Promise<any>;
47 | getProjectTimeline(projectName: string): Promise<any>;
48 | getResourceAllocation(projectName: string, resourceName?: string): Promise<any>;
49 | getProjectRisks(projectName: string): Promise<any>;
50 | findRelatedProjects(projectName: string, depth?: number): Promise<any>;
51 | getDecisionLog(projectName: string): Promise<any>;
52 | getProjectHealth(projectName: string): Promise<any>;
53 | private generateHealthRecommendations;
54 | }
55 | export { KnowledgeGraphManager };
56 |
```
--------------------------------------------------------------------------------
/main/descriptions/common_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A powerful session initialization tool for establishing context in domain-specific work.
2 | This tool starts a new session and provides a comprehensive overview of the current landscape.
3 | It retrieves recent sessions, active work items, high-priority elements, and upcoming deadlines to help focus work effectively.
4 |
5 | When to use this tool:
6 | - Beginning a new work session in your domain
7 | - Getting oriented to your current state across multiple projects/courses/research
8 | - Planning which elements to focus on in the current session
9 |
10 | Key features:
11 | - Generates a unique session identifier for tracking activities
12 | - Retrieves and displays recent sessions with summaries
13 | - Formats domain-specific information in a structured, easy-to-read format
14 |
15 | Parameters explained:
16 | - No parameters required - the tool automatically retrieves all relevant context
17 |
18 | Return information:
19 | - Session ID: A unique identifier for this session
20 | - Recent Sessions: Up to 3 most recent sessions with date, focus area, and session summary (truncated for readability)
21 | - Domain-Specific Elements:
22 | * Developer:
23 | - Active Projects: Software projects with status
24 | - High-Priority Tasks: Task name, status, assigned developer
25 | - Upcoming Milestones: Milestone name, due date
26 | * Student:
27 | - Active Courses: Currently enrolled courses
28 | - Upcoming Deadlines: Assignment/exam name, course, due date, days remaining
29 | - Recently Studied Concepts: List of recently studied topics
30 | * Qualitative Research:
31 | - Active Research Projects: Project name, status, research phase
32 | - Sample Participants: Participant name, demographic information, participation status
33 | - Top Codes: Code name, reference count, code group
34 | - Recent Memos: Memo name, creation date, memo type, brief summary
35 | * Quantitative Research:
36 | - Active Research Projects: Project name, status
37 | - Available Datasets: Dataset name, type of data, associated project
38 | - Research Questions: Question text, associated project
39 | - Recent Statistical Models: Model name, model type, performance metrics
40 | - Recent Visualizations: Name, type (chart, plot, etc.), associated dataset
41 | * Project Management:
42 | - Active Projects: Project name, status, deadline information
43 | - High-Priority Tasks: Task name, associated project, status, assignee
44 | - Upcoming Milestones: Name, associated project, due date, completion percentage
45 | - Project Health Summary: Project name, health status, health score, issue count, risk count
46 | - Top Project Risks: Risk name, associated project, severity level, impact assessment
47 |
48 | Session workflow:
49 | 1. Starting a session creates a session identifier in the appropriate domain
50 | 2. This session can be referenced when loading context with loadcontext
51 | 3. Session activities are tracked for later recording
52 | 4. Sessions should be ended with endsession to record progress and accomplishments
53 | 5. Session history becomes available for future startsession calls
54 |
55 | You should:
56 | 1. Begin each focused work period with startsession
57 | 2. Review the provided context to determine your focus
58 | 3. Choose specific elements to work on
59 | 4. Use the generated session ID with the loadcontext tool to load specific entities
60 | 5. End the session with endsession when work is complete
```
--------------------------------------------------------------------------------
/main/descriptions/common_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A precise tool for removing elements from domain-specific knowledge graphs.
2 | This tool allows targeted deletion of entities, relationships between entities, or specific observations from existing entities.
3 | It helps maintain an accurate and current representation of the context as work evolves.
4 |
5 | When to use this tool:
6 | - Removing deprecated, completed, or incorrect entities
7 | - Deleting obsolete or erroneous relationships between entities
8 | - Pruning outdated observations that no longer apply
9 | - Correcting errors in the knowledge graph
10 | - Cleaning up test or prototype elements
11 | - Reorganizing your domain structure by removing and recreating elements
12 |
13 | Key features:
14 | - Three distinct deletion operation types (entities, relations, observations)
15 | - Cascading deletion for entities (automatically removes related relations)
16 | - Precise deletion of specific observations without removing entire entities
17 | - Targeted relation removal with exact matching on from/to/type
18 | - Batch operations for efficient cleanup
19 | - JSON-formatted response with operation results
20 | - Secure validation before deletion
21 | - Clear error messages when operations fail
22 |
23 | Parameters explained:
24 | - type: The deletion operation type to perform, which must be one of:
25 | * "entities" - Remove entities and their relations
26 | * "relations" - Remove specific relationships between entities
27 | * "observations" - Remove specific observations from entities
28 | - data: Operation-specific data structure:
29 | * For "entities": Array of entity names to delete
30 | - Example: ["ProjectX", "Task123", "Course101"]
31 | * For "relations": Array of objects with { from, to, relationType }
32 | - Example: [{ "from": "ProjectX", "to": "Task123", "relationType": "contains" }]
33 | * For "observations": Array of objects with { entityName, observations[] }
34 | - Example: [{ "entityName": "ProjectX", "observations": ["status:completed", "priority:high"] }]
35 |
36 | Deletion behavior by type:
37 | - "entities": Completely removes the specified entities and any relations where they appear
38 | - "relations": Removes only the exact relations specified, matching on all three attributes
39 | - "observations": Removes specific observations from entities while preserving the entities themselves
40 |
41 | Safety considerations:
42 | - Entity deletion cascades to relations, so be careful when deleting key entities
43 | - There is no "undo" operation, so confirm deletions carefully
44 | - Partial graph information can lead to inconsistent views
45 | - Relations require entities on both ends to exist
46 | - Consider exporting or backing up your knowledge graph before large-scale deletions
47 |
48 | Return information:
49 | - JSON response indicating success or failure
50 | - For successful operations:
51 | * Success flag set to true
52 | * Confirmation message with count of deleted items
53 | - For failed operations:
54 | * Success flag set to false
55 | * Error message describing the issue
56 |
57 | You should:
58 | 1. Identify the specific elements that need to be removed
59 | 2. Choose the appropriate deletion type (entities, relations, or observations)
60 | 3. Structure your data according to the deletion type's requirements
61 | 4. Start with the most specific deletions (observations) before broader ones
62 | 5. Consider documenting major deletions as observations on related entities
63 | 6. When removing an entire project/course/research component, first delete its sub-elements for cleaner removal
```
--------------------------------------------------------------------------------
/developer/developer_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A versatile tool for removing elements from the software development knowledge graph.
2 | This tool allows precise deletion of entities, relationships between entities, or specific observations from existing entities.
3 | It helps maintain an accurate and current representation of the development context as projects evolve.
4 |
5 | When to use this tool:
6 | - Removing deprecated or completed project components
7 | - Deleting obsolete relationships between development entities
8 | - Pruning outdated observations that no longer apply
9 | - Correcting errors in the knowledge graph
10 | - Cleaning up testing or prototype entities
11 | - Maintaining graph accuracy as project scope changes
12 | - Removing sensitive or confidential information
13 | - Archiving completed projects or components
14 | - Removing task sequencing relationships
15 | - Updating status or priority relationships
16 |
17 | Key features:
18 | - Three distinct deletion operation types (entities, relations, observations)
19 | - Cascading deletion for entities (automatically removes related relations)
20 | - Precise deletion of specific observations without removing entire entities
21 | - Targeted relation removal with exact matching on from/to/type
22 | - Batch operations for efficient cleanup
23 | - JSON-formatted response with operation results
24 | - Secure validation before deletion
25 |
26 | Parameters explained:
27 | - type: The deletion operation type to perform, which must be one of:
28 | * "entities" - Remove development entities and their relations
29 | * "relations" - Remove specific relationships between entities
30 | * "observations" - Remove specific observations from entities
31 | - data: Operation-specific data structure:
32 | * For "entities": Array of entity names to delete
33 | * For "relations": Array of objects with { from, to, relationType }
34 | * For "observations": Array of objects with { entityName, observations[] }
35 |
36 | Deletion behavior by type:
37 | - "entities": Completely removes the specified entities and any relations where they appear
38 | - "relations": Removes only the exact relations specified, matching on all three attributes
39 | - "observations": Removes specific observations from entities while preserving the entities themselves
40 |
41 | Safety considerations:
42 | - Entity deletion cascades to relations, so be careful when deleting key entities
43 | - There is no "undo" operation, so confirm deletions carefully
44 | - Partial graph information can lead to inconsistent views
45 | - Relations require entities on both ends to exist
46 | - Instead of deleting status or priority entities, prefer updating them using appropriate tools
47 | - Deleting task sequencing relations may disrupt project planning and dependencies
48 |
49 | You should:
50 | 1. Identify the specific elements that need to be removed
51 | 2. Choose the appropriate deletion type (entities, relations, or observations)
52 | 3. Structure your data according to the deletion type's requirements
53 | 4. Start with the most specific deletions (observations) before broader ones
54 | 5. Verify the entities or relations exist before attempting deletion
55 | 6. To update status or priority, create new has_status or has_priority relations rather than deleting old ones
56 | 7. When removing task sequencing, consider how it affects other tasks and milestones
57 | 8. Check the operation result to confirm successful deletion
58 | 9. Consider documenting major deletions as observations on related entities
59 | 10. When removing an entire project, first delete its components for cleaner removal
```
--------------------------------------------------------------------------------
/main/descriptions/developer_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A versatile tool for removing elements from the software development knowledge graph.
2 | This tool allows precise deletion of entities, relationships between entities, or specific observations from existing entities.
3 | It helps maintain an accurate and current representation of the development context as projects evolve.
4 |
5 | When to use this tool:
6 | - Removing deprecated or completed project components
7 | - Deleting obsolete relationships between development entities
8 | - Pruning outdated observations that no longer apply
9 | - Correcting errors in the knowledge graph
10 | - Cleaning up testing or prototype entities
11 | - Maintaining graph accuracy as project scope changes
12 | - Removing sensitive or confidential information
13 | - Archiving completed projects or components
14 | - Removing task sequencing relationships
15 | - Updating status or priority relationships
16 |
17 | Key features:
18 | - Three distinct deletion operation types (entities, relations, observations)
19 | - Cascading deletion for entities (automatically removes related relations)
20 | - Precise deletion of specific observations without removing entire entities
21 | - Targeted relation removal with exact matching on from/to/type
22 | - Batch operations for efficient cleanup
23 | - JSON-formatted response with operation results
24 | - Secure validation before deletion
25 |
26 | Parameters explained:
27 | - type: The deletion operation type to perform, which must be one of:
28 | * "entities" - Remove development entities and their relations
29 | * "relations" - Remove specific relationships between entities
30 | * "observations" - Remove specific observations from entities
31 | - data: Operation-specific data structure:
32 | * For "entities": Array of entity names to delete
33 | * For "relations": Array of objects with { from, to, relationType }
34 | * For "observations": Array of objects with { entityName, observations[] }
35 |
36 | Deletion behavior by type:
37 | - "entities": Completely removes the specified entities and any relations where they appear
38 | - "relations": Removes only the exact relations specified, matching on all three attributes
39 | - "observations": Removes specific observations from entities while preserving the entities themselves
40 |
41 | Safety considerations:
42 | - Entity deletion cascades to relations, so be careful when deleting key entities
43 | - There is no "undo" operation, so confirm deletions carefully
44 | - Partial graph information can lead to inconsistent views
45 | - Relations require entities on both ends to exist
46 | - Instead of deleting status or priority entities, prefer updating them using appropriate tools
47 | - Deleting task sequencing relations may disrupt project planning and dependencies
48 |
49 | You should:
50 | 1. Identify the specific elements that need to be removed
51 | 2. Choose the appropriate deletion type (entities, relations, or observations)
52 | 3. Structure your data according to the deletion type's requirements
53 | 4. Start with the most specific deletions (observations) before broader ones
54 | 5. Verify the entities or relations exist before attempting deletion
55 | 6. To update status or priority, create new has_status or has_priority relations rather than deleting old ones
56 | 7. When removing task sequencing, consider how it affects other tasks and milestones
57 | 8. Check the operation result to confirm successful deletion
58 | 9. Consider documenting major deletions as observations on related entities
59 | 10. When removing an entire project, first delete its components for cleaner removal
```
--------------------------------------------------------------------------------
/developer/developer_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for retrieving rich, contextual information about specific software development entities, providing formatted details based on entity type.
2 |
3 | When to use this tool:
4 | - Retrieving detailed information about a specific project, component, feature, or other development entity
5 | - Exploring relationships between software development entities
6 | - Examining project status, components, features, tasks, and issues
7 | - Understanding the structure and elements of a software component
8 | - Reviewing milestone progress and completion metrics
9 | - Examining task details, dependencies, and task sequencing
10 | - Exploring feature implementations and technical requirements
11 | - Analyzing the project knowledge graph to understand entity relationships
12 | - Preparing for work on a specific entity by establishing context
13 |
14 | Key features:
15 | - Provides contextually rich, formatted information about software development entities
16 | - Adapts output format based on entity type (project, component, feature, task, etc.)
17 | - Presents both direct entity information and related elements
18 | - Organizes information in a clear, hierarchical structure
19 | - Automatically identifies entity relationships and presents them systematically
20 |
21 | Parameters explained:
22 | - entityName: Required - The name of the entity to retrieve context for
23 | * Example: "AuthService", "UserProfile", "LoginFeature"
24 | - entityType: Optional - The type of entity being retrieved
25 | * Default: "project"
26 | * Accepted values: "project", "component", "task", "issue", "milestone", "decision", "feature", "technology", "documentation", "dependency", "developer"
27 | * Helps the system format the output appropriately
28 | - sessionId: Optional - The current session identifier
29 | * Typically provided by startsession
30 | * Used for tracking entity views within the session
31 |
32 | Each entity type returns specialized context information:
33 | - Project: Shows status, components, active features, active tasks, active issues, upcoming milestones, team members, recent decisions, and task sequencing information
34 | - Component: Displays parent projects, implemented features, technologies used, active issues, documentation, and dependencies
35 | - Feature: Shows status, priority, description, requirements, implementing components, and related tasks
36 | - Task: Displays project, status, priority, description, related issues, blocking items, preceding tasks, and following tasks
37 | - Milestone: Shows status, progress percentage, and tasks grouped by completion status (complete, active, inactive)
38 | - Other Entity Types: Shows observations and both incoming and outgoing relationships within the knowledge graph
39 |
40 | You should:
41 | - Specify the exact entity name for accurate retrieval
42 | - Provide the entity type when possible for optimally formatted results
43 | - Start with project entities to get a high-level overview
44 | - Explore components to understand technical architecture
45 | - Examine features to see functional requirements and implementations
46 | - Review tasks to understand specific work items and their status
47 | - Analyze task sequencing to understand dependencies and workflow
48 | - Use status information to focus on active or incomplete work
49 | - Consider priority information when planning next steps
50 | - Use milestone context to track progress toward completion
51 | - After retrieving context, follow up on specific entities of interest
52 | - Use in conjunction with startsession to maintain session tracking
53 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/main/descriptions/developer_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for retrieving rich, contextual information about specific software development entities, providing formatted details based on entity type.
2 |
3 | When to use this tool:
4 | - Retrieving detailed information about a specific project, component, feature, or other development entity
5 | - Exploring relationships between software development entities
6 | - Examining project status, components, features, tasks, and issues
7 | - Understanding the structure and elements of a software component
8 | - Reviewing milestone progress and completion metrics
9 | - Examining task details, dependencies, and task sequencing
10 | - Exploring feature implementations and technical requirements
11 | - Analyzing the project knowledge graph to understand entity relationships
12 | - Preparing for work on a specific entity by establishing context
13 |
14 | Key features:
15 | - Provides contextually rich, formatted information about software development entities
16 | - Adapts output format based on entity type (project, component, feature, task, etc.)
17 | - Presents both direct entity information and related elements
18 | - Organizes information in a clear, hierarchical structure
19 | - Automatically identifies entity relationships and presents them systematically
20 |
21 | Parameters explained:
22 | - entityName: Required - The name of the entity to retrieve context for
23 | * Example: "AuthService", "UserProfile", "LoginFeature"
24 | - entityType: Optional - The type of entity being retrieved
25 | * Default: "project"
26 | * Accepted values: "project", "component", "task", "issue", "milestone", "decision", "feature", "technology", "documentation", "dependency", "developer"
27 | * Helps the system format the output appropriately
28 | - sessionId: Optional - The current session identifier
29 | * Typically provided by startsession
30 | * Used for tracking entity views within the session
31 |
32 | Each entity type returns specialized context information:
33 | - Project: Shows status, components, active features, active tasks, active issues, upcoming milestones, team members, recent decisions, and task sequencing information
34 | - Component: Displays parent projects, implemented features, technologies used, active issues, documentation, and dependencies
35 | - Feature: Shows status, priority, description, requirements, implementing components, and related tasks
36 | - Task: Displays project, status, priority, description, related issues, blocking items, preceding tasks, and following tasks
37 | - Milestone: Shows status, progress percentage, and tasks grouped by completion status (complete, active, inactive)
38 | - Other Entity Types: Shows observations and both incoming and outgoing relationships within the knowledge graph
39 |
40 | You should:
41 | - Specify the exact entity name for accurate retrieval
42 | - Provide the entity type when possible for optimally formatted results
43 | - Start with project entities to get a high-level overview
44 | - Explore components to understand technical architecture
45 | - Examine features to see functional requirements and implementations
46 | - Review tasks to understand specific work items and their status
47 | - Analyze task sequencing to understand dependencies and workflow
48 | - Use status information to focus on active or incomplete work
49 | - Consider priority information when planning next steps
50 | - Use milestone context to track progress toward completion
51 | - After retrieving context, follow up on specific entities of interest
52 | - Use in conjunction with startsession to maintain session tracking
53 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/main/descriptions/student_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for initializing a new academic study session.
2 | This tool starts a new study session and provides a comprehensive overview of your current educational landscape.
3 | It retrieves recent study sessions, active courses, upcoming deadlines, and recently studied concepts to help focus your learning effectively.
4 |
5 | When to use this tool:
6 | - Beginning a new study session or learning period
7 | - Getting oriented in your current academic state
8 | - Planning which courses or assignments to focus on
9 | - Reviewing recent study activity and progress
10 | - Checking upcoming deadlines for assignments and exams
11 | - Deciding which concepts need attention
12 | - Establishing context before diving into specific study work
13 | - Creating a structured record of your study activity
14 | - Identifying high-priority assignments that need attention
15 | - Tracking progress through status information
16 |
17 | Key features:
18 | - Generates a unique study session identifier for tracking activity
19 | - Retrieves and displays your most recent study sessions
20 | - Shows active courses (based on has_status relations)
21 | - Highlights high-priority assignments (based on has_priority relations)
22 | - Identifies assignment status (not_started, in_progress, complete)
23 | - Highlights upcoming assignment and exam deadlines
24 | - Lists recently studied concepts for review
25 | - Formats information in a structured, easy-to-read format
26 | - Provides seamless integration with loadcontext tool
27 | - Stores study session data for historical record keeping
28 |
29 | Parameters explained:
30 | - No parameters required - the tool automatically retrieves all relevant context
31 |
32 | Return information:
33 | - Session ID: A unique identifier for this study session (format: stud_timestamp_randomstring)
34 | - Recent Study Sessions: Up to 3 most recent sessions with:
35 | * Date
36 | * Course focus
37 | * Study session summary (truncated for readability)
38 | - Active Courses: List of courses with active status (via has_status relation), including:
39 | * Course name
40 | * Course code or description
41 | * Status via has_status relation
42 | * Priority if assigned via has_priority relation
43 | - High-Priority Assignments: Assignments with high priority status (via has_priority relation), including:
44 | * Assignment name
45 | * Current status (not_started, in_progress, complete)
46 | * Course it belongs to
47 | * Due date if available
48 | - Upcoming Deadlines: Assignment and exam deadlines in the next 14 days, including:
49 | * Assignment/exam name
50 | * Course it belongs to
51 | * Due date
52 | * Days remaining until due
53 | * Status (not_started, in_progress, complete)
54 | - Recently Studied Concepts: List of concepts you've recently studied
55 |
56 | Session workflow:
57 | 1. Starting a session creates a session identifier in the student domain
58 | 2. This session can be referenced when loading course context with loadcontext
59 | 3. Session activities are tracked for later recording
60 | 4. Sessions should be ended with endsession to record learning progress
61 | 5. Session history becomes available for future startsession calls
62 |
63 | Status and Priority:
64 | - Course status is retrieved through has_status relations (not_started, in_progress, complete)
65 | - Assignment priority is retrieved through has_priority relations (low, high)
66 | - This information helps you prioritize your study activities
67 |
68 | You should:
69 | 1. Begin each focused study period with startsession
70 | 2. Review the provided context to determine your study focus
71 | 3. Prioritize high-priority assignments with upcoming deadlines
72 | 4. Focus on incomplete assignments (not_started or in_progress status)
73 | 5. Choose a specific course, assignment, or concept to work on
74 | 6. Use the generated session ID with the loadcontext tool to load specific entities
75 | 7. Complete your study work on your selected focus area
76 | 8. End the session with endsession when work is complete
77 | 9. Record concepts learned, assignment status updates, and study accomplishments
78 | 10. Use the session history to maintain continuity between study periods
```
--------------------------------------------------------------------------------
/student/student_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for initializing a new academic study session.
2 | This tool starts a new study session and provides a comprehensive overview of your current educational landscape.
3 | It retrieves recent study sessions, active courses, upcoming deadlines, and recently studied concepts to help focus your learning effectively.
4 |
5 | When to use this tool:
6 | - Beginning a new study session or learning period
7 | - Getting oriented in your current academic state
8 | - Planning which courses or assignments to focus on
9 | - Reviewing recent study activity and progress
10 | - Checking upcoming deadlines for assignments and exams
11 | - Deciding which concepts need attention
12 | - Establishing context before diving into specific study work
13 | - Creating a structured record of your study activity
14 | - Identifying high-priority assignments that need attention
15 | - Tracking progress through status information
16 |
17 | Key features:
18 | - Generates a unique study session identifier for tracking activity
19 | - Retrieves and displays your most recent study sessions
20 | - Shows active courses (based on has_status relations)
21 | - Highlights high-priority assignments (based on has_priority relations)
22 | - Identifies assignment status (not_started, in_progress, complete)
23 | - Highlights upcoming assignment and exam deadlines
24 | - Lists recently studied concepts for review
25 | - Formats information in a structured, easy-to-read format
26 | - Provides seamless integration with loadcontext tool
27 | - Stores study session data for historical record keeping
28 |
29 | Parameters explained:
30 | - No parameters required - the tool automatically retrieves all relevant context
31 |
32 | Return information:
33 | - Session ID: A unique identifier for this study session (format: stud_timestamp_randomstring)
34 | - Recent Study Sessions: Up to 3 most recent sessions with:
35 | * Date
36 | * Course focus
37 | * Study session summary (truncated for readability)
38 | - Active Courses: List of courses with active status (via has_status relation), including:
39 | * Course name
40 | * Course code or description
41 | * Status via has_status relation
42 | * Priority if assigned via has_priority relation
43 | - High-Priority Assignments: Assignments with high priority status (via has_priority relation), including:
44 | * Assignment name
45 | * Current status (not_started, in_progress, complete)
46 | * Course it belongs to
47 | * Due date if available
48 | - Upcoming Deadlines: Assignment and exam deadlines in the next 14 days, including:
49 | * Assignment/exam name
50 | * Course it belongs to
51 | * Due date
52 | * Days remaining until due
53 | * Status (not_started, in_progress, complete)
54 | - Recently Studied Concepts: List of concepts you've recently studied
55 |
56 | Session workflow:
57 | 1. Starting a session creates a session identifier in the student domain
58 | 2. This session can be referenced when loading course context with loadcontext
59 | 3. Session activities are tracked for later recording
60 | 4. Sessions should be ended with endsession to record learning progress
61 | 5. Session history becomes available for future startsession calls
62 |
63 | Status and Priority:
64 | - Course status is retrieved through has_status relations (not_started, in_progress, complete)
65 | - Assignment priority is retrieved through has_priority relations (low, high)
66 | - This information helps you prioritize your study activities
67 |
68 | You should:
69 | 1. Begin each focused study period with startsession
70 | 2. Review the provided context to determine your study focus
71 | 3. Prioritize high-priority assignments with upcoming deadlines
72 | 4. Focus on incomplete assignments (not_started or in_progress status)
73 | 5. Choose a specific course, assignment, or concept to work on
74 | 6. Use the generated session ID with the loadcontext tool to load specific entities
75 | 7. Complete your study work on your selected focus area
76 | 8. End the session with endsession when work is complete
77 | 9. Record concepts learned, assignment status updates, and study accomplishments
78 | 10. Use the session history to maintain continuity between study periods
```
--------------------------------------------------------------------------------
/main/descriptions/student_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A precise tool for removing elements from your educational knowledge graph.
2 | This tool enables targeted deletion of academic entities, relationships between educational components, or specific observations about study materials.
3 | It helps maintain an accurate and current representation of your academic landscape as your learning journey evolves.
4 |
5 | When to use this tool:
6 | - Removing completed or dropped courses
7 | - Deleting obsolete relationships between academic entities
8 | - Pruning outdated notes or observations that are no longer relevant
9 | - Correcting errors in your academic knowledge graph
10 | - Cleaning up test or practice entities
11 | - Maintaining graph accuracy as your educational focus changes
12 | - Removing duplicate learning materials or resources
13 | - Archiving completed assignments or exams
14 | - Updating status or priority relations when they change
15 | - Modifying entity sequences
16 |
17 | Key features:
18 | - Three distinct deletion operation types (entities, relations, observations)
19 | - Cascading deletion for entities (automatically removes related relations)
20 | - Precise deletion of specific observations without removing entire entities
21 | - Targeted relation removal with exact matching on from/to/type
22 | - Batch operations for efficient cleanup
23 | - JSON-formatted response with operation results
24 | - Secure validation before deletion
25 | - Clear error messages when operations fail
26 |
27 | Parameters explained:
28 | - type: The deletion operation type to perform, which must be one of:
29 | * "entities" - Remove academic entities and their relations
30 | * "relations" - Remove specific relationships between entities
31 | * "observations" - Remove specific observations from entities
32 | - data: Operation-specific data structure:
33 | * For "entities": Array of entity names to delete
34 | * For "relations": Array of objects with { from, to, relationType }
35 | * For "observations": Array of objects with { entityName, observations[] }
36 |
37 | Deletion behavior by type:
38 | - "entities": Completely removes the specified entities and any relations where they appear
39 | - "relations": Removes only the exact relations specified, matching on all three attributes
40 | - "observations": Removes specific observations from entities while preserving the entities themselves
41 |
42 | Status and Priority Management:
43 | - To change an entity's status, delete the old has_status relation and create a new one
44 | - To change priority, delete the old has_priority relation and create a new one
45 | - Status values (not_started, in_progress, complete) are managed through relations, not direct properties
46 | - Priority values (low, high) are managed through relations, not direct properties
47 |
48 | Safety considerations:
49 | - Entity deletion cascades to relations, so be careful when deleting key entities
50 | - There is no "undo" operation, so confirm deletions carefully
51 | - Partial graph information can lead to inconsistent views of your academic knowledge
52 | - Relations require entities on both ends to exist
53 | - Deleting status or priority relations without replacing them can lead to inconsistent state
54 | - Consider creating new status/priority relations before deleting old ones
55 |
56 | You should:
57 | 1. Identify the specific elements in your academic graph that need to be removed
58 | 2. Choose the appropriate deletion type (entities, relations, or observations)
59 | 3. Structure your data according to the deletion type's requirements
60 | 4. Start with more specific deletions (observations) before broader ones
61 | 5. Verify the entities or relations exist before attempting deletion
62 | 6. When updating status, create a new has_status relation before deleting the old one
63 | 7. When updating priority, create a new has_priority relation before deleting the old one
64 | 8. Consider the impact on entity sequences when deleting follows relations
65 | 9. Check the operation result to confirm successful deletion
66 | 10. Consider documenting major deletions as observations on related entities
67 | 11. When removing an entire course, first delete its components for cleaner removal
```
--------------------------------------------------------------------------------
/student/student_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A precise tool for removing elements from your educational knowledge graph.
2 | This tool enables targeted deletion of academic entities, relationships between educational components, or specific observations about study materials.
3 | It helps maintain an accurate and current representation of your academic landscape as your learning journey evolves.
4 |
5 | When to use this tool:
6 | - Removing completed or dropped courses
7 | - Deleting obsolete relationships between academic entities
8 | - Pruning outdated notes or observations that are no longer relevant
9 | - Correcting errors in your academic knowledge graph
10 | - Cleaning up test or practice entities
11 | - Maintaining graph accuracy as your educational focus changes
12 | - Removing duplicate learning materials or resources
13 | - Archiving completed assignments or exams
14 | - Updating status or priority relations when they change
15 | - Modifying entity sequences
16 |
17 | Key features:
18 | - Three distinct deletion operation types (entities, relations, observations)
19 | - Cascading deletion for entities (automatically removes related relations)
20 | - Precise deletion of specific observations without removing entire entities
21 | - Targeted relation removal with exact matching on from/to/type
22 | - Batch operations for efficient cleanup
23 | - JSON-formatted response with operation results
24 | - Secure validation before deletion
25 | - Clear error messages when operations fail
26 |
27 | Parameters explained:
28 | - type: The deletion operation type to perform, which must be one of:
29 | * "entities" - Remove academic entities and their relations
30 | * "relations" - Remove specific relationships between entities
31 | * "observations" - Remove specific observations from entities
32 | - data: Operation-specific data structure:
33 | * For "entities": Array of entity names to delete
34 | * For "relations": Array of objects with { from, to, relationType }
35 | * For "observations": Array of objects with { entityName, observations[] }
36 |
37 | Deletion behavior by type:
38 | - "entities": Completely removes the specified entities and any relations where they appear
39 | - "relations": Removes only the exact relations specified, matching on all three attributes
40 | - "observations": Removes specific observations from entities while preserving the entities themselves
41 |
42 | Status and Priority Management:
43 | - To change an entity's status, delete the old has_status relation and create a new one
44 | - To change priority, delete the old has_priority relation and create a new one
45 | - Status values (not_started, in_progress, complete) are managed through relations, not direct properties
46 | - Priority values (low, high) are managed through relations, not direct properties
47 |
48 | Safety considerations:
49 | - Entity deletion cascades to relations, so be careful when deleting key entities
50 | - There is no "undo" operation, so confirm deletions carefully
51 | - Partial graph information can lead to inconsistent views of your academic knowledge
52 | - Relations require entities on both ends to exist
53 | - Deleting status or priority relations without replacing them can lead to inconsistent state
54 | - Consider creating new status/priority relations before deleting old ones
55 |
56 | You should:
57 | 1. Identify the specific elements in your academic graph that need to be removed
58 | 2. Choose the appropriate deletion type (entities, relations, or observations)
59 | 3. Structure your data according to the deletion type's requirements
60 | 4. Start with more specific deletions (observations) before broader ones
61 | 5. Verify the entities or relations exist before attempting deletion
62 | 6. When updating status, create a new has_status relation before deleting the old one
63 | 7. When updating priority, create a new has_priority relation before deleting the old one
64 | 8. Consider the impact on entity sequences when deleting follows relations
65 | 9. Check the operation result to confirm successful deletion
66 | 10. Consider documenting major deletions as observations on related entities
67 | 11. When removing an entire course, first delete its components for cleaner removal
```
--------------------------------------------------------------------------------
/developer/developer_advancedcontext.txt:
--------------------------------------------------------------------------------
```
1 | A sophisticated tool for advanced querying and analysis of the software development knowledge graph.
2 | This tool provides specialized operations to extract meaningful insights and contextual information from the graph structure.
3 | It enables deep exploration of projects, components, relationships, decisions, and progress tracking.
4 |
5 | When to use this tool:
6 | - Retrieving the complete development knowledge graph
7 | - Searching for specific entities using keyword or partial matching
8 | - Fetching details on a precise set of development entities
9 | - Exploring all relationships for a specific entity
10 | - Examining the decision history for a software project
11 | - Tracking progress toward project milestones
12 | - Investigating dependencies between components
13 | - Analyzing the evolution of a software project
14 | - Understanding the context surrounding development entities
15 | - Exploring task sequencing and dependencies
16 | - Identifying entities by status or priority
17 |
18 | Key features:
19 | - Six specialized query operation types
20 | - Full graph retrieval with entities and relations
21 | - Keyword-based search across entities and their properties
22 | - Direct entity lookup by exact name
23 | - Relationship exploration with filtering options
24 | - Project decision history with chronological ordering
25 | - Milestone progress tracking with task status breakdown
26 | - Status and priority information retrieval
27 |
28 | Parameters explained:
29 | - type: The query operation type to perform, which must be one of:
30 | * "graph" - Retrieve the entire knowledge graph (all entities and relations)
31 | * "search" - Find entities by keyword/partial match in name, type, or observations
32 | * "nodes" - Get specific entities by exact name
33 | * "related" - Get all entities related to a specific entity
34 | * "decisions" - Get the decision history for a project
35 | * "milestone" - Get progress tracking for a specific milestone
36 | - params: Operation-specific parameters structure:
37 | * For "graph": No parameters needed
38 | * For "search": { query: "search text" }
39 | * For "nodes": { names: ["EntityName1", "EntityName2", ...] }
40 | * For "related": { entityName: "EntityName", relationTypes: ["type1", "type2", ...] }
41 | * For "decisions": { projectName: "ProjectName" }
42 | * For "milestone": { milestoneName: "MilestoneName" }
43 |
44 | Operation details:
45 | - "graph" returns the complete knowledge graph structure
46 | - "search" performs partial matching on entity names, types, and observations
47 | - "nodes" retrieves specific entities by exact name matching
48 | - "related" finds all incoming and outgoing relationships for an entity
49 | - "decisions" retrieves and chronologically sorts project decisions
50 | - "milestone" calculates progress percentage and task breakdowns with status information
51 |
52 | Notes:
53 | - Valid status values: "inactive", "active", or "complete"
54 | - Valid priority values: "low" or "high"
55 | - Status is represented via the has_status relation type, and priority via has_priority
56 |
57 | Return structures:
58 | - All operations return { success: true/false, ... } with operation-specific data
59 | - Error responses include detailed error messages
60 | - "related" returns both incoming and outgoing relationships
61 | - "milestone" includes progress percentage and task categorization by status
62 | - Sequencing information appears in directed relationship graphs
63 |
64 | You should:
65 | 1. Select the most appropriate query type for your information need
66 | 2. Provide the required parameters for your chosen operation type
67 | 3. Start with broader queries and refine to more specific ones
68 | 4. Use "search" for exploratory investigation when entity names are unknown
69 | 5. Use "related" to explore the neighborhood of a known entity
70 | 6. Use "decisions" to understand the rationale behind project changes
71 | 7. Use "milestone" to evaluate project progress and identify blockers
72 | 8. Analyze task sequencing to understand dependencies and critical paths
73 | 9. Filter entities by status to focus on active, inactive, or completed items
74 | 10. Consider entity priorities when planning work or resolving issues
75 | 11. Combine query results to build comprehensive understanding
```
--------------------------------------------------------------------------------
/main/descriptions/developer_advancedcontext.txt:
--------------------------------------------------------------------------------
```
1 | A sophisticated tool for advanced querying and analysis of the software development knowledge graph.
2 | This tool provides specialized operations to extract meaningful insights and contextual information from the graph structure.
3 | It enables deep exploration of projects, components, relationships, decisions, and progress tracking.
4 |
5 | When to use this tool:
6 | - Retrieving the complete development knowledge graph
7 | - Searching for specific entities using keyword or partial matching
8 | - Fetching details on a precise set of development entities
9 | - Exploring all relationships for a specific entity
10 | - Examining the decision history for a software project
11 | - Tracking progress toward project milestones
12 | - Investigating dependencies between components
13 | - Analyzing the evolution of a software project
14 | - Understanding the context surrounding development entities
15 | - Exploring task sequencing and dependencies
16 | - Identifying entities by status or priority
17 |
18 | Key features:
19 | - Six specialized query operation types
20 | - Full graph retrieval with entities and relations
21 | - Keyword-based search across entities and their properties
22 | - Direct entity lookup by exact name
23 | - Relationship exploration with filtering options
24 | - Project decision history with chronological ordering
25 | - Milestone progress tracking with task status breakdown
26 | - Status and priority information retrieval
27 |
28 | Parameters explained:
29 | - type: The query operation type to perform, which must be one of:
30 | * "graph" - Retrieve the entire knowledge graph (all entities and relations)
31 | * "search" - Find entities by keyword/partial match in name, type, or observations
32 | * "nodes" - Get specific entities by exact name
33 | * "related" - Get all entities related to a specific entity
34 | * "decisions" - Get the decision history for a project
35 | * "milestone" - Get progress tracking for a specific milestone
36 | - params: Operation-specific parameters structure:
37 | * For "graph": No parameters needed
38 | * For "search": { query: "search text" }
39 | * For "nodes": { names: ["EntityName1", "EntityName2", ...] }
40 | * For "related": { entityName: "EntityName", relationTypes: ["type1", "type2", ...] }
41 | * For "decisions": { projectName: "ProjectName" }
42 | * For "milestone": { milestoneName: "MilestoneName" }
43 |
44 | Operation details:
45 | - "graph" returns the complete knowledge graph structure
46 | - "search" performs partial matching on entity names, types, and observations
47 | - "nodes" retrieves specific entities by exact name matching
48 | - "related" finds all incoming and outgoing relationships for an entity
49 | - "decisions" retrieves and chronologically sorts project decisions
50 | - "milestone" calculates progress percentage and task breakdowns with status information
51 |
52 | Notes:
53 | - Valid status values: "inactive", "active", or "complete"
54 | - Valid priority values: "low" or "high"
55 | - Status is represented via the has_status relation type, and priority via has_priority
56 |
57 | Return structures:
58 | - All operations return { success: true/false, ... } with operation-specific data
59 | - Error responses include detailed error messages
60 | - "related" returns both incoming and outgoing relationships
61 | - "milestone" includes progress percentage and task categorization by status
62 | - Sequencing information appears in directed relationship graphs
63 |
64 | You should:
65 | 1. Select the most appropriate query type for your information need
66 | 2. Provide the required parameters for your chosen operation type
67 | 3. Start with broader queries and refine to more specific ones
68 | 4. Use "search" for exploratory investigation when entity names are unknown
69 | 5. Use "related" to explore the neighborhood of a known entity
70 | 6. Use "decisions" to understand the rationale behind project changes
71 | 7. Use "milestone" to evaluate project progress and identify blockers
72 | 8. Analyze task sequencing to understand dependencies and critical paths
73 | 9. Filter entities by status to focus on active, inactive, or completed items
74 | 10. Consider entity priorities when planning work or resolving issues
75 | 11. Combine query results to build comprehensive understanding
```