This is page 2 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
--------------------------------------------------------------------------------
/developer/developer_buildcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for building and enriching the software development knowledge graph through creation operations.
2 | This tool allows developers to add new entities, create relationships between entities, or add observations to existing entities.
3 | Each operation type serves a specific purpose in constructing a comprehensive development context model.
4 |
5 | When to use this tool:
6 | - Creating new project components like features, tasks, and milestones
7 | - Establishing relationships between development entities (e.g., component implements feature)
8 | - Documenting observations about existing entities (statuses, descriptions, etc.)
9 | - Building a graph of connected software development artifacts
10 | - Recording new information discovered during development
11 | - Tracking project structure, dependencies, and status
12 | - Documenting developer roles and assignments
13 | - Setting entity status and priority values
14 | - Defining task sequencing and dependencies
15 |
16 | Key features:
17 | - Three distinct operation types (entities, relations, observations)
18 | - Type validation against software development domain standards
19 | - Automatic rejection of invalid entity or relation types
20 | - Safe addition of new observations to existing entities
21 | - JSON-formatted response with operation results
22 | - Clear error messages when operations fail
23 | - Handles both single and batch operations
24 |
25 | Parameters explained:
26 | - type: The operation type to perform, which must be one of:
27 | * "entities" - Create new software development entities
28 | * "relations" - Create relationships between existing entities
29 | * "observations" - Add observations to existing entities
30 | - data: Operation-specific data structure:
31 | * For "entities": Array of objects with { name, entityType, observations[] }
32 | * For "relations": Array of objects with { from, to, relationType }
33 | * For "observations": Array of objects with { entityName, contents[] }
34 |
35 | Entity Types:
36 | - project - Overall software project
37 | - component - Module, service, or package within a project
38 | - feature - Specific functionality being developed
39 | - issue - Bug or problem to be fixed
40 | - task - Work item or activity needed for development
41 | - developer - Team member working on the project
42 | - technology - Language, framework, or tool used
43 | - decision - Important technical or architectural decision
44 | - milestone - Key project deadline or phase
45 | - environment - Development, staging, production environments
46 | - documentation - Project documentation
47 | - requirement - Project requirement or specification
48 | - status - Entity status (inactive, active, or complete)
49 | - priority - Entity priority (low or high)
50 |
51 | Relation Types include:
52 | - depends_on - Dependency relationship
53 | - implements - Component implements a feature
54 | - blocked_by - Task is blocked by an issue
55 | - uses - Component uses a technology
56 | - part_of - Component is part of a project
57 | - contains - Project contains a component
58 | - has_status - Links entity to its status (inactive, active, complete)
59 | - has_priority - Links entity to its priority (low, high)
60 | - precedes - Task precedes another task (for sequencing)
61 | - related_to - General relationship
62 | - affects - Issue affects a component
63 | - resolves - Task resolves an issue
64 | - documented_in - Component is documented in documentation
65 | - decided_in - Decision was made in a meeting
66 | - required_by - Feature is required by a requirement
67 | - depends_on_milestone - Task depends on reaching a milestone
68 | - tested_in - Component is tested in an environment
69 |
70 | You should:
71 | 1. Specify the operation type based on what you need to create (entities, relations, or observations)
72 | 2. Structure your data according to the operation type's requirements
73 | 3. Use valid entity types and relation types from the software development domain
74 | 4. Ensure entities exist before creating relations between them
75 | 5. Provide meaningful names and descriptions for new entities
76 | 6. Use observations to add metadata about entities
77 | 7. Create complete structures rather than adding entities/relations piecemeal
78 | 8. For task sequencing, use the 'precedes' relation to define which tasks must be completed before others
79 | 9. Set status values using the has_status relation (valid values: inactive, active, complete)
80 | 10. Set priority values using the has_priority relation (valid values: low, high)
```
--------------------------------------------------------------------------------
/main/descriptions/developer_buildcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for building and enriching the software development knowledge graph through creation operations.
2 | This tool allows developers to add new entities, create relationships between entities, or add observations to existing entities.
3 | Each operation type serves a specific purpose in constructing a comprehensive development context model.
4 |
5 | When to use this tool:
6 | - Creating new project components like features, tasks, and milestones
7 | - Establishing relationships between development entities (e.g., component implements feature)
8 | - Documenting observations about existing entities (statuses, descriptions, etc.)
9 | - Building a graph of connected software development artifacts
10 | - Recording new information discovered during development
11 | - Tracking project structure, dependencies, and status
12 | - Documenting developer roles and assignments
13 | - Setting entity status and priority values
14 | - Defining task sequencing and dependencies
15 |
16 | Key features:
17 | - Three distinct operation types (entities, relations, observations)
18 | - Type validation against software development domain standards
19 | - Automatic rejection of invalid entity or relation types
20 | - Safe addition of new observations to existing entities
21 | - JSON-formatted response with operation results
22 | - Clear error messages when operations fail
23 | - Handles both single and batch operations
24 |
25 | Parameters explained:
26 | - type: The operation type to perform, which must be one of:
27 | * "entities" - Create new software development entities
28 | * "relations" - Create relationships between existing entities
29 | * "observations" - Add observations to existing entities
30 | - data: Operation-specific data structure:
31 | * For "entities": Array of objects with { name, entityType, observations[] }
32 | * For "relations": Array of objects with { from, to, relationType }
33 | * For "observations": Array of objects with { entityName, contents[] }
34 |
35 | Entity Types:
36 | - project - Overall software project
37 | - component - Module, service, or package within a project
38 | - feature - Specific functionality being developed
39 | - issue - Bug or problem to be fixed
40 | - task - Work item or activity needed for development
41 | - developer - Team member working on the project
42 | - technology - Language, framework, or tool used
43 | - decision - Important technical or architectural decision
44 | - milestone - Key project deadline or phase
45 | - environment - Development, staging, production environments
46 | - documentation - Project documentation
47 | - requirement - Project requirement or specification
48 | - status - Entity status (inactive, active, or complete)
49 | - priority - Entity priority (low or high)
50 |
51 | Relation Types include:
52 | - depends_on - Dependency relationship
53 | - implements - Component implements a feature
54 | - blocked_by - Task is blocked by an issue
55 | - uses - Component uses a technology
56 | - part_of - Component is part of a project
57 | - contains - Project contains a component
58 | - has_status - Links entity to its status (inactive, active, complete)
59 | - has_priority - Links entity to its priority (low, high)
60 | - precedes - Task precedes another task (for sequencing)
61 | - related_to - General relationship
62 | - affects - Issue affects a component
63 | - resolves - Task resolves an issue
64 | - documented_in - Component is documented in documentation
65 | - decided_in - Decision was made in a meeting
66 | - required_by - Feature is required by a requirement
67 | - depends_on_milestone - Task depends on reaching a milestone
68 | - tested_in - Component is tested in an environment
69 |
70 | You should:
71 | 1. Specify the operation type based on what you need to create (entities, relations, or observations)
72 | 2. Structure your data according to the operation type's requirements
73 | 3. Use valid entity types and relation types from the software development domain
74 | 4. Ensure entities exist before creating relations between them
75 | 5. Provide meaningful names and descriptions for new entities
76 | 6. Use observations to add metadata about entities
77 | 7. Create complete structures rather than adding entities/relations piecemeal
78 | 8. For task sequencing, use the 'precedes' relation to define which tasks must be completed before others
79 | 9. Set status values using the has_status relation (valid values: inactive, active, complete)
80 | 10. Set priority values using the has_priority relation (valid values: low, high)
```
--------------------------------------------------------------------------------
/main/descriptions/student_buildcontext.txt:
--------------------------------------------------------------------------------
```
1 | A flexible tool for constructing and enhancing your educational knowledge graph.
2 | This tool allows you to add new academic entities, create relationships between educational components, or add observations to existing study materials.
3 | Each operation type serves a specific purpose in building a comprehensive representation of your academic journey.
4 |
5 | When to use this tool:
6 | - Creating new educational entities like courses, assignments, and exams
7 | - Establishing relationships between academic entities (e.g., assignment is part of a course)
8 | - Documenting observations about your academic materials
9 | - Building a connected graph of your educational experience
10 | - Organizing your study resources and materials
11 | - Tracking relationships between concepts and learning materials
12 | - Recording course-specific details like schedules and due dates
13 | - Creating structured representations of your academic knowledge
14 | - Setting status values for educational entities
15 | - Assigning priority to assignments and tasks
16 |
17 | Key features:
18 | - Three distinct operation types (entities, relations, observations)
19 | - Type validation against academic domain standards
20 | - Automatic rejection of invalid entity or relation types
21 | - Safe addition of new observations to existing academic entities
22 | - Status and priority assignment through entity-relation model
23 | - JSON-formatted response with operation results
24 | - Clear error messages when operations fail
25 | - Handles both single and batch operations
26 |
27 | Parameters explained:
28 | - type: The operation type to perform, which must be one of:
29 | * "entities" - Create new academic entities
30 | * "relations" - Create relationships between existing entities
31 | * "observations" - Add observations to existing entities
32 | - data: Operation-specific data structure:
33 | * For "entities": Array of objects with { name, entityType, observations[] }
34 | * For "relations": Array of objects with { from, to, relationType }
35 | * For "observations": Array of objects with { entityName, contents[] }
36 |
37 | Entity Types:
38 | - course - Academic courses you're taking
39 | - assignment - Homework, projects, and other submitted work
40 | - exam - Tests, quizzes, and other assessments
41 | - concept - Knowledge topics and learning objectives
42 | - resource - Textbooks, articles, videos, and other learning materials
43 | - note - Personal study notes and observations
44 | - lecture - Individual class sessions
45 | - project - Larger educational projects
46 | - question - Specific questions for study or review
47 | - term - Academic terms or semesters
48 | - goal - Learning objectives and targets
49 | - professor - Course instructors and teachers
50 | - status - Entity status (not_started, in_progress, complete)
51 | - priority - Entity priority (low, high)
52 |
53 | Relation Types include:
54 | - enrolled_in - Student is taking a course
55 | - assigned_in - Assignment is part of a course
56 | - due_on - Assignment/exam has specific due date
57 | - covers - Lecture/resource covers concept
58 | - references - Note references concept
59 | - prerequisite_for - Concept is foundation for another
60 | - taught_by - Course taught by professor
61 | - scheduled_for - Lecture/exam scheduled for specific time
62 | - contains - Course contains lectures/assignments
63 | - has_status - Links entity to its status (not_started, in_progress, complete)
64 | - has_priority - Links entity to its priority (low, high)
65 | - follows - Entity follows another in a sequence
66 |
67 | Status Values:
68 | - not_started - Work on the entity has not begun
69 | - in_progress - Work is actively underway
70 | - complete - Work has been finished
71 |
72 | Priority Values:
73 | - low - Lower priority item
74 | - high - Higher priority item
75 |
76 | You should:
77 | 1. Specify the operation type based on what you need to create (entities, relations, or observations)
78 | 2. Structure your data according to the operation type's requirements
79 | 3. Use valid entity types and relation types from the academic domain
80 | 4. Ensure entities exist before creating relations between them
81 | 5. Provide meaningful names and descriptions for new entities
82 | 6. Use observations to add general metadata about entities
83 | 7. Use has_status relations to track progress (not_started, in_progress, complete)
84 | 8. Use has_priority relations to indicate importance (low, high)
85 | 9. Use follows relations to establish sequences between related entities
86 | 10. Create complete structures rather than adding entities/relations piecemeal
87 | 11. Check the operation result to confirm successful creation
```
--------------------------------------------------------------------------------
/student/student_buildcontext.txt:
--------------------------------------------------------------------------------
```
1 | A flexible tool for constructing and enhancing your educational knowledge graph.
2 | This tool allows you to add new academic entities, create relationships between educational components, or add observations to existing study materials.
3 | Each operation type serves a specific purpose in building a comprehensive representation of your academic journey.
4 |
5 | When to use this tool:
6 | - Creating new educational entities like courses, assignments, and exams
7 | - Establishing relationships between academic entities (e.g., assignment is part of a course)
8 | - Documenting observations about your academic materials
9 | - Building a connected graph of your educational experience
10 | - Organizing your study resources and materials
11 | - Tracking relationships between concepts and learning materials
12 | - Recording course-specific details like schedules and due dates
13 | - Creating structured representations of your academic knowledge
14 | - Setting status values for educational entities
15 | - Assigning priority to assignments and tasks
16 |
17 | Key features:
18 | - Three distinct operation types (entities, relations, observations)
19 | - Type validation against academic domain standards
20 | - Automatic rejection of invalid entity or relation types
21 | - Safe addition of new observations to existing academic entities
22 | - Status and priority assignment through entity-relation model
23 | - JSON-formatted response with operation results
24 | - Clear error messages when operations fail
25 | - Handles both single and batch operations
26 |
27 | Parameters explained:
28 | - type: The operation type to perform, which must be one of:
29 | * "entities" - Create new academic entities
30 | * "relations" - Create relationships between existing entities
31 | * "observations" - Add observations to existing entities
32 | - data: Operation-specific data structure:
33 | * For "entities": Array of objects with { name, entityType, observations[] }
34 | * For "relations": Array of objects with { from, to, relationType }
35 | * For "observations": Array of objects with { entityName, contents[] }
36 |
37 | Entity Types:
38 | - course - Academic courses you're taking
39 | - assignment - Homework, projects, and other submitted work
40 | - exam - Tests, quizzes, and other assessments
41 | - concept - Knowledge topics and learning objectives
42 | - resource - Textbooks, articles, videos, and other learning materials
43 | - note - Personal study notes and observations
44 | - lecture - Individual class sessions
45 | - project - Larger educational projects
46 | - question - Specific questions for study or review
47 | - term - Academic terms or semesters
48 | - goal - Learning objectives and targets
49 | - professor - Course instructors and teachers
50 | - status - Entity status (not_started, in_progress, complete)
51 | - priority - Entity priority (low, high)
52 |
53 | Relation Types include:
54 | - enrolled_in - Student is taking a course
55 | - assigned_in - Assignment is part of a course
56 | - due_on - Assignment/exam has specific due date
57 | - covers - Lecture/resource covers concept
58 | - references - Note references concept
59 | - prerequisite_for - Concept is foundation for another
60 | - taught_by - Course taught by professor
61 | - scheduled_for - Lecture/exam scheduled for specific time
62 | - contains - Course contains lectures/assignments
63 | - has_status - Links entity to its status (not_started, in_progress, complete)
64 | - has_priority - Links entity to its priority (low, high)
65 | - follows - Entity follows another in a sequence
66 |
67 | Status Values:
68 | - not_started - Work on the entity has not begun
69 | - in_progress - Work is actively underway
70 | - complete - Work has been finished
71 |
72 | Priority Values:
73 | - low - Lower priority item
74 | - high - Higher priority item
75 |
76 | You should:
77 | 1. Specify the operation type based on what you need to create (entities, relations, or observations)
78 | 2. Structure your data according to the operation type's requirements
79 | 3. Use valid entity types and relation types from the academic domain
80 | 4. Ensure entities exist before creating relations between them
81 | 5. Provide meaningful names and descriptions for new entities
82 | 6. Use observations to add general metadata about entities
83 | 7. Use has_status relations to track progress (not_started, in_progress, complete)
84 | 8. Use has_priority relations to indicate importance (low, high)
85 | 9. Use follows relations to establish sequences between related entities
86 | 10. Create complete structures rather than adding entities/relations piecemeal
87 | 11. Check the operation result to confirm successful creation
```
--------------------------------------------------------------------------------
/main/descriptions/common_buildcontext.txt:
--------------------------------------------------------------------------------
```
1 | Build Context Tool
2 |
3 | A versatile tool for constructing and enhancing domain-specific knowledge graphs through creation operations.
4 | This tool allows you to add new entities, create relationships between entities, or add observations to existing entities.
5 | Each operation type serves a specific purpose in building a comprehensive contextual model.
6 |
7 | When to use this tool:
8 | - Creating new entities specific to your domain (projects, tasks, courses, datasets, etc.)
9 | - Establishing relationships between entities (e.g., dependencies, assignments, hierarchies)
10 | - Adding observations, properties, or metadata to existing entities
11 | - Building a connected graph of domain-specific elements
12 | - Recording new information as it becomes available
13 | - Tracking structure, dependencies, and status information
14 |
15 | Key features:
16 | - Three distinct operation types (entities, relations, observations)
17 | - Type validation against domain-specific standards
18 | - Automatic rejection of invalid entity or relation types
19 | - Safe addition of new observations to existing entities
20 | - JSON-formatted response with operation results
21 | - Clear error messages when operations fail
22 | - Handles both single and batch operations
23 |
24 | Parameters explained:
25 | - type: The operation type to perform, which must be one of:
26 | * "entities" - Create new domain-specific entities
27 | * "relations" - Create relationships between existing entities
28 | * "observations" - Add observations to existing entities
29 | - data: Operation-specific data structure:
30 | * For "entities": Array of objects with { name, entityType, observations[] }
31 | * For "relations": Array of objects with { from, to, relationType }
32 | * For "observations": Array of objects with { entityName, contents[] }
33 |
34 | Valid entity types by domain:
35 | - Developer:
36 | * project, component, feature, issue, task, developer, technology, decision, milestone, environment, documentation, requirement
37 | - Student:
38 | * course, assignment, exam, concept, resource, note, lecture, project, question, term, goal, professor
39 | - Qualitative Research:
40 | * project, participant, interview, observation, document, code, codeGroup, memo, theme, quote, literature, researchQuestion, finding
41 | - Quantitative Research:
42 | * project, dataset, variable, hypothesis, statisticalTest, result, analysisScript, visualization, model, literature, researchQuestion, finding, participant
43 | - Project Management:
44 | * project, task, milestone, teamMember, risk, decision, resource, issue, dependency, meeting, document, stakeholder
45 |
46 | Valid relation types by domain:
47 | - Developer:
48 | * depends_on, implements, assigned_to, blocked_by, uses, part_of, contains, works_on
49 | - Student:
50 | * enrolled_in, assigned_in, due_on, covers, references, prerequisite_for, taught_by, scheduled_for, contains
51 | - Qualitative Research:
52 | * part_of, contains, participates_in, codes, groups, references, supports, contradicts, emerges_from, relates_to, precedes, follows, associated_with
53 | - Quantitative Research:
54 | * correlates_with, predicts, tests, analyzes, produces, visualizes, contains, part_of, depends_on, supports, contradicts, derived_from, controls_for, moderates, mediates, implements, compares, includes, validates, cites
55 | - Project Management:
56 | * part_of, depends_on, assigned_to, responsible_for, created_by, leads_to, blocks, reports_to, collaborates_with, decides_on, impacts
57 |
58 | Return information:
59 | - JSON response indicating success or failure
60 | - For successful operations:
61 | * Success flag set to true
62 | * Details of created elements in the "created" field (for entities/relations) or "added" field (for observations)
63 | - For failed operations:
64 | * Success flag set to false
65 | * Error message describing the issue
66 |
67 | Error handling:
68 | - Validates entity types against the predefined list for the specific domain
69 | - Validates relation types against domain-specific standards
70 | - Returns descriptive error messages for invalid inputs
71 | - Gracefully handles type mismatches and formatting errors
72 |
73 | You should:
74 | 1. Specify the operation type based on what you need to create (entities, relations, or observations)
75 | 2. Structure your data according to the operation type's requirements
76 | 3. Use valid entity types and relation types from your specific domain
77 | 4. Ensure entities exist before creating relations between them
78 | 5. Provide meaningful names and descriptions for new entities
79 | 6. Create complete structures rather than adding entities/relations piecemeal
80 | 7. Check the operation result to confirm successful creation
```
--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A comprehensive tool for initializing a new qualitative research session, providing structured information about ongoing research projects, participants, analytical elements, and recent research activities.
2 |
3 | When to use this tool:
4 | - Beginning a new research analysis session
5 | - Getting oriented to your current research state across multiple projects
6 | - Planning which research elements to focus on in the current session
7 | - Reviewing recent research activities and progress
8 | - Identifying active research projects and their status
9 | - Exploring available participants for analysis
10 | - Reviewing your most frequently used codes
11 | - Accessing recent analytical memos
12 | - Establishing research context before diving into specific analysis tasks
13 | - Re-engaging with your research after time away
14 | - Prioritizing high-priority research tasks
15 | - Tracking the status of various research activities
16 | - Understanding sequential research processes
17 |
18 | Key features:
19 | - Generates a unique session identifier for tracking research activities
20 | - Retrieves and displays recent research sessions with summaries
21 | - Lists active research projects with status and phase information
22 | - Provides a sample of research participants with demographic information
23 | - Presents your most frequently used codes with reference counts
24 | - Highlights recent analytical memos with type and summary information
25 | - Formats information in an easily scannable format for quick orientation
26 | - Integrates with the loadcontext tool for deeper exploration
27 | - Maintains continuity between research sessions
28 | - Tracks research session history for progress review
29 | - Displays high-priority research tasks needing attention
30 | - Shows status information for key research activities
31 | - Presents sequential relationships between research processes
32 |
33 | Parameters explained:
34 | No parameters required - the tool automatically retrieves all relevant context.
35 |
36 | Return information:
37 | - A unique session identifier
38 | - Recent research sessions (up to 3) with:
39 | * Date
40 | * Project name
41 | * Brief summary
42 | - Active research projects with:
43 | * Project name
44 | * Current status
45 | * Research phase
46 | - Sample participants (up to 5) with:
47 | * Participant name
48 | * Demographic information
49 | * Participation status
50 | - Top codes (up to 10) with:
51 | * Code name
52 | * Reference count
53 | * Code group
54 | - Recent memos (up to 3) with:
55 | * Memo name
56 | * Creation date
57 | * Memo type
58 | * Brief summary
59 | - High-priority research tasks (up to 5) with:
60 | * Task name
61 | * Current status
62 | * Associated project
63 | - Upcoming research activities (up to 3) with:
64 | * Activity name
65 | * Scheduled date
66 | * Prerequisite activities
67 | * Current status
68 |
69 | Status and Priority Information:
70 | - Research activities are displayed with their current status values
71 | - High-priority tasks are prominently highlighted for attention
72 | - Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
73 | - Priority values (high, low) help indicate which tasks need immediate attention
74 |
75 | Sequential Process Information:
76 | - Upcoming activities show prerequisite tasks that must be completed first
77 | - Research phases are presented in their logical sequence
78 | - The precedes relation is used to determine activity ordering
79 | - Sequential relationships help visualize the research workflow
80 |
81 | Session Workflow:
82 | 1. Start a research session with startsession
83 | 2. Review the provided context to decide what to focus on
84 | 3. Use loadcontext to retrieve detailed information about specific research elements
85 | 4. Conduct your analysis, adding new elements with buildcontext as needed
86 | 5. End the session with endsession to record your research progress
87 |
88 | You should:
89 | - Begin each focused research period with startsession to establish context
90 | - Review recent sessions to maintain continuity in your research
91 | - Identify active projects that require attention
92 | - Note available participants for interview analysis
93 | - Consider frequently used codes that may indicate important patterns
94 | - Review recent memos to reconnect with your analytical thinking
95 | - Prioritize high-priority tasks for immediate attention
96 | - Check the status of research activities to maintain progress awareness
97 | - Consider sequential relationships when planning your research activities
98 | - Use the session ID when using other tools to maintain session tracking
99 | - After completing a session, record your progress using endsession
100 | - Establish a regular cadence of research sessions to maintain momentum
101 | - Use the structured overview to make deliberate choices about where to focus your analytical effort
```
--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A comprehensive tool for initializing a new qualitative research session, providing structured information about ongoing research projects, participants, analytical elements, and recent research activities.
2 |
3 | When to use this tool:
4 | - Beginning a new research analysis session
5 | - Getting oriented to your current research state across multiple projects
6 | - Planning which research elements to focus on in the current session
7 | - Reviewing recent research activities and progress
8 | - Identifying active research projects and their status
9 | - Exploring available participants for analysis
10 | - Reviewing your most frequently used codes
11 | - Accessing recent analytical memos
12 | - Establishing research context before diving into specific analysis tasks
13 | - Re-engaging with your research after time away
14 | - Prioritizing high-priority research tasks
15 | - Tracking the status of various research activities
16 | - Understanding sequential research processes
17 |
18 | Key features:
19 | - Generates a unique session identifier for tracking research activities
20 | - Retrieves and displays recent research sessions with summaries
21 | - Lists active research projects with status and phase information
22 | - Provides a sample of research participants with demographic information
23 | - Presents your most frequently used codes with reference counts
24 | - Highlights recent analytical memos with type and summary information
25 | - Formats information in an easily scannable format for quick orientation
26 | - Integrates with the loadcontext tool for deeper exploration
27 | - Maintains continuity between research sessions
28 | - Tracks research session history for progress review
29 | - Displays high-priority research tasks needing attention
30 | - Shows status information for key research activities
31 | - Presents sequential relationships between research processes
32 |
33 | Parameters explained:
34 | No parameters required - the tool automatically retrieves all relevant context.
35 |
36 | Return information:
37 | - A unique session identifier
38 | - Recent research sessions (up to 3) with:
39 | * Date
40 | * Project name
41 | * Brief summary
42 | - Active research projects with:
43 | * Project name
44 | * Current status
45 | * Research phase
46 | - Sample participants (up to 5) with:
47 | * Participant name
48 | * Demographic information
49 | * Participation status
50 | - Top codes (up to 10) with:
51 | * Code name
52 | * Reference count
53 | * Code group
54 | - Recent memos (up to 3) with:
55 | * Memo name
56 | * Creation date
57 | * Memo type
58 | * Brief summary
59 | - High-priority research tasks (up to 5) with:
60 | * Task name
61 | * Current status
62 | * Associated project
63 | - Upcoming research activities (up to 3) with:
64 | * Activity name
65 | * Scheduled date
66 | * Prerequisite activities
67 | * Current status
68 |
69 | Status and Priority Information:
70 | - Research activities are displayed with their current status values
71 | - High-priority tasks are prominently highlighted for attention
72 | - Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
73 | - Priority values (high, low) help indicate which tasks need immediate attention
74 |
75 | Sequential Process Information:
76 | - Upcoming activities show prerequisite tasks that must be completed first
77 | - Research phases are presented in their logical sequence
78 | - The precedes relation is used to determine activity ordering
79 | - Sequential relationships help visualize the research workflow
80 |
81 | Session Workflow:
82 | 1. Start a research session with startsession
83 | 2. Review the provided context to decide what to focus on
84 | 3. Use loadcontext to retrieve detailed information about specific research elements
85 | 4. Conduct your analysis, adding new elements with buildcontext as needed
86 | 5. End the session with endsession to record your research progress
87 |
88 | You should:
89 | - Begin each focused research period with startsession to establish context
90 | - Review recent sessions to maintain continuity in your research
91 | - Identify active projects that require attention
92 | - Note available participants for interview analysis
93 | - Consider frequently used codes that may indicate important patterns
94 | - Review recent memos to reconnect with your analytical thinking
95 | - Prioritize high-priority tasks for immediate attention
96 | - Check the status of research activities to maintain progress awareness
97 | - Consider sequential relationships when planning your research activities
98 | - Use the session ID when using other tools to maintain session tracking
99 | - After completing a session, record your progress using endsession
100 | - Establish a regular cadence of research sessions to maintain momentum
101 | - Use the structured overview to make deliberate choices about where to focus your analytical effort
```
--------------------------------------------------------------------------------
/developer/developer_endsession.txt:
--------------------------------------------------------------------------------
```
1 | A multi-stage tool for documenting development sessions, recording achievements, tracking task progress, and updating project status in the knowledge graph.
2 |
3 | When to use this tool:
4 | Only use this tool when the user explicity requests it or provides explicit approval.
5 |
6 | Key features:
7 | - Provides a structured, multi-stage workflow for session documentation
8 | - Records session achievements in the knowledge graph
9 | - Updates task statuses using the has_status relation (inactive, active, complete)
10 | - Updates task priorities using the has_priority relation (low, high)
11 | - Updates task sequencing relationships using the precedes relation
12 | - Creates links between completed tasks and projects
13 | - Updates project status metadata
14 | - Creates new tasks for future development
15 | - Supports revision of previous stages when needed
16 | - Offers a comprehensive assembly stage that consolidates all session information
17 | - Organizes development activity into a coherent project history
18 |
19 | The endsession tool uses a sequential, multi-stage approach with 6 typical stages:
20 | 1. Summary Stage: Records basic session information
21 | 2. Achievements Stage: Documents specific accomplishments
22 | 3. Task Updates Stage: Records status and priority changes to existing tasks
23 | 4. New Tasks Stage: Defines new tasks created during the session
24 | 5. Project Status Stage: Updates the overall project status
25 | 6. Assembly Stage: Consolidates all information and finalizes the session record
26 |
27 | Parameters explained:
28 | - sessionId: Required - Unique identifier for the development session
29 | * Obtained from the startsession tool
30 | * Example: "dev_1234567890_abc123"
31 | - stage: Required - Current stage of the endsession workflow
32 | * Accepts: "summary", "achievements", "taskUpdates", "newTasks", "projectStatus", or "assembly"
33 | * Each stage has specific data requirements and processing logic
34 | - stageNumber: Required - The sequence number of the current stage
35 | * Starts at 1 and typically progresses through 6 stages
36 | * Used to track progress through the session documentation workflow
37 | - totalStages: Required - Total number of stages planned for this workflow
38 | * Typically 6 for the complete workflow
39 | * Provides context for the progress within the overall process
40 | - analysis: Optional - Text analysis or observations for the current stage
41 | * Descriptive text explaining the work done in this stage
42 | * Example: "Analyzed progress on the authentication system"
43 | - stageData: Optional - Stage-specific structured data
44 | * summary: { summary: "Session summary text", duration: "2 hours", focus: "ProjectName" }
45 | * achievements: { achievements: ["Implemented feature X", "Fixed bug Y", "Refactored component Z"] }
46 | * taskUpdates: { taskUpdates: [{ name: "Task1", status: "complete" }, { name: "Task2", status: "active", priority: "high" }] }
47 | * newTasks: { newTasks: [{ name: "NewTask1", description: "Implement feature A", priority: "high", precedesTask: "Task2" }] }
48 | * projectStatus: { projectName: "ProjectName", status: "active", observation: "Making good progress" }
49 | * assembly: No stageData needed - automatically assembled from previous stages
50 | - nextStageNeeded: Required - Whether additional stages are needed after this one
51 | * Boolean value (true/false)
52 | * Set to false on the final stage to complete the session
53 | - isRevision: Optional - Whether this is revising a previous stage
54 | * Boolean value (true/false)
55 | * Default: false
56 | - revisesStage: Optional - If revising, which stage number is being revised
57 | * Required when isRevision is true
58 | * Indicates which previous stage is being updated
59 |
60 | Return information:
61 | - success: Boolean indicating whether the operation succeeded
62 | - stageCompleted: The stage that was just completed
63 | - nextStageNeeded: Whether more stages are required
64 | - stageResult: The processed result of the current stage
65 | - endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
66 | - sessionRecorded: (Final stage only) Whether the session was recorded
67 | - summaryMessage: (Final stage only) Formatted summary of all recorded information
68 | - error: (Only on failure) Error message describing the issue
69 |
70 | You should:
71 | - Complete all stages in order for comprehensive session documentation
72 | - Provide specific details in each stage for accurate knowledge graph updates
73 | - Be precise about task names to ensure they match existing tasks in the knowledge graph
74 | - Use valid status values (inactive, active, complete) when updating task status
75 | - Use valid priority values (low, high) when specifying task priorities
76 | - Specify task sequencing with the precedesTask field to establish task dependencies
77 | - Use clear, descriptive names for any new tasks
78 | - Include relevant observations for project status updates
79 | - If making a revision, specify which stage is being revised
80 | - Only mark nextStageNeeded as false on the final assembly stage
81 | - Review the final summary message to confirm all session details were recorded properly
```
--------------------------------------------------------------------------------
/main/descriptions/developer_endsession.txt:
--------------------------------------------------------------------------------
```
1 | A multi-stage tool for documenting development sessions, recording achievements, tracking task progress, and updating project status in the knowledge graph.
2 |
3 | When to use this tool:
4 | Only use this tool when the user explicity requests it or provides explicit approval.
5 |
6 | Key features:
7 | - Provides a structured, multi-stage workflow for session documentation
8 | - Records session achievements in the knowledge graph
9 | - Updates task statuses using the has_status relation (inactive, active, complete)
10 | - Updates task priorities using the has_priority relation (low, high)
11 | - Updates task sequencing relationships using the precedes relation
12 | - Creates links between completed tasks and projects
13 | - Updates project status metadata
14 | - Creates new tasks for future development
15 | - Supports revision of previous stages when needed
16 | - Offers a comprehensive assembly stage that consolidates all session information
17 | - Organizes development activity into a coherent project history
18 |
19 | The endsession tool uses a sequential, multi-stage approach with 6 typical stages:
20 | 1. Summary Stage: Records basic session information
21 | 2. Achievements Stage: Documents specific accomplishments
22 | 3. Task Updates Stage: Records status and priority changes to existing tasks
23 | 4. New Tasks Stage: Defines new tasks created during the session
24 | 5. Project Status Stage: Updates the overall project status
25 | 6. Assembly Stage: Consolidates all information and finalizes the session record
26 |
27 | Parameters explained:
28 | - sessionId: Required - Unique identifier for the development session
29 | * Obtained from the startsession tool
30 | * Example: "dev_1234567890_abc123"
31 | - stage: Required - Current stage of the endsession workflow
32 | * Accepts: "summary", "achievements", "taskUpdates", "newTasks", "projectStatus", or "assembly"
33 | * Each stage has specific data requirements and processing logic
34 | - stageNumber: Required - The sequence number of the current stage
35 | * Starts at 1 and typically progresses through 6 stages
36 | * Used to track progress through the session documentation workflow
37 | - totalStages: Required - Total number of stages planned for this workflow
38 | * Typically 6 for the complete workflow
39 | * Provides context for the progress within the overall process
40 | - analysis: Optional - Text analysis or observations for the current stage
41 | * Descriptive text explaining the work done in this stage
42 | * Example: "Analyzed progress on the authentication system"
43 | - stageData: Optional - Stage-specific structured data
44 | * summary: { summary: "Session summary text", duration: "2 hours", focus: "ProjectName" }
45 | * achievements: { achievements: ["Implemented feature X", "Fixed bug Y", "Refactored component Z"] }
46 | * taskUpdates: { taskUpdates: [{ name: "Task1", status: "complete" }, { name: "Task2", status: "active", priority: "high" }] }
47 | * newTasks: { newTasks: [{ name: "NewTask1", description: "Implement feature A", priority: "high", precedesTask: "Task2" }] }
48 | * projectStatus: { projectName: "ProjectName", status: "active", observation: "Making good progress" }
49 | * assembly: No stageData needed - automatically assembled from previous stages
50 | - nextStageNeeded: Required - Whether additional stages are needed after this one
51 | * Boolean value (true/false)
52 | * Set to false on the final stage to complete the session
53 | - isRevision: Optional - Whether this is revising a previous stage
54 | * Boolean value (true/false)
55 | * Default: false
56 | - revisesStage: Optional - If revising, which stage number is being revised
57 | * Required when isRevision is true
58 | * Indicates which previous stage is being updated
59 |
60 | Return information:
61 | - success: Boolean indicating whether the operation succeeded
62 | - stageCompleted: The stage that was just completed
63 | - nextStageNeeded: Whether more stages are required
64 | - stageResult: The processed result of the current stage
65 | - endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
66 | - sessionRecorded: (Final stage only) Whether the session was recorded
67 | - summaryMessage: (Final stage only) Formatted summary of all recorded information
68 | - error: (Only on failure) Error message describing the issue
69 |
70 | You should:
71 | - Complete all stages in order for comprehensive session documentation
72 | - Provide specific details in each stage for accurate knowledge graph updates
73 | - Be precise about task names to ensure they match existing tasks in the knowledge graph
74 | - Use valid status values (inactive, active, complete) when updating task status
75 | - Use valid priority values (low, high) when specifying task priorities
76 | - Specify task sequencing with the precedesTask field to establish task dependencies
77 | - Use clear, descriptive names for any new tasks
78 | - Include relevant observations for project status updates
79 | - If making a revision, specify which stage is being revised
80 | - Only mark nextStageNeeded as false on the final assembly stage
81 | - Review the final summary message to confirm all session details were recorded properly
```
--------------------------------------------------------------------------------
/main/descriptions/project_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A comprehensive tool for initializing a new project management session, providing structured information about ongoing projects, tasks, deadlines, and overall project health.
2 |
3 | When to use this tool:
4 | - Beginning a new project management session
5 | - Getting oriented to your current project portfolio status
6 | - Planning which projects or tasks to focus on in the current work session
7 | - Reviewing recent project activity and progress
8 | - Checking upcoming deadlines for tasks and milestones
9 | - Assessing the health of active projects
10 | - Identifying high-priority tasks requiring attention
11 | - Reviewing project risks that need mitigation
12 | - Establishing context before diving into specific project work
13 | - Creating a structured record of your project management activity
14 | - Tracking the status of various project entities
15 | - Managing sequential task dependencies
16 |
17 | Key features:
18 | - Generates a unique session identifier for tracking project management activities
19 | - Retrieves and displays your most recent project management sessions
20 | - Shows active projects you're currently managing with status information
21 | - Highlights high-priority tasks requiring attention
22 | - Lists upcoming milestones with progress metrics
23 | - Provides project health summaries with status indicators
24 | - Identifies top project risks requiring mitigation
25 | - Formats information in a structured, easy-to-read format
26 | - Integrates with the loadcontext tool for deeper exploration
27 | - Maintains continuity between project management sessions
28 | - Displays status information through has_status relations
29 | - Shows priority assignments through has_priority relations
30 | - Presents task sequencing through precedes relations
31 |
32 | Parameters explained:
33 | No parameters required - the tool automatically retrieves all relevant context.
34 |
35 | Return information:
36 | - Session ID: A unique identifier for this project management session
37 | - Recent Project Management Sessions: Up to 3 most recent sessions with:
38 | * Date
39 | * Project focus
40 | * Session summary (truncated for readability)
41 | - Active Projects: List of current projects with:
42 | * Project name
43 | * Current status (via has_status relation)
44 | * Deadline information
45 | - High-Priority Tasks: Up to 10 highest priority tasks with:
46 | * Task name
47 | * Associated project
48 | * Status (inactive, active, complete)
49 | * Priority (high via has_priority relation)
50 | * Assignee
51 | - Upcoming Milestones: Up to 8 nearest milestones with:
52 | * Milestone name
53 | * Associated project
54 | * Due date
55 | * Completion percentage
56 | * Status (via has_status relation)
57 | - Project Health Summary: Status of active projects with:
58 | * Project name
59 | * Health status indicator
60 | * Health score
61 | * Issue count
62 | * Risk count
63 | - Top Project Risks: Up to 5 highest severity risks with:
64 | * Risk name
65 | * Associated project
66 | * Severity level
67 | * Impact assessment
68 | - Next Sequence Tasks: Up to 5 tasks ready to be worked on next based on sequential dependencies:
69 | * Task name
70 | * Associated project
71 | * Status (via has_status relation)
72 | * Prerequisites completion status
73 |
74 | Status and Priority Information:
75 | - Project and task status is retrieved through has_status relations
76 | - Valid status values include: inactive, active, complete
77 | - Task priority is retrieved through has_priority relations
78 | - Valid priority values include: high, low
79 | - This information helps you prioritize your project management activities
80 |
81 | Sequential Task Management:
82 | - Tasks are presented in their logical sequence based on precedes relations
83 | - Prerequisite tasks must be completed before dependent tasks can begin
84 | - The sequential view helps identify the next logical actions in project workflows
85 | - Critical path tasks are highlighted to show dependencies affecting project timelines
86 |
87 | Session Workflow:
88 | 1. Start a project management session with startsession
89 | 2. Review the provided context to decide what to focus on
90 | 3. Use loadcontext to retrieve detailed information about specific projects
91 | 4. Conduct your project management work, adding new elements with buildcontext as needed
92 | 5. End the session when work is complete
93 | 6. Record progress, decisions, and next steps
94 |
95 | You should:
96 | - Begin each focused project management period with startsession
97 | - Review recent sessions to maintain continuity in your work
98 | - Prioritize work based on high-priority tasks and upcoming milestones
99 | - Address projects with poor health indicators
100 | - Mitigate high-severity risks promptly
101 | - Focus on tasks that are next in sequence based on precedes relations
102 | - Complete prerequisite tasks to unblock dependent tasks
103 | - Check entity status to identify active work items
104 | - Use the session ID when using other tools to maintain session tracking
105 | - Establish a regular cadence of project management sessions
106 | - Use the structured overview to make deliberate choices about where to focus your effort
107 | - Consider creating or updating project entities after reviewing the current state
108 | - Follow up on projects with approaching deadlines
```
--------------------------------------------------------------------------------
/project/project_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A comprehensive tool for initializing a new project management session, providing structured information about ongoing projects, tasks, deadlines, and overall project health.
2 |
3 | When to use this tool:
4 | - Beginning a new project management session
5 | - Getting oriented to your current project portfolio status
6 | - Planning which projects or tasks to focus on in the current work session
7 | - Reviewing recent project activity and progress
8 | - Checking upcoming deadlines for tasks and milestones
9 | - Assessing the health of active projects
10 | - Identifying high-priority tasks requiring attention
11 | - Reviewing project risks that need mitigation
12 | - Establishing context before diving into specific project work
13 | - Creating a structured record of your project management activity
14 | - Tracking the status of various project entities
15 | - Managing sequential task dependencies
16 |
17 | Key features:
18 | - Generates a unique session identifier for tracking project management activities
19 | - Retrieves and displays your most recent project management sessions
20 | - Shows active projects you're currently managing with status information
21 | - Highlights high-priority tasks requiring attention
22 | - Lists upcoming milestones with progress metrics
23 | - Provides project health summaries with status indicators
24 | - Identifies top project risks requiring mitigation
25 | - Formats information in a structured, easy-to-read format
26 | - Integrates with the loadcontext tool for deeper exploration
27 | - Maintains continuity between project management sessions
28 | - Displays status information through has_status relations
29 | - Shows priority assignments through has_priority relations
30 | - Presents task sequencing through precedes relations
31 |
32 | Parameters explained:
33 | No parameters required - the tool automatically retrieves all relevant context.
34 |
35 | Return information:
36 | - Session ID: A unique identifier for this project management session
37 | - Recent Project Management Sessions: Up to 3 most recent sessions with:
38 | * Date
39 | * Project focus
40 | * Session summary (truncated for readability)
41 | - Active Projects: List of current projects with:
42 | * Project name
43 | * Current status (via has_status relation)
44 | * Deadline information
45 | - High-Priority Tasks: Up to 10 highest priority tasks with:
46 | * Task name
47 | * Associated project
48 | * Status (inactive, active, complete)
49 | * Priority (high via has_priority relation)
50 | * Assignee
51 | - Upcoming Milestones: Up to 8 nearest milestones with:
52 | * Milestone name
53 | * Associated project
54 | * Due date
55 | * Completion percentage
56 | * Status (via has_status relation)
57 | - Project Health Summary: Status of active projects with:
58 | * Project name
59 | * Health status indicator
60 | * Health score
61 | * Issue count
62 | * Risk count
63 | - Top Project Risks: Up to 5 highest severity risks with:
64 | * Risk name
65 | * Associated project
66 | * Severity level
67 | * Impact assessment
68 | - Next Sequence Tasks: Up to 5 tasks ready to be worked on next based on sequential dependencies:
69 | * Task name
70 | * Associated project
71 | * Status (via has_status relation)
72 | * Prerequisites completion status
73 |
74 | Status and Priority Information:
75 | - Project and task status is retrieved through has_status relations
76 | - Valid status values include: inactive, active, complete
77 | - Task priority is retrieved through has_priority relations
78 | - Valid priority values include: high, low
79 | - This information helps you prioritize your project management activities
80 |
81 | Sequential Task Management:
82 | - Tasks are presented in their logical sequence based on precedes relations
83 | - Prerequisite tasks must be completed before dependent tasks can begin
84 | - The sequential view helps identify the next logical actions in project workflows
85 | - Critical path tasks are highlighted to show dependencies affecting project timelines
86 |
87 | Session Workflow:
88 | 1. Start a project management session with startsession
89 | 2. Review the provided context to decide what to focus on
90 | 3. Use loadcontext to retrieve detailed information about specific projects
91 | 4. Conduct your project management work, adding new elements with buildcontext as needed
92 | 5. End the session when work is complete
93 | 6. Record progress, decisions, and next steps
94 |
95 | You should:
96 | - Begin each focused project management period with startsession
97 | - Review recent sessions to maintain continuity in your work
98 | - Prioritize work based on high-priority tasks and upcoming milestones
99 | - Address projects with poor health indicators
100 | - Mitigate high-severity risks promptly
101 | - Focus on tasks that are next in sequence based on precedes relations
102 | - Complete prerequisite tasks to unblock dependent tasks
103 | - Check entity status to identify active work items
104 | - Use the session ID when using other tools to maintain session tracking
105 | - Establish a regular cadence of project management sessions
106 | - Use the structured overview to make deliberate choices about where to focus your effort
107 | - Consider creating or updating project entities after reviewing the current state
108 | - Follow up on projects with approaching deadlines
```
--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A comprehensive tool for initializing a new quantitative research session, providing structured information about ongoing research projects, datasets, statistical models, and recent research activities.
2 |
3 | When to use this tool:
4 | - Beginning a new quantitative analysis session
5 | - Getting oriented to your current research state across multiple projects
6 | - Planning which research elements to focus on in the current session
7 | - Reviewing recent research activities and progress
8 | - Identifying active research projects and their status
9 | - Exploring available datasets for analysis
10 | - Reviewing current research questions
11 | - Examining statistical models and their performance
12 | - Viewing recent visualizations of your data
13 | - Establishing research context before diving into specific analysis tasks
14 | - Re-engaging with your research after time away
15 | - Prioritizing high-priority research tasks
16 | - Tracking the status of various research activities
17 | - Understanding sequential research processes
18 |
19 | Key features:
20 | - Generates a unique session identifier for tracking research activities
21 | - Retrieves and displays recent research sessions with summaries
22 | - Lists active research projects with status information
23 | - Provides a sample of available datasets with key information
24 | - Presents current research questions guiding your studies
25 | - Highlights recent statistical models with performance metrics
26 | - Displays recent visualizations with brief descriptions
27 | - Formats information in an easily scannable format for quick orientation
28 | - Integrates with the loadcontext tool for deeper exploration
29 | - Maintains continuity between research sessions
30 | - Tracks research session history for progress review
31 | - Displays high-priority research tasks needing attention
32 | - Shows status information for key research activities
33 | - Presents sequential relationships between research processes
34 |
35 | Parameters explained:
36 | No parameters required - the tool automatically retrieves all relevant context.
37 |
38 | Return information:
39 | - Recent research sessions (up to 3) with:
40 | - Date
41 | - Project name
42 | - Brief summary
43 |
44 | - Active research projects with:
45 | - Project name
46 | - Current status (via has_status relation)
47 | - Priority (if assigned via has_priority relation)
48 |
49 | - Available datasets (up to 5) with:
50 | - Dataset name
51 | - Type of data
52 | - Associated project
53 | - Status (active, completed, pending, abandoned)
54 |
55 | - Research questions (up to 5) with:
56 | - Question text
57 | - Associated project
58 | - Status (via has_status relation)
59 |
60 | - Recent statistical models with:
61 | - Model name
62 | - Model type
63 | - Performance metrics
64 | - Status (via has_status relation)
65 |
66 | - Recent visualizations with:
67 | - Visualization name
68 | - Type (chart, plot, etc.)
69 | - Associated dataset
70 |
71 | - High-priority research tasks (up to 5) with:
72 | - Task name
73 | - Current status (active, completed, pending, abandoned)
74 | - Associated project
75 |
76 | - Upcoming research activities (up to 3) with:
77 | - Activity name
78 | - Prerequisite activities (via precedes relation)
79 | - Current status (via has_status relation)
80 |
81 | Status and Priority Information:
82 | - Research activities are displayed with their current status values
83 | - High-priority tasks are prominently highlighted for attention
84 | - Valid status values include: active, completed, pending, abandoned
85 | - Priority values (high, low) help indicate which tasks need immediate attention
86 | - Status is retrieved through has_status relations
87 | - Priority is retrieved through has_priority relations
88 |
89 | Sequential Process Information:
90 | - Upcoming activities show prerequisite tasks that must be completed first
91 | - Research phases are presented in their logical sequence
92 | - The precedes relation is used to determine activity ordering
93 | - Sequential relationships help visualize the research workflow
94 |
95 | Session Workflow:
96 | 1. Start a research session with startsession
97 | 2. Review the provided context to decide what to focus on
98 | 3. Use loadcontext to retrieve detailed information about specific research elements
99 | 4. Conduct your analysis, adding new elements with buildcontext as needed
100 | 5. End the session with endsession to record your research progress
101 |
102 | You should:
103 | - Begin each focused research period with startsession to establish context
104 | - Review recent sessions to maintain continuity in your research
105 | - Identify active projects that require attention
106 | - Note available datasets for potential analysis
107 | - Consider current research questions that need investigation
108 | - Review existing statistical models before creating new ones
109 | - Examine recent visualizations to understand data representation
110 | - Prioritize high-priority tasks for immediate attention
111 | - Check the status of research activities to maintain progress awareness
112 | - Consider sequential relationships when planning your research activities
113 | - Use the session ID when using other tools to maintain session tracking
114 | - After completing a session, record your progress using endsession
115 | - Establish a regular cadence of research sessions to maintain momentum
116 | - Use the structured overview to make deliberate choices about where to focus your analytical effort
```
--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_startsession.txt:
--------------------------------------------------------------------------------
```
1 | A comprehensive tool for initializing a new quantitative research session, providing structured information about ongoing research projects, datasets, statistical models, and recent research activities.
2 |
3 | When to use this tool:
4 | - Beginning a new quantitative analysis session
5 | - Getting oriented to your current research state across multiple projects
6 | - Planning which research elements to focus on in the current session
7 | - Reviewing recent research activities and progress
8 | - Identifying active research projects and their status
9 | - Exploring available datasets for analysis
10 | - Reviewing current research questions
11 | - Examining statistical models and their performance
12 | - Viewing recent visualizations of your data
13 | - Establishing research context before diving into specific analysis tasks
14 | - Re-engaging with your research after time away
15 | - Prioritizing high-priority research tasks
16 | - Tracking the status of various research activities
17 | - Understanding sequential research processes
18 |
19 | Key features:
20 | - Generates a unique session identifier for tracking research activities
21 | - Retrieves and displays recent research sessions with summaries
22 | - Lists active research projects with status information
23 | - Provides a sample of available datasets with key information
24 | - Presents current research questions guiding your studies
25 | - Highlights recent statistical models with performance metrics
26 | - Displays recent visualizations with brief descriptions
27 | - Formats information in an easily scannable format for quick orientation
28 | - Integrates with the loadcontext tool for deeper exploration
29 | - Maintains continuity between research sessions
30 | - Tracks research session history for progress review
31 | - Displays high-priority research tasks needing attention
32 | - Shows status information for key research activities
33 | - Presents sequential relationships between research processes
34 |
35 | Parameters explained:
36 | No parameters required - the tool automatically retrieves all relevant context.
37 |
38 | Return information:
39 | - Recent research sessions (up to 3) with:
40 | - Date
41 | - Project name
42 | - Brief summary
43 |
44 | - Active research projects with:
45 | - Project name
46 | - Current status (via has_status relation)
47 | - Priority (if assigned via has_priority relation)
48 |
49 | - Available datasets (up to 5) with:
50 | - Dataset name
51 | - Type of data
52 | - Associated project
53 | - Status (active, completed, pending, abandoned)
54 |
55 | - Research questions (up to 5) with:
56 | - Question text
57 | - Associated project
58 | - Status (via has_status relation)
59 |
60 | - Recent statistical models with:
61 | - Model name
62 | - Model type
63 | - Performance metrics
64 | - Status (via has_status relation)
65 |
66 | - Recent visualizations with:
67 | - Visualization name
68 | - Type (chart, plot, etc.)
69 | - Associated dataset
70 |
71 | - High-priority research tasks (up to 5) with:
72 | - Task name
73 | - Current status (active, completed, pending, abandoned)
74 | - Associated project
75 |
76 | - Upcoming research activities (up to 3) with:
77 | - Activity name
78 | - Prerequisite activities (via precedes relation)
79 | - Current status (via has_status relation)
80 |
81 | Status and Priority Information:
82 | - Research activities are displayed with their current status values
83 | - High-priority tasks are prominently highlighted for attention
84 | - Valid status values include: active, completed, pending, abandoned
85 | - Priority values (high, low) help indicate which tasks need immediate attention
86 | - Status is retrieved through has_status relations
87 | - Priority is retrieved through has_priority relations
88 |
89 | Sequential Process Information:
90 | - Upcoming activities show prerequisite tasks that must be completed first
91 | - Research phases are presented in their logical sequence
92 | - The precedes relation is used to determine activity ordering
93 | - Sequential relationships help visualize the research workflow
94 |
95 | Session Workflow:
96 | 1. Start a research session with startsession
97 | 2. Review the provided context to decide what to focus on
98 | 3. Use loadcontext to retrieve detailed information about specific research elements
99 | 4. Conduct your analysis, adding new elements with buildcontext as needed
100 | 5. End the session with endsession to record your research progress
101 |
102 | You should:
103 | - Begin each focused research period with startsession to establish context
104 | - Review recent sessions to maintain continuity in your research
105 | - Identify active projects that require attention
106 | - Note available datasets for potential analysis
107 | - Consider current research questions that need investigation
108 | - Review existing statistical models before creating new ones
109 | - Examine recent visualizations to understand data representation
110 | - Prioritize high-priority tasks for immediate attention
111 | - Check the status of research activities to maintain progress awareness
112 | - Consider sequential relationships when planning your research activities
113 | - Use the session ID when using other tools to maintain session tracking
114 | - After completing a session, record your progress using endsession
115 | - Establish a regular cadence of research sessions to maintain momentum
116 | - Use the structured overview to make deliberate choices about where to focus your analytical effort
```
--------------------------------------------------------------------------------
/main/descriptions/student_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for retrieving comprehensive, structured information about specific educational entities, providing context-rich details tailored to academic needs.
2 |
3 | When to use this tool:
4 | - Retrieving detailed information about courses, assignments, exams, and academic concepts
5 | - Exploring course materials, lecture schedules, and assignment deadlines
6 | - Preparing for upcoming exams by identifying key concepts and resources
7 | - Tracking assignment status and due dates
8 | - Understanding relationships between academic concepts
9 | - Examining course structures and learning resources
10 | - Planning study sessions around specific courses or topics
11 | - Reviewing term schedules and upcoming deadlines
12 | - Organizing academic resources by courses and concepts
13 | - Establishing context for effective learning and study planning
14 | - Viewing entity status information (not_started, in_progress, complete)
15 | - Checking priority levels for assignments and tasks
16 | - Understanding sequential relationships between academic entities
17 |
18 | Key features:
19 | - Provides richly formatted, context-aware information about educational entities
20 | - Adapts output format based on entity type (course, assignment, exam, concept, term)
21 | - Presents both direct entity information and related academic elements
22 | - Shows time-sensitive information like due dates and exam schedules
23 | - Tracks loaded entities within the current session for continuity
24 | - Formats information in a clean, readable markdown structure
25 | - Automatically identifies relationships between academic entities
26 | - Displays status information via has_status relations
27 | - Shows priority levels via has_priority relations
28 | - Presents sequential relationships through follows relations
29 | - Highlights status of assignments and upcoming deadlines
30 | - Shows progress metrics for courses and assignment completion
31 |
32 | Parameters explained:
33 | 1. entityName: Required - The name of the entity to retrieve context for
34 | - Example: "Introduction to Computer Science", "Midterm Paper", "Binary Trees"
35 | 2. entityType: Optional - The type of entity being retrieved
36 | - Default: "course"
37 | - Accepts values from valid entity types for the student domain
38 | - Helps the system format the output appropriately
39 | 3. sessionId: Optional - The current session identifier
40 | - Typically provided by startsession
41 | - Used for tracking entity views within the session
42 |
43 | Each entity type returns specialized context information:
44 | - Course: Shows code, status (via has_status), schedule, location, description, professor information, lectures, assignments (with status and priority), exams, key concepts, and resources
45 | - Assignment: Displays course, status (not_started, in_progress, complete), priority (low, high), due date, points, time remaining, instructions, related concepts, helpful resources, and your notes
46 | - Exam: Shows course, date, time remaining, location, format, duration, concepts to study, key lectures, and study resources
47 | - Concept: Displays difficulty level, description, related concepts (including sequential relationships), courses covering this concept, and learning resources
48 | - Term: Shows start date, end date, status, courses for the term (with completion percentages), and upcoming deadlines
49 | - Other Entity Types: Shows observations and both incoming and outgoing relationships within the knowledge graph
50 |
51 | Status and Priority:
52 | - All entities include status values (not_started, in_progress, complete) retrieved via has_status relations
53 | - Relevant entities include priority values (low, high) retrieved via has_priority relations
54 | - Status information is used to calculate completion percentages and filter assignments
55 | - Priority information helps identify important tasks and assignments
56 |
57 | Sequential Relationships:
58 | - Related entities may have follows relationships indicating recommended sequence
59 | - Course view shows sequenced lectures and assignments
60 | - Concept view shows prerequisite relationships between concepts
61 |
62 | Return information:
63 | - Formatted markdown text with hierarchical structure
64 | - Sections adapted to the specific entity type
65 | - Related entities shown with their status, priority, and descriptions
66 | - Error messages if the entity doesn't exist or can't be retrieved
67 |
68 | You should:
69 | - Specify the exact entity name for accurate retrieval
70 | - Provide the entity type when possible for optimally formatted results
71 | - Start with course entities to get a high-level overview of academic materials
72 | - Use assignment context to track deadlines and submission status
73 | - Prepare for exams by examining exam context for study resources
74 | - Explore concept context to understand relationships between academic topics
75 | - Review term context to plan your academic schedule
76 | - Pay attention to status values to identify incomplete assignments
77 | - Consider priority information when planning your study schedule
78 | - Follow sequential relationships to create effective learning paths
79 | - After retrieving context, follow up on specific entities of interest
80 | - Use in conjunction with startsession to maintain session tracking
81 | - Combine with endsession to document your learning progress
82 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/student/student_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for retrieving comprehensive, structured information about specific educational entities, providing context-rich details tailored to academic needs.
2 |
3 | When to use this tool:
4 | - Retrieving detailed information about courses, assignments, exams, and academic concepts
5 | - Exploring course materials, lecture schedules, and assignment deadlines
6 | - Preparing for upcoming exams by identifying key concepts and resources
7 | - Tracking assignment status and due dates
8 | - Understanding relationships between academic concepts
9 | - Examining course structures and learning resources
10 | - Planning study sessions around specific courses or topics
11 | - Reviewing term schedules and upcoming deadlines
12 | - Organizing academic resources by courses and concepts
13 | - Establishing context for effective learning and study planning
14 | - Viewing entity status information (not_started, in_progress, complete)
15 | - Checking priority levels for assignments and tasks
16 | - Understanding sequential relationships between academic entities
17 |
18 | Key features:
19 | - Provides richly formatted, context-aware information about educational entities
20 | - Adapts output format based on entity type (course, assignment, exam, concept, term)
21 | - Presents both direct entity information and related academic elements
22 | - Shows time-sensitive information like due dates and exam schedules
23 | - Tracks loaded entities within the current session for continuity
24 | - Formats information in a clean, readable markdown structure
25 | - Automatically identifies relationships between academic entities
26 | - Displays status information via has_status relations
27 | - Shows priority levels via has_priority relations
28 | - Presents sequential relationships through follows relations
29 | - Highlights status of assignments and upcoming deadlines
30 | - Shows progress metrics for courses and assignment completion
31 |
32 | Parameters explained:
33 | 1. entityName: Required - The name of the entity to retrieve context for
34 | - Example: "Introduction to Computer Science", "Midterm Paper", "Binary Trees"
35 | 2. entityType: Optional - The type of entity being retrieved
36 | - Default: "course"
37 | - Accepts values from valid entity types for the student domain
38 | - Helps the system format the output appropriately
39 | 3. sessionId: Optional - The current session identifier
40 | - Typically provided by startsession
41 | - Used for tracking entity views within the session
42 |
43 | Each entity type returns specialized context information:
44 | - Course: Shows code, status (via has_status), schedule, location, description, professor information, lectures, assignments (with status and priority), exams, key concepts, and resources
45 | - Assignment: Displays course, status (not_started, in_progress, complete), priority (low, high), due date, points, time remaining, instructions, related concepts, helpful resources, and your notes
46 | - Exam: Shows course, date, time remaining, location, format, duration, concepts to study, key lectures, and study resources
47 | - Concept: Displays difficulty level, description, related concepts (including sequential relationships), courses covering this concept, and learning resources
48 | - Term: Shows start date, end date, status, courses for the term (with completion percentages), and upcoming deadlines
49 | - Other Entity Types: Shows observations and both incoming and outgoing relationships within the knowledge graph
50 |
51 | Status and Priority:
52 | - All entities include status values (not_started, in_progress, complete) retrieved via has_status relations
53 | - Relevant entities include priority values (low, high) retrieved via has_priority relations
54 | - Status information is used to calculate completion percentages and filter assignments
55 | - Priority information helps identify important tasks and assignments
56 |
57 | Sequential Relationships:
58 | - Related entities may have follows relationships indicating recommended sequence
59 | - Course view shows sequenced lectures and assignments
60 | - Concept view shows prerequisite relationships between concepts
61 |
62 | Return information:
63 | - Formatted markdown text with hierarchical structure
64 | - Sections adapted to the specific entity type
65 | - Related entities shown with their status, priority, and descriptions
66 | - Error messages if the entity doesn't exist or can't be retrieved
67 |
68 | You should:
69 | - Specify the exact entity name for accurate retrieval
70 | - Provide the entity type when possible for optimally formatted results
71 | - Start with course entities to get a high-level overview of academic materials
72 | - Use assignment context to track deadlines and submission status
73 | - Prepare for exams by examining exam context for study resources
74 | - Explore concept context to understand relationships between academic topics
75 | - Review term context to plan your academic schedule
76 | - Pay attention to status values to identify incomplete assignments
77 | - Consider priority information when planning your study schedule
78 | - Follow sequential relationships to create effective learning paths
79 | - After retrieving context, follow up on specific entities of interest
80 | - Use in conjunction with startsession to maintain session tracking
81 | - Combine with endsession to document your learning progress
82 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A precise tool for removing elements from the qualitative research knowledge graph, enabling researchers to maintain data accuracy and refine their analytical framework.
2 |
3 | When to use this tool:
4 | - Removing incorrect or duplicate research entities
5 | - Deleting erroneous relationships between research elements
6 | - Clearing outdated observations from research entities
7 | - Restructuring your research framework as analysis evolves
8 | - Removing pilot or test data that shouldn't be included in final analysis
9 | - Cleaning up the knowledge graph during research refinement phases
10 | - Eliminating deprecated codes, themes, or concepts that no longer fit your analytical framework
11 | - Removing sensitive information that should not be retained
12 | - Reorganizing your analytical structure by removing and recreating elements
13 | - Updating status assignments when research activities change state
14 | - Modifying priority assignments as research focus shifts
15 | - Restructuring sequential relationships between research processes
16 |
17 | Key features:
18 | - Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
19 | - Maintains knowledge graph integrity during deletion operations
20 | - Supports batch deletion of multiple items in a single operation
21 | - Returns clear confirmation of deletion results
22 | - Preserves the overall structure of the research knowledge graph while removing specific elements
23 | - Performs validation to ensure deletion requests are properly formatted
24 | - Handles status and priority relation management
25 | - Supports modification of sequential process relationships
26 |
27 | Parameters explained:
28 | 1. type: The type of deletion operation to perform
29 | - Accepts: "entities", "relations", or "observations"
30 | - Determines how the data parameter is interpreted
31 | 2. data: The elements to remove from the knowledge graph (structure varies by type):
32 | - For "entities": Array of entity names to delete
33 | * Example: ["Participant_A", "Interview_3"]
34 | - For "relations": Array of relation objects, each containing:
35 | * from: Name of the source entity
36 | * to: Name of the target entity
37 | * relationType: Type of relationship to remove (e.g., "participated_in", "codes", "has_status", "has_priority", "precedes")
38 | - For "observations": Array of objects, each containing:
39 | * entityName: Name of the entity to remove observations from
40 | * indices: Array of numeric indices identifying which observations to remove
41 |
42 | Deletion behavior by type:
43 | - Entities: Removes the specified entities and all their associated relations from the knowledge graph
44 | - Relations: Removes only the specified relationships, leaving the connected entities intact
45 | - Observations: Removes specific observations from entities while preserving the entities themselves
46 |
47 | Status and Priority Management:
48 | - When deleting status or priority entities, be aware of the impact on entities that reference them
49 | - For changing an entity's status or priority, first delete the existing has_status or has_priority relation, then create a new one
50 | - Consider the research workflow implications when removing status entities or relations
51 | - Deletion of a status entity will remove all has_status relations pointing to it
52 |
53 | Sequential Process Management:
54 | - Removing precedes relations affects the logical flow of research processes
55 | - Consider restructuring sequential relationships after deletion to maintain process continuity
56 | - When reorganizing research phases, update all affected precedes relations
57 |
58 | Safety considerations:
59 | - Entity deletion is permanent and will also remove all relationships involving those entities
60 | - Consider exporting or backing up your research knowledge graph before performing large-scale deletions
61 | - For sensitive operations, consider removing specific observations rather than entire entities
62 | - When removing codes or themes, consider the impact on your analytical framework
63 | - Status changes should be carefully managed to maintain accurate research progress tracking
64 | - Changes to sequential relationships may affect dependent research activities
65 |
66 | Return information:
67 | - JSON response indicating success or failure
68 | - For successful operations:
69 | * Success flag set to true
70 | * Confirmation message
71 | - For failed operations:
72 | * Success flag set to false
73 | * Error message describing the issue
74 |
75 | You should:
76 | - Be specific in your deletion requests to avoid unintended data loss
77 | - Use relations deletion when you want to disconnect entities without removing them
78 | - For observations, provide the exact indices to ensure only the intended content is removed
79 | - When restructuring your analysis, consider how deletions will affect related elements
80 | - Use deletecontext in conjunction with buildcontext to refine and evolve your research framework
81 | - Regularly review your knowledge graph for elements that may need to be removed or updated
82 | - Consider the cascading effects of entity deletion on your overall research structure
83 | - Use observation deletion for minor corrections rather than removing entire entities
84 | - When updating entity status, delete the old has_status relation before creating a new one
85 | - Maintain logical consistency when modifying sequential process relationships
```
--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A precise tool for removing elements from the qualitative research knowledge graph, enabling researchers to maintain data accuracy and refine their analytical framework.
2 |
3 | When to use this tool:
4 | - Removing incorrect or duplicate research entities
5 | - Deleting erroneous relationships between research elements
6 | - Clearing outdated observations from research entities
7 | - Restructuring your research framework as analysis evolves
8 | - Removing pilot or test data that shouldn't be included in final analysis
9 | - Cleaning up the knowledge graph during research refinement phases
10 | - Eliminating deprecated codes, themes, or concepts that no longer fit your analytical framework
11 | - Removing sensitive information that should not be retained
12 | - Reorganizing your analytical structure by removing and recreating elements
13 | - Updating status assignments when research activities change state
14 | - Modifying priority assignments as research focus shifts
15 | - Restructuring sequential relationships between research processes
16 |
17 | Key features:
18 | - Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
19 | - Maintains knowledge graph integrity during deletion operations
20 | - Supports batch deletion of multiple items in a single operation
21 | - Returns clear confirmation of deletion results
22 | - Preserves the overall structure of the research knowledge graph while removing specific elements
23 | - Performs validation to ensure deletion requests are properly formatted
24 | - Handles status and priority relation management
25 | - Supports modification of sequential process relationships
26 |
27 | Parameters explained:
28 | 1. type: The type of deletion operation to perform
29 | - Accepts: "entities", "relations", or "observations"
30 | - Determines how the data parameter is interpreted
31 | 2. data: The elements to remove from the knowledge graph (structure varies by type):
32 | - For "entities": Array of entity names to delete
33 | * Example: ["Participant_A", "Interview_3"]
34 | - For "relations": Array of relation objects, each containing:
35 | * from: Name of the source entity
36 | * to: Name of the target entity
37 | * relationType: Type of relationship to remove (e.g., "participated_in", "codes", "has_status", "has_priority", "precedes")
38 | - For "observations": Array of objects, each containing:
39 | * entityName: Name of the entity to remove observations from
40 | * indices: Array of numeric indices identifying which observations to remove
41 |
42 | Deletion behavior by type:
43 | - Entities: Removes the specified entities and all their associated relations from the knowledge graph
44 | - Relations: Removes only the specified relationships, leaving the connected entities intact
45 | - Observations: Removes specific observations from entities while preserving the entities themselves
46 |
47 | Status and Priority Management:
48 | - When deleting status or priority entities, be aware of the impact on entities that reference them
49 | - For changing an entity's status or priority, first delete the existing has_status or has_priority relation, then create a new one
50 | - Consider the research workflow implications when removing status entities or relations
51 | - Deletion of a status entity will remove all has_status relations pointing to it
52 |
53 | Sequential Process Management:
54 | - Removing precedes relations affects the logical flow of research processes
55 | - Consider restructuring sequential relationships after deletion to maintain process continuity
56 | - When reorganizing research phases, update all affected precedes relations
57 |
58 | Safety considerations:
59 | - Entity deletion is permanent and will also remove all relationships involving those entities
60 | - Consider exporting or backing up your research knowledge graph before performing large-scale deletions
61 | - For sensitive operations, consider removing specific observations rather than entire entities
62 | - When removing codes or themes, consider the impact on your analytical framework
63 | - Status changes should be carefully managed to maintain accurate research progress tracking
64 | - Changes to sequential relationships may affect dependent research activities
65 |
66 | Return information:
67 | - JSON response indicating success or failure
68 | - For successful operations:
69 | * Success flag set to true
70 | * Confirmation message
71 | - For failed operations:
72 | * Success flag set to false
73 | * Error message describing the issue
74 |
75 | You should:
76 | - Be specific in your deletion requests to avoid unintended data loss
77 | - Use relations deletion when you want to disconnect entities without removing them
78 | - For observations, provide the exact indices to ensure only the intended content is removed
79 | - When restructuring your analysis, consider how deletions will affect related elements
80 | - Use deletecontext in conjunction with buildcontext to refine and evolve your research framework
81 | - Regularly review your knowledge graph for elements that may need to be removed or updated
82 | - Consider the cascading effects of entity deletion on your overall research structure
83 | - Use observation deletion for minor corrections rather than removing entire entities
84 | - When updating entity status, delete the old has_status relation before creating a new one
85 | - Maintain logical consistency when modifying sequential process relationships
```
--------------------------------------------------------------------------------
/main/descriptions/project_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for retrieving detailed contextual information about project entities, providing rich insights tailored to each entity type in the project management domain.
2 |
3 | When to use this tool:
4 | - Retrieving comprehensive information about projects, tasks, milestones, and team members
5 | - Exploring task dependencies and critical path information
6 | - Examining milestone progress and completion status
7 | - Reviewing team member assignments and workload
8 | - Analyzing resource allocation and availability
9 | - Inspecting project risks and issues
10 | - Preparing for project status updates and planning meetings
11 | - Examining project timelines and progress metrics
12 | - Getting a holistic view of project status and health
13 | - Understanding relationships between project entities
14 | - Viewing entity status information (inactive, active, complete)
15 | - Checking priority levels for tasks and activities
16 | - Understanding sequential relationships between tasks
17 |
18 | Key features:
19 | - Provides richly formatted, context-aware information about project management entities
20 | - Adapts output format based on entity type (project, task, milestone, teamMember, resource)
21 | - Presents both direct entity information and related elements
22 | - Shows project metrics, task completion rates, and milestone progress
23 | - Tracks entity views within the current project session
24 | - Formats information in a structured, readable markdown format
25 | - Highlights relationships between tasks, milestones, and team members
26 | - Presents critical path information for task dependencies
27 | - Shows resource utilization metrics and availability
28 | - Displays status information via has_status relations
29 | - Shows priority levels via has_priority relations
30 | - Presents sequential relationships through precedes relations
31 |
32 | Parameters explained:
33 | 1. entityName: Required - The name of the entity to retrieve context for
34 | - Example: "Marketing Campaign Q4", "Design Homepage", "Website Launch"
35 | 2. entityType: Optional - The type of entity being retrieved
36 | - Default: "project"
37 | - Helps the system format the output appropriately
38 | - Common types include: "project", "task", "milestone", "teamMember", "resource", "status", "priority"
39 | 3. sessionId: Optional - The current session identifier
40 | - Typically provided by startsession
41 | - Used for tracking entity views within the session
42 |
43 | Each entity type returns specialized context information:
44 | - Project: Shows project status (via has_status), description, timeline, budget, goal, tasks, milestones, issues, team members, risks, and task completion rate
45 | - Task: Displays project affiliation, status (inactive, active, complete), priority (low, high), due date, assignee, description, critical path status, task dependencies, and task sequencing (preceding and following tasks)
46 | - Milestone: Shows project affiliation, status (via has_status), date, completion criteria, description, progress percentage, days remaining, required tasks, and blocking tasks
47 | - Team Member: Displays role, skills, availability, workload, assigned tasks, projects, upcoming deadlines, and overdue tasks
48 | - Resource: Shows type, project affiliation, availability, capacity, cost, usage percentage, assigned tasks, and team members using the resource
49 | - Status: Shows all entities assigned this status value, organized by entity type
50 | - Priority: Shows all entities assigned this priority value, organized by entity type
51 | - Other Entity Types: Shows basic entity information, observations, incoming relations, and outgoing relations
52 |
53 | Status and Priority Information:
54 | - All entity displays include status information when available via has_status relations
55 | - Tasks and other prioritized elements show priority assignments via has_priority relations
56 | - Valid status values include: inactive, active, complete
57 | - Valid priority values include: high, low
58 |
59 | Sequential Task Relationships:
60 | - Task displays show preceding and following tasks through precedes relations
61 | - Sequential relationships are visualized to show workflow between tasks
62 | - Tasks display their position in the overall project workflow
63 | - Critical path information highlights essential task sequences
64 |
65 | Return information:
66 | - Formatted markdown text with hierarchical structure
67 | - Sections adapted to the specific entity type
68 | - Related entities shown with their relationships
69 | - Progress metrics and completion statistics where applicable
70 | - Status and priority information prominently displayed
71 | - Sequential relationships clearly indicated
72 | - Error messages if the entity doesn't exist or can't be retrieved
73 |
74 | You should:
75 | - Specify the exact entity name for accurate retrieval
76 | - Provide the entity type when possible for optimally formatted results
77 | - Start with project entities to get a high-level overview
78 | - Examine task context to understand dependencies and critical path
79 | - Review milestone context to assess progress towards key deliverables
80 | - Use team member context to evaluate workload and assignments
81 | - Explore resource context to understand allocation and availability
82 | - Check status entities to see all project elements at the same stage
83 | - Review priority entities to identify critical project tasks
84 | - Explore sequential relationships to understand task workflows
85 | - After retrieving context, follow up on specific entities of interest
86 | - Use in conjunction with startsession to maintain session tracking
87 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/project/project_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for retrieving detailed contextual information about project entities, providing rich insights tailored to each entity type in the project management domain.
2 |
3 | When to use this tool:
4 | - Retrieving comprehensive information about projects, tasks, milestones, and team members
5 | - Exploring task dependencies and critical path information
6 | - Examining milestone progress and completion status
7 | - Reviewing team member assignments and workload
8 | - Analyzing resource allocation and availability
9 | - Inspecting project risks and issues
10 | - Preparing for project status updates and planning meetings
11 | - Examining project timelines and progress metrics
12 | - Getting a holistic view of project status and health
13 | - Understanding relationships between project entities
14 | - Viewing entity status information (inactive, active, complete)
15 | - Checking priority levels for tasks and activities
16 | - Understanding sequential relationships between tasks
17 |
18 | Key features:
19 | - Provides richly formatted, context-aware information about project management entities
20 | - Adapts output format based on entity type (project, task, milestone, teamMember, resource)
21 | - Presents both direct entity information and related elements
22 | - Shows project metrics, task completion rates, and milestone progress
23 | - Tracks entity views within the current project session
24 | - Formats information in a structured, readable markdown format
25 | - Highlights relationships between tasks, milestones, and team members
26 | - Presents critical path information for task dependencies
27 | - Shows resource utilization metrics and availability
28 | - Displays status information via has_status relations
29 | - Shows priority levels via has_priority relations
30 | - Presents sequential relationships through precedes relations
31 |
32 | Parameters explained:
33 | 1. entityName: Required - The name of the entity to retrieve context for
34 | - Example: "Marketing Campaign Q4", "Design Homepage", "Website Launch"
35 | 2. entityType: Optional - The type of entity being retrieved
36 | - Default: "project"
37 | - Helps the system format the output appropriately
38 | - Common types include: "project", "task", "milestone", "teamMember", "resource", "status", "priority"
39 | 3. sessionId: Optional - The current session identifier
40 | - Typically provided by startsession
41 | - Used for tracking entity views within the session
42 |
43 | Each entity type returns specialized context information:
44 | - Project: Shows project status (via has_status), description, timeline, budget, goal, tasks, milestones, issues, team members, risks, and task completion rate
45 | - Task: Displays project affiliation, status (inactive, active, complete), priority (low, high), due date, assignee, description, critical path status, task dependencies, and task sequencing (preceding and following tasks)
46 | - Milestone: Shows project affiliation, status (via has_status), date, completion criteria, description, progress percentage, days remaining, required tasks, and blocking tasks
47 | - Team Member: Displays role, skills, availability, workload, assigned tasks, projects, upcoming deadlines, and overdue tasks
48 | - Resource: Shows type, project affiliation, availability, capacity, cost, usage percentage, assigned tasks, and team members using the resource
49 | - Status: Shows all entities assigned this status value, organized by entity type
50 | - Priority: Shows all entities assigned this priority value, organized by entity type
51 | - Other Entity Types: Shows basic entity information, observations, incoming relations, and outgoing relations
52 |
53 | Status and Priority Information:
54 | - All entity displays include status information when available via has_status relations
55 | - Tasks and other prioritized elements show priority assignments via has_priority relations
56 | - Valid status values include: inactive, active, complete
57 | - Valid priority values include: high, low
58 |
59 | Sequential Task Relationships:
60 | - Task displays show preceding and following tasks through precedes relations
61 | - Sequential relationships are visualized to show workflow between tasks
62 | - Tasks display their position in the overall project workflow
63 | - Critical path information highlights essential task sequences
64 |
65 | Return information:
66 | - Formatted markdown text with hierarchical structure
67 | - Sections adapted to the specific entity type
68 | - Related entities shown with their relationships
69 | - Progress metrics and completion statistics where applicable
70 | - Status and priority information prominently displayed
71 | - Sequential relationships clearly indicated
72 | - Error messages if the entity doesn't exist or can't be retrieved
73 |
74 | You should:
75 | - Specify the exact entity name for accurate retrieval
76 | - Provide the entity type when possible for optimally formatted results
77 | - Start with project entities to get a high-level overview
78 | - Examine task context to understand dependencies and critical path
79 | - Review milestone context to assess progress towards key deliverables
80 | - Use team member context to evaluate workload and assignments
81 | - Explore resource context to understand allocation and availability
82 | - Check status entities to see all project elements at the same stage
83 | - Review priority entities to identify critical project tasks
84 | - Explore sequential relationships to understand task workflows
85 | - After retrieving context, follow up on specific entities of interest
86 | - Use in conjunction with startsession to maintain session tracking
87 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for retrieving detailed contextual information about quantitative research entities, providing rich statistical insights tailored to each entity type.
2 |
3 | When to use this tool:
4 | - Retrieving comprehensive information about research projects, datasets, variables, and statistical elements
5 | - Exploring the statistical relationships between variables
6 | - Examining hypothesis tests and their results
7 | - Reviewing model performance metrics and parameters
8 | - Analyzing dataset properties and descriptive statistics
9 | - Inspecting visualizations related to specific datasets or projects
10 | - Understanding statistical test results and their significance
11 | - Preparing for statistical analysis by establishing data context
12 | - Examining variable distributions and correlations
13 | - Getting a holistic view of quantitative research progress
14 | - Tracking research activities by their current status
15 | - Managing tasks based on their assigned priorities
16 | - Understanding sequential relationships between research processes
17 |
18 | Key features:
19 | - Provides richly formatted, context-aware information about quantitative research entities
20 | - Adapts output format based on entity type (project, dataset, variable, model, hypothesis, statistical_test)
21 | - Presents both direct entity information and related statistical elements
22 | - Shows statistical metrics, p-values, and significance levels
23 | - Tracks entity views within the current research session
24 | - Formats information in a structured, readable markdown format
25 | - Highlights relationships between variables and statistical tests
26 | - Presents performance metrics for statistical models
27 | - Shows dataset characteristics and variable properties
28 | - Includes status information for tracking research progress
29 | - Displays priority assignments for critical research elements
30 | - Visualizes sequential relationships between research processes
31 |
32 | Parameters explained:
33 | 1. entityName: Required - The name of the entity to retrieve context for
34 | - Example: "Customer Satisfaction Study", "Survey_Dataset", "Age_Variable"
35 | 2. entityType: Optional - The type of entity being retrieved
36 | - Default: "project"
37 | - Helps the system format the output appropriately
38 | - Common types include: "project", "dataset", "variable", "model", "hypothesis", "statistical_test", "status", "priority"
39 | 3. sessionId: Optional - The current session identifier
40 | - Typically provided by startsession
41 | - Used for tracking entity views within the session
42 |
43 | Each entity type returns specialized context information:
44 | - Project: Shows project status (via has_status), description, datasets, hypotheses, statistical tests, models, key visualizations, and priority (via has_priority)
45 | - Dataset: Displays project affiliation, status (via has_status), size, variable count, descriptive statistics, visualizations, and models trained on it
46 | - Variable: Shows data type, role, scale, descriptive statistics, normality tests, and correlations with other variables
47 | - Model: Displays type, training dataset, creation date, status (via has_status), performance metrics, and model parameters
48 | - Hypothesis: Shows status (via has_status), p-value, creation date, associated tests, and project affiliation
49 | - Statistical Test: Shows test type, result, p-value, date, variables analyzed, and hypotheses tested
50 | - Status: Shows all entities assigned this status value, organized by entity type
51 | - Priority: Shows all entities assigned this priority value, organized by entity type
52 | - Other Entity Types: Shows basic entity information and observations
53 |
54 | Status and Priority Information:
55 | - All entity displays include status information when available via has_status relations
56 | - Priority assignments are shown for research tasks and other prioritized elements
57 | - Valid status values include: active, completed, pending, abandoned
58 | - Valid priority values include: high, low
59 |
60 | Sequential Process Relationships:
61 | - Entity displays show preceding and following entities through precedes relations
62 | - Process sequences are visualized to show workflow between research activities
63 | - Research phases and activities display their position in the overall analytical pipeline
64 | - Sequential relationships help understand dependencies in multi-step analysis processes
65 |
66 | Return information:
67 | - Formatted markdown text with hierarchical structure
68 | - Sections adapted to the specific entity type
69 | - Related entities shown with their statistical properties
70 | - Status and priority information prominently displayed
71 | - Sequential relationships clearly indicated
72 | - Error messages if the entity doesn't exist or can't be retrieved
73 |
74 | You should:
75 | - Specify the exact entity name for accurate retrieval
76 | - Provide the entity type when possible for optimally formatted results
77 | - Start with project entities to get a high-level overview of research
78 | - Examine dataset context to understand variable relationships
79 | - Review variable context to understand distributions and correlations
80 | - Use hypothesis context to assess research question outcomes
81 | - Explore model context to evaluate predictive performance
82 | - Examine statistical test context to understand analysis results
83 | - Check status entities to see all research elements at the same stage
84 | - Review priority entities to identify critical research tasks
85 | - Explore sequential relationships to understand analysis workflows
86 | - After retrieving context, follow up on specific entities of interest
87 | - Use in conjunction with startsession to maintain session tracking
88 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for retrieving detailed contextual information about quantitative research entities, providing rich statistical insights tailored to each entity type.
2 |
3 | When to use this tool:
4 | - Retrieving comprehensive information about research projects, datasets, variables, and statistical elements
5 | - Exploring the statistical relationships between variables
6 | - Examining hypothesis tests and their results
7 | - Reviewing model performance metrics and parameters
8 | - Analyzing dataset properties and descriptive statistics
9 | - Inspecting visualizations related to specific datasets or projects
10 | - Understanding statistical test results and their significance
11 | - Preparing for statistical analysis by establishing data context
12 | - Examining variable distributions and correlations
13 | - Getting a holistic view of quantitative research progress
14 | - Tracking research activities by their current status
15 | - Managing tasks based on their assigned priorities
16 | - Understanding sequential relationships between research processes
17 |
18 | Key features:
19 | - Provides richly formatted, context-aware information about quantitative research entities
20 | - Adapts output format based on entity type (project, dataset, variable, model, hypothesis, statistical_test)
21 | - Presents both direct entity information and related statistical elements
22 | - Shows statistical metrics, p-values, and significance levels
23 | - Tracks entity views within the current research session
24 | - Formats information in a structured, readable markdown format
25 | - Highlights relationships between variables and statistical tests
26 | - Presents performance metrics for statistical models
27 | - Shows dataset characteristics and variable properties
28 | - Includes status information for tracking research progress
29 | - Displays priority assignments for critical research elements
30 | - Visualizes sequential relationships between research processes
31 |
32 | Parameters explained:
33 | 1. entityName: Required - The name of the entity to retrieve context for
34 | - Example: "Customer Satisfaction Study", "Survey_Dataset", "Age_Variable"
35 | 2. entityType: Optional - The type of entity being retrieved
36 | - Default: "project"
37 | - Helps the system format the output appropriately
38 | - Common types include: "project", "dataset", "variable", "model", "hypothesis", "statistical_test", "status", "priority"
39 | 3. sessionId: Optional - The current session identifier
40 | - Typically provided by startsession
41 | - Used for tracking entity views within the session
42 |
43 | Each entity type returns specialized context information:
44 | - Project: Shows project status (via has_status), description, datasets, hypotheses, statistical tests, models, key visualizations, and priority (via has_priority)
45 | - Dataset: Displays project affiliation, status (via has_status), size, variable count, descriptive statistics, visualizations, and models trained on it
46 | - Variable: Shows data type, role, scale, descriptive statistics, normality tests, and correlations with other variables
47 | - Model: Displays type, training dataset, creation date, status (via has_status), performance metrics, and model parameters
48 | - Hypothesis: Shows status (via has_status), p-value, creation date, associated tests, and project affiliation
49 | - Statistical Test: Shows test type, result, p-value, date, variables analyzed, and hypotheses tested
50 | - Status: Shows all entities assigned this status value, organized by entity type
51 | - Priority: Shows all entities assigned this priority value, organized by entity type
52 | - Other Entity Types: Shows basic entity information and observations
53 |
54 | Status and Priority Information:
55 | - All entity displays include status information when available via has_status relations
56 | - Priority assignments are shown for research tasks and other prioritized elements
57 | - Valid status values include: active, completed, pending, abandoned
58 | - Valid priority values include: high, low
59 |
60 | Sequential Process Relationships:
61 | - Entity displays show preceding and following entities through precedes relations
62 | - Process sequences are visualized to show workflow between research activities
63 | - Research phases and activities display their position in the overall analytical pipeline
64 | - Sequential relationships help understand dependencies in multi-step analysis processes
65 |
66 | Return information:
67 | - Formatted markdown text with hierarchical structure
68 | - Sections adapted to the specific entity type
69 | - Related entities shown with their statistical properties
70 | - Status and priority information prominently displayed
71 | - Sequential relationships clearly indicated
72 | - Error messages if the entity doesn't exist or can't be retrieved
73 |
74 | You should:
75 | - Specify the exact entity name for accurate retrieval
76 | - Provide the entity type when possible for optimally formatted results
77 | - Start with project entities to get a high-level overview of research
78 | - Examine dataset context to understand variable relationships
79 | - Review variable context to understand distributions and correlations
80 | - Use hypothesis context to assess research question outcomes
81 | - Explore model context to evaluate predictive performance
82 | - Examine statistical test context to understand analysis results
83 | - Check status entities to see all research elements at the same stage
84 | - Review priority entities to identify critical research tasks
85 | - Explore sequential relationships to understand analysis workflows
86 | - After retrieving context, follow up on specific entities of interest
87 | - Use in conjunction with startsession to maintain session tracking
88 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/main/descriptions/common_advancedcontext.txt:
--------------------------------------------------------------------------------
```
1 | Advanced Context Tool
2 |
3 | A sophisticated tool for advanced querying and analysis of domain-specific knowledge graphs.
4 | This tool provides specialized operations to extract meaningful insights and contextual information from the graph structure.
5 | It enables deep exploration of entities, relationships, and contextual information relevant to each domain.
6 |
7 | When to use this tool:
8 | - Retrieving the complete knowledge graph structure
9 | - Searching for specific entities using keyword or partial matching
10 | - Fetching details on a precise set of entities
11 | - Exploring all relationships for a specific entity
12 | - Examining domain-specific data structures and hierarchies
13 | - Tracking progress on domain-specific elements
14 | - Investigating dependencies and connections between entities
15 | - Analyzing the evolution of projects, courses, or research
16 | - Understanding the context surrounding specific entities
17 | - Creating reports or summaries from your knowledge graph
18 |
19 | Key features:
20 | - Multiple specialized query operation types tailored to each domain
21 | - Full graph retrieval with entities and relations
22 | - Keyword-based search across entities and their properties
23 | - Direct entity lookup by exact name
24 | - Relationship exploration with filtering options
25 | - Domain-specific operations for specialized analysis
26 | - JSON-formatted response with query results
27 | - Detailed error reporting when operations fail
28 |
29 | Parameters explained:
30 | - type: The query operation type to perform, which must be one of the domain-specific operation types:
31 | * Common operations across domains:
32 | - "graph" - Retrieve the entire knowledge graph (all entities and relations)
33 | - "search" - Find entities by keyword/partial match in name, type, or observations
34 | - "nodes" - Get specific entities by exact name
35 | - "related" - Get all entities related to a specific entity
36 | * Developer-specific operations:
37 | - "decisions" - Get the decision history for a project
38 | - "milestone" - Get progress tracking for a specific milestone
39 | * Student-specific operations:
40 | - "course" - Get comprehensive details about a specific course
41 | - "deadlines" - Get upcoming assignment and exam deadlines
42 | - "assignment" - Get detailed status of a specific assignment
43 | - "exam" - Get preparation materials for a specific exam
44 | - "concepts" - Find related concepts based on a starting concept
45 | - "lecture" - Track and organize notes for lectures
46 | - "term" - Get overview of an academic term
47 | * Qualitative Research-specific operations:
48 | - "project" - Get comprehensive project information
49 | - "participant" - Get participant profile with demographic information
50 | - "codes" - Get coding information filtered by project
51 | - "themes" - Get theme information with associated codes
52 | - "transcript" - Get interview transcript content
53 | - "memo" - Get memo content with metadata
54 | - "analysis" - Get analysis artifacts for a project
55 | - "codebook" - Generate a structured codebook for a project
56 | * Quantitative Research-specific operations:
57 | - "project" - Get comprehensive project information
58 | - "dataset" - Get dataset analysis with variables and statistics
59 | - "hypothesis" - Get hypothesis tests and results
60 | - "variables" - Get variable relationships and dependencies
61 | - "statistics" - Get statistical test results
62 | - "visualizations" - Get visualization metadata
63 | - "model" - Get model performance metrics
64 | - "question" - Get research question details
65 | - "distribution" - Get variable distribution analysis
66 | * Project Management-specific operations:
67 | - "project" - Get comprehensive project information
68 | - "dependencies" - Map task dependencies and critical paths
69 | - "assignments" - Get team member assignments and workload
70 | - "milestones" - Track milestone progress and completion
71 | - "timeline" - Generate project timeline with dependencies
72 | - "resources" - Analyze resource allocation
73 | - "risks" - Identify and prioritize project risks
74 | - "decisions" - Get decision log for governance
75 | - "health" - Assess project health with KPIs
76 |
77 | - params: Operation-specific parameters structure (varies by type):
78 | * For common operations:
79 | - "graph": No parameters needed
80 | - "search": { query: "search text" }
81 | - "nodes": { names: ["EntityName1", "EntityName2", ...] }
82 | - "related": { entityName: "EntityName", relationTypes: ["type1", "type2", ...] }
83 | * For domain-specific operations: Refer to domain documentation for parameter details
84 |
85 | Operation details:
86 | - "graph" returns the complete knowledge graph structure for the active domain
87 | - "search" performs partial matching on entity names, types, and observations
88 | - "nodes" retrieves specific entities by exact name matching
89 | - "related" finds all incoming and outgoing relationships for an entity
90 | - Domain-specific operations provide specialized views and analytics tailored to that domain
91 |
92 | Return structures:
93 | - All operations return { success: true/false, ... } with operation-specific data
94 | - Error responses include detailed error messages
95 | - Domain-specific operations return structured data relevant to the operation type
96 |
97 | You should:
98 | 1. Select the most appropriate query type for your information need
99 | 2. Provide the required parameters for your chosen operation type
100 | 3. Start with broader queries and refine to more specific ones
101 | 4. Use "search" for exploratory investigation when entity names are unknown
102 | 5. Use "related" to explore the neighborhood of a known entity
103 | 6. Use domain-specific operations for specialized analysis
104 | 7. Combine query results to build comprehensive understanding
```
--------------------------------------------------------------------------------
/main/descriptions/student_advancedcontext.txt:
--------------------------------------------------------------------------------
```
1 | A comprehensive tool for querying and analyzing your educational knowledge graph.
2 | This tool provides specialized operations to extract meaningful insights and contextual information about your academic journey.
3 | It enables deep exploration of courses, assignments, exams, concepts, and educational resources.
4 |
5 | When to use this tool:
6 | - Retrieving the complete educational knowledge graph
7 | - Searching for specific academic entities using keyword matching
8 | - Fetching details on a precise set of educational entities
9 | - Getting comprehensive information about a specific course
10 | - Finding upcoming assignment and exam deadlines
11 | - Checking detailed status of a specific assignment
12 | - Preparing for exams with concept retrieval
13 | - Discovering connections between learning concepts
14 | - Tracking and reviewing lecture notes
15 | - Getting an overview of an entire academic term
16 | - Identifying entities by status (not_started, in_progress, complete)
17 | - Finding high-priority assignments and tasks
18 | - Exploring sequential relationships between entities
19 |
20 | Key features:
21 | - Ten specialized query operation types
22 | - Full educational graph retrieval with entities and relations
23 | - Keyword-based search across academic entities and their properties
24 | - Direct entity lookup by exact name
25 | - Course details including lectures, assignments, exams, and resources
26 | - Deadline tracking with time-based filtering
27 | - Assignment status with progress tracking through has_status relations
28 | - Priority information via has_priority relations
29 | - Exam preparation with related concepts and materials
30 | - Concept relationship mapping
31 | - Sequential entity relationships via follows relations
32 | - Lecture note organization
33 | - Term-based academic overview
34 | - JSON-formatted response with query results
35 |
36 | Parameters explained:
37 | - type: The query operation type to perform, which must be one of:
38 | * "graph" - Retrieve the entire educational knowledge graph
39 | * "search" - Find academic entities by keyword/partial match
40 | * "nodes" - Get specific educational entities by exact name
41 | * "course" - Get comprehensive details about a specific course
42 | * "deadlines" - Get upcoming assignment and exam deadlines
43 | * "assignment" - Get detailed status of a specific assignment
44 | * "exam" - Get preparation materials for a specific exam
45 | * "concepts" - Find related concepts based on a starting concept
46 | * "lecture" - Track and organize notes for lectures
47 | * "term" - Get overview of an academic term
48 | - params: Operation-specific parameters structure:
49 | * For "graph": No parameters needed
50 | * For "search": { query: "search text" }
51 | * For "nodes": { names: ["EntityName1", "EntityName2", ...] }
52 | * For "course": { courseName: "Course Name" }
53 | * For "deadlines": { termName: "Term Name", courseName: "Course Name", daysAhead: 14 }
54 | * For "assignment": { assignmentName: "Assignment Name" }
55 | * For "exam": { examName: "Exam Name" }
56 | * For "concepts": { conceptName: "Concept Name", depth: 1 }
57 | * For "lecture": { courseName: "Course Name" }
58 | * For "term": { termName: "Term Name" }
59 |
60 | Operation details:
61 | - "graph" returns the complete educational knowledge graph structure
62 | - "search" performs partial matching on entity names, types, and observations
63 | - "nodes" retrieves specific entities by exact name matching
64 | - "course" provides a comprehensive view of a course with its components
65 | - "deadlines" finds upcoming assignments and exams with due dates
66 | - "assignment" shows detailed status and related concepts for an assignment
67 | - "exam" provides study resources and related concepts for exam preparation
68 | - "concepts" maps relationships between different learning concepts
69 | - "lecture" organizes and retrieves notes for course lectures
70 | - "term" gives an overview of courses and work for an academic term
71 |
72 | Status information:
73 | - All entities include status information (not_started, in_progress, complete) via has_status relations
74 | - Status can be used in search queries (e.g., "status:complete")
75 | - Course views show assignment completion status
76 | - Term views highlight course completion percentages based on status
77 |
78 | Priority information:
79 | - Entities can have priority values (low, high) via has_priority relations
80 | - Priority can be used in search queries (e.g., "priority:high")
81 | - High-priority items are highlighted in course and term views
82 |
83 | Sequential relationships:
84 | - Entities can have sequence relationships through follows relations
85 | - Course views show recommended sequence of assignments and lectures
86 | - Concept views show prerequisite relationships
87 |
88 | Return structures:
89 | - All operations return { success: true/false, ... } with operation-specific data
90 | - Error responses include detailed error messages
91 | - Complex operations return rich, structured data about academic entities
92 | - Educational relationships are preserved in all returned data
93 | - Status and priority information is included in relevant entity data
94 |
95 | You should:
96 | 1. Select the most appropriate query type for your educational information need
97 | 2. Provide the required parameters for your chosen operation type
98 | 3. Start with broader queries and refine to more specific ones
99 | 4. Use "search" for exploratory investigation of your academic knowledge
100 | 5. Use "course" to get a comprehensive view of your coursework
101 | 6. Use "deadlines" to stay on top of upcoming academic work
102 | 7. Use "concepts" to understand relationships between learning topics
103 | 8. Filter search results by status to focus on incomplete work
104 | 9. Prioritize assignments based on priority values
105 | 10. Follow sequential relationships to create effective study plans
106 | 11. Combine query results to build comprehensive study strategies
```
--------------------------------------------------------------------------------
/student/student_advancedcontext.txt:
--------------------------------------------------------------------------------
```
1 | A comprehensive tool for querying and analyzing your educational knowledge graph.
2 | This tool provides specialized operations to extract meaningful insights and contextual information about your academic journey.
3 | It enables deep exploration of courses, assignments, exams, concepts, and educational resources.
4 |
5 | When to use this tool:
6 | - Retrieving the complete educational knowledge graph
7 | - Searching for specific academic entities using keyword matching
8 | - Fetching details on a precise set of educational entities
9 | - Getting comprehensive information about a specific course
10 | - Finding upcoming assignment and exam deadlines
11 | - Checking detailed status of a specific assignment
12 | - Preparing for exams with concept retrieval
13 | - Discovering connections between learning concepts
14 | - Tracking and reviewing lecture notes
15 | - Getting an overview of an entire academic term
16 | - Identifying entities by status (not_started, in_progress, complete)
17 | - Finding high-priority assignments and tasks
18 | - Exploring sequential relationships between entities
19 |
20 | Key features:
21 | - Ten specialized query operation types
22 | - Full educational graph retrieval with entities and relations
23 | - Keyword-based search across academic entities and their properties
24 | - Direct entity lookup by exact name
25 | - Course details including lectures, assignments, exams, and resources
26 | - Deadline tracking with time-based filtering
27 | - Assignment status with progress tracking through has_status relations
28 | - Priority information via has_priority relations
29 | - Exam preparation with related concepts and materials
30 | - Concept relationship mapping
31 | - Sequential entity relationships via follows relations
32 | - Lecture note organization
33 | - Term-based academic overview
34 | - JSON-formatted response with query results
35 |
36 | Parameters explained:
37 | - type: The query operation type to perform, which must be one of:
38 | * "graph" - Retrieve the entire educational knowledge graph
39 | * "search" - Find academic entities by keyword/partial match
40 | * "nodes" - Get specific educational entities by exact name
41 | * "course" - Get comprehensive details about a specific course
42 | * "deadlines" - Get upcoming assignment and exam deadlines
43 | * "assignment" - Get detailed status of a specific assignment
44 | * "exam" - Get preparation materials for a specific exam
45 | * "concepts" - Find related concepts based on a starting concept
46 | * "lecture" - Track and organize notes for lectures
47 | * "term" - Get overview of an academic term
48 | - params: Operation-specific parameters structure:
49 | * For "graph": No parameters needed
50 | * For "search": { query: "search text" }
51 | * For "nodes": { names: ["EntityName1", "EntityName2", ...] }
52 | * For "course": { courseName: "Course Name" }
53 | * For "deadlines": { termName: "Term Name", courseName: "Course Name", daysAhead: 14 }
54 | * For "assignment": { assignmentName: "Assignment Name" }
55 | * For "exam": { examName: "Exam Name" }
56 | * For "concepts": { conceptName: "Concept Name", depth: 1 }
57 | * For "lecture": { courseName: "Course Name" }
58 | * For "term": { termName: "Term Name" }
59 |
60 | Operation details:
61 | - "graph" returns the complete educational knowledge graph structure
62 | - "search" performs partial matching on entity names, types, and observations
63 | - "nodes" retrieves specific entities by exact name matching
64 | - "course" provides a comprehensive view of a course with its components
65 | - "deadlines" finds upcoming assignments and exams with due dates
66 | - "assignment" shows detailed status and related concepts for an assignment
67 | - "exam" provides study resources and related concepts for exam preparation
68 | - "concepts" maps relationships between different learning concepts
69 | - "lecture" organizes and retrieves notes for course lectures
70 | - "term" gives an overview of courses and work for an academic term
71 |
72 | Status information:
73 | - All entities include status information (not_started, in_progress, complete) via has_status relations
74 | - Status can be used in search queries (e.g., "status:complete")
75 | - Course views show assignment completion status
76 | - Term views highlight course completion percentages based on status
77 |
78 | Priority information:
79 | - Entities can have priority values (low, high) via has_priority relations
80 | - Priority can be used in search queries (e.g., "priority:high")
81 | - High-priority items are highlighted in course and term views
82 |
83 | Sequential relationships:
84 | - Entities can have sequence relationships through follows relations
85 | - Course views show recommended sequence of assignments and lectures
86 | - Concept views show prerequisite relationships
87 |
88 | Return structures:
89 | - All operations return { success: true/false, ... } with operation-specific data
90 | - Error responses include detailed error messages
91 | - Complex operations return rich, structured data about academic entities
92 | - Educational relationships are preserved in all returned data
93 | - Status and priority information is included in relevant entity data
94 |
95 | You should:
96 | 1. Select the most appropriate query type for your educational information need
97 | 2. Provide the required parameters for your chosen operation type
98 | 3. Start with broader queries and refine to more specific ones
99 | 4. Use "search" for exploratory investigation of your academic knowledge
100 | 5. Use "course" to get a comprehensive view of your coursework
101 | 6. Use "deadlines" to stay on top of upcoming academic work
102 | 7. Use "concepts" to understand relationships between learning topics
103 | 8. Filter search results by status to focus on incomplete work
104 | 9. Prioritize assignments based on priority values
105 | 10. Follow sequential relationships to create effective study plans
106 | 11. Combine query results to build comprehensive study strategies
```
--------------------------------------------------------------------------------
/main/descriptions/project_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A precise tool for removing elements from the project management knowledge graph, enabling project managers to maintain data accuracy and refine their project structure as needs evolve.
2 |
3 | When to use this tool:
4 | - Removing completed or canceled projects or tasks
5 | - Deleting erroneous relationships between project elements
6 | - Clearing outdated observations from project entities
7 | - Restructuring your project organization as the project evolves
8 | - Removing team members who are no longer part of the project
9 | - Correcting relationships between tasks, milestones, and resources
10 | - Cleaning up the knowledge graph during project phase transitions
11 | - Eliminating deprecated risks or issues that are no longer relevant
12 | - Removing preliminary project elements that have been superseded
13 | - Reorganizing your project structure by removing and recreating elements
14 | - Updating status assignments when task or project states change
15 | - Modifying priority levels as project needs shift
16 | - Restructuring sequential relationships between tasks and activities
17 |
18 | Key features:
19 | - Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
20 | - Maintains knowledge graph integrity during deletion operations
21 | - Supports batch deletion of multiple items in a single operation
22 | - Returns clear confirmation of deletion results
23 | - Preserves the overall structure of the project knowledge graph while removing specific elements
24 | - Performs validation to ensure deletion requests are properly formatted
25 | - Handles status and priority relation management
26 | - Supports modification of task sequencing relationships
27 |
28 | Parameters explained:
29 | 1. type: The type of deletion operation to perform
30 | - Accepts: "entities", "relations", or "observations"
31 | - Determines how the data parameter is interpreted
32 | 2. data: The elements to remove from the knowledge graph (structure varies by type):
33 | - For "entities": Array of entity names to delete
34 | * Example: ["Task_A", "Milestone_1"]
35 | - For "relations": Array of relation objects, each containing:
36 | * from: Name of the source entity
37 | * to: Name of the target entity
38 | * relationType: Type of relationship to remove (e.g., "part_of", "has_status", "has_priority", "precedes")
39 | * Example: [{ "from": "Task_A", "to": "Milestone_1", "relationType": "part_of" }]
40 | - For "observations": Array of objects, each containing:
41 | * entityName: Name of the entity to remove observations from
42 | * observations: Array of specific observations to remove
43 | * Example: [{ "entityName": "Project_X", "observations": ["duration:3 months", "budget:10000"] }]
44 |
45 | Deletion behavior by type:
46 | - Entities: Removes the specified entities and all their associated relations from the knowledge graph
47 | - Relations: Removes only the specified relationships, leaving the connected entities intact
48 | - Observations: Removes specific observations from entities while preserving the entities themselves
49 |
50 | Status and Priority Management:
51 | - When deleting status or priority entities, be aware that all has_status or has_priority relations using these entities will be removed
52 | - For changing an entity's status, delete the existing has_status relation before creating a new one
53 | - For changing priority, delete the existing has_priority relation before creating a new one
54 | - Status values (inactive, active, complete) are managed through relations, not direct properties
55 | - Priority values (low, high) are managed through relations, not direct properties
56 |
57 | Sequential Task Management:
58 | - Removing precedes relations will affect task sequencing and dependencies
59 | - When reorganizing project tasks, update all affected precedes relations
60 | - Consider the impact on project timelines when modifying sequential relationships
61 |
62 | Safety considerations:
63 | - Entity deletion is permanent and will also remove all relationships involving those entities
64 | - Consider exporting or backing up your project knowledge graph before performing large-scale deletions
65 | - For sensitive operations, consider removing specific observations rather than entire entities
66 | - When removing key project elements, consider the impact on your overall project structure
67 | - Status changes should be carefully managed to maintain accurate project tracking
68 | - Changes to task sequences may affect dependent project activities
69 |
70 | Return information:
71 | - JSON response indicating success or failure
72 | - For successful operations:
73 | - Success flag set to true
74 | - Confirmation message with count of deleted items
75 | * For entities: "Deleted X entities"
76 | * For relations: "Deleted X relations"
77 | * For observations: "Deleted observations from X entities"
78 | - For failed operations:
79 | - Success flag set to false
80 | - Error message describing the issue
81 |
82 | You should:
83 | - Be specific in your deletion requests to avoid unintended data loss
84 | - Use relations deletion when you want to disconnect entities without removing them
85 | - For observations, provide the exact observations to ensure only the intended content is removed
86 | - When restructuring your project, consider how deletions will affect related elements
87 | - Use deletecontext in conjunction with buildcontext to refine and evolve your project structure
88 | - Regularly review your knowledge graph for elements that may need to be removed or updated
89 | - Consider the cascading effects of entity deletion on your overall project structure
90 | - Delete completed tasks and milestones systematically when closing project phases
91 | - Remove resolved risks and issues to keep your project status current
92 | - When updating entity status, delete the old has_status relation before creating a new one
93 | - When updating entity priority, delete the old has_priority relation before creating a new one
94 | - Maintain logical consistency when modifying sequential task relationships
```
--------------------------------------------------------------------------------
/project/project_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A precise tool for removing elements from the project management knowledge graph, enabling project managers to maintain data accuracy and refine their project structure as needs evolve.
2 |
3 | When to use this tool:
4 | - Removing completed or canceled projects or tasks
5 | - Deleting erroneous relationships between project elements
6 | - Clearing outdated observations from project entities
7 | - Restructuring your project organization as the project evolves
8 | - Removing team members who are no longer part of the project
9 | - Correcting relationships between tasks, milestones, and resources
10 | - Cleaning up the knowledge graph during project phase transitions
11 | - Eliminating deprecated risks or issues that are no longer relevant
12 | - Removing preliminary project elements that have been superseded
13 | - Reorganizing your project structure by removing and recreating elements
14 | - Updating status assignments when task or project states change
15 | - Modifying priority levels as project needs shift
16 | - Restructuring sequential relationships between tasks and activities
17 |
18 | Key features:
19 | - Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
20 | - Maintains knowledge graph integrity during deletion operations
21 | - Supports batch deletion of multiple items in a single operation
22 | - Returns clear confirmation of deletion results
23 | - Preserves the overall structure of the project knowledge graph while removing specific elements
24 | - Performs validation to ensure deletion requests are properly formatted
25 | - Handles status and priority relation management
26 | - Supports modification of task sequencing relationships
27 |
28 | Parameters explained:
29 | 1. type: The type of deletion operation to perform
30 | - Accepts: "entities", "relations", or "observations"
31 | - Determines how the data parameter is interpreted
32 | 2. data: The elements to remove from the knowledge graph (structure varies by type):
33 | - For "entities": Array of entity names to delete
34 | * Example: ["Task_A", "Milestone_1"]
35 | - For "relations": Array of relation objects, each containing:
36 | * from: Name of the source entity
37 | * to: Name of the target entity
38 | * relationType: Type of relationship to remove (e.g., "part_of", "has_status", "has_priority", "precedes")
39 | * Example: [{ "from": "Task_A", "to": "Milestone_1", "relationType": "part_of" }]
40 | - For "observations": Array of objects, each containing:
41 | * entityName: Name of the entity to remove observations from
42 | * observations: Array of specific observations to remove
43 | * Example: [{ "entityName": "Project_X", "observations": ["duration:3 months", "budget:10000"] }]
44 |
45 | Deletion behavior by type:
46 | - Entities: Removes the specified entities and all their associated relations from the knowledge graph
47 | - Relations: Removes only the specified relationships, leaving the connected entities intact
48 | - Observations: Removes specific observations from entities while preserving the entities themselves
49 |
50 | Status and Priority Management:
51 | - When deleting status or priority entities, be aware that all has_status or has_priority relations using these entities will be removed
52 | - For changing an entity's status, delete the existing has_status relation before creating a new one
53 | - For changing priority, delete the existing has_priority relation before creating a new one
54 | - Status values (inactive, active, complete) are managed through relations, not direct properties
55 | - Priority values (low, high) are managed through relations, not direct properties
56 |
57 | Sequential Task Management:
58 | - Removing precedes relations will affect task sequencing and dependencies
59 | - When reorganizing project tasks, update all affected precedes relations
60 | - Consider the impact on project timelines when modifying sequential relationships
61 |
62 | Safety considerations:
63 | - Entity deletion is permanent and will also remove all relationships involving those entities
64 | - Consider exporting or backing up your project knowledge graph before performing large-scale deletions
65 | - For sensitive operations, consider removing specific observations rather than entire entities
66 | - When removing key project elements, consider the impact on your overall project structure
67 | - Status changes should be carefully managed to maintain accurate project tracking
68 | - Changes to task sequences may affect dependent project activities
69 |
70 | Return information:
71 | - JSON response indicating success or failure
72 | - For successful operations:
73 | - Success flag set to true
74 | - Confirmation message with count of deleted items
75 | * For entities: "Deleted X entities"
76 | * For relations: "Deleted X relations"
77 | * For observations: "Deleted observations from X entities"
78 | - For failed operations:
79 | - Success flag set to false
80 | - Error message describing the issue
81 |
82 | You should:
83 | - Be specific in your deletion requests to avoid unintended data loss
84 | - Use relations deletion when you want to disconnect entities without removing them
85 | - For observations, provide the exact observations to ensure only the intended content is removed
86 | - When restructuring your project, consider how deletions will affect related elements
87 | - Use deletecontext in conjunction with buildcontext to refine and evolve your project structure
88 | - Regularly review your knowledge graph for elements that may need to be removed or updated
89 | - Consider the cascading effects of entity deletion on your overall project structure
90 | - Delete completed tasks and milestones systematically when closing project phases
91 | - Remove resolved risks and issues to keep your project status current
92 | - When updating entity status, delete the old has_status relation before creating a new one
93 | - When updating entity priority, delete the old has_priority relation before creating a new one
94 | - Maintain logical consistency when modifying sequential task relationships
```
--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A sophisticated tool for retrieving rich, contextual information about qualitative research entities, providing structured insights tailored to different research components.
2 |
3 | When to use this tool:
4 | - Retrieving detailed information about research projects, participants, interviews, and analytical elements
5 | - Exploring thematic analyses and research findings
6 | - Reviewing participant profiles and interview transcripts
7 | - Examining code definitions and their connections to data
8 | - Analyzing emerging themes and their supporting evidence
9 | - Investigating research questions and related findings
10 | - Reviewing analytical memos and their connections to data
11 | - Preparing for coding sessions by establishing contextual understanding
12 | - Exploring relationships between codes, themes, and concepts
13 | - Getting a comprehensive overview of project progress and insights
14 | - Tracking research activities by their current status
15 | - Managing tasks based on their assigned priorities
16 | - Understanding sequential relationships between research processes
17 |
18 | Key features:
19 | - Provides richly formatted, context-aware information about research entities
20 | - Adapts output format based on entity type (project, participant, interview, code, theme, memo, researchQuestion)
21 | - Presents both direct entity information and related research elements
22 | - Shows research design, methodology, and analysis progression
23 | - Tracks entity views within the current research session
24 | - Formats information in a structured, readable markdown format
25 | - Highlights relationships between research elements
26 | - Presents supporting quotes and evidence for themes and codes
27 | - Shows co-occurrence patterns between codes where available
28 | - Includes status information for tracking research progress
29 | - Displays priority assignments for critical research elements
30 | - Visualizes sequential relationships between research processes
31 |
32 | Parameters explained:
33 | 1. entityName: Required - The name of the entity to retrieve context for
34 | - Example: "Health Behavior Study", "Participant_P001", "Interview_20230315"
35 | 2. entityType: Optional - The type of entity being retrieved
36 | - Default: "project"
37 | - Helps the system format the output appropriately
38 | - Common types include: "project", "participant", "interview", "code", "theme", "memo", "researchQuestion", "status", "priority"
39 | 3. sessionId: Optional - The current session identifier
40 | - Typically provided by startsession
41 | - Used for tracking entity views within the session
42 |
43 | Each entity type returns specialized context information:
44 | - Project: Shows project status, description, research design, research questions, data collection stats, recent interviews, analysis progress (themes), and findings
45 | - Participant: Displays demographic information, interview history, observation records, notable quotes, and research memos
46 | - Interview: Shows project affiliation, participant, date, transcript content, applied codes, and notable quotes
47 | - Code: Displays definition, status, creation date, code group affiliations, supporting quotes, sources, associated themes, and code co-occurrence data
48 | - Theme: Shows description, status, creation date, project affiliation, supporting codes, example quotes, and analytical memos
49 | - Memo: Displays topic, date, project affiliation, content, and related entities
50 | - Research Question: Shows the question text, project affiliation, related findings, themes, and supporting quotes
51 | - Status: Shows all entities assigned this status value, organized by entity type
52 | - Priority: Shows all entities assigned this priority value, organized by entity type
53 | - Other Entity Types: Shows observations and relationship information for other entity types
54 |
55 | Status and Priority Information:
56 | - All entity displays include status information when available via has_status relations
57 | - Priority assignments are shown for tasks and other prioritized elements
58 | - Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
59 | - Valid priority values include: high, low
60 |
61 | Sequential Process Relationships:
62 | - Entity displays show preceding and following entities through precedes relations
63 | - Process sequences are visualized to show workflow between research activities
64 | - Research phases and activities display their position in the overall research process
65 |
66 | Return information:
67 | - Formatted markdown text with hierarchical structure
68 | - Sections adapted to the specific entity type
69 | - Related entities shown with their descriptions and connections
70 | - Status and priority information prominently displayed
71 | - Sequential relationships clearly indicated
72 | - Error messages if the entity doesn't exist or can't be retrieved
73 |
74 | You should:
75 | - Specify the exact entity name for accurate retrieval
76 | - Provide the entity type when possible for optimally formatted results
77 | - Start with project entities to get a high-level overview of research
78 | - Use participant context to understand individual perspectives
79 | - Examine interview context to see coding applied to raw data
80 | - Review code context to understand analytical categories
81 | - Explore theme context to see patterns and theoretical constructs
82 | - Use research question context to track progress toward answering key inquiries
83 | - Examine memo context to review analytical insights
84 | - Check status entities to see all research elements at the same stage
85 | - Review priority entities to identify critical research tasks
86 | - Explore sequential relationships to understand research process flow
87 | - After retrieving context, follow up on specific entities of interest
88 | - Use in conjunction with startsession to maintain session tracking
89 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A sophisticated tool for retrieving rich, contextual information about qualitative research entities, providing structured insights tailored to different research components.
2 |
3 | When to use this tool:
4 | - Retrieving detailed information about research projects, participants, interviews, and analytical elements
5 | - Exploring thematic analyses and research findings
6 | - Reviewing participant profiles and interview transcripts
7 | - Examining code definitions and their connections to data
8 | - Analyzing emerging themes and their supporting evidence
9 | - Investigating research questions and related findings
10 | - Reviewing analytical memos and their connections to data
11 | - Preparing for coding sessions by establishing contextual understanding
12 | - Exploring relationships between codes, themes, and concepts
13 | - Getting a comprehensive overview of project progress and insights
14 | - Tracking research activities by their current status
15 | - Managing tasks based on their assigned priorities
16 | - Understanding sequential relationships between research processes
17 |
18 | Key features:
19 | - Provides richly formatted, context-aware information about research entities
20 | - Adapts output format based on entity type (project, participant, interview, code, theme, memo, researchQuestion)
21 | - Presents both direct entity information and related research elements
22 | - Shows research design, methodology, and analysis progression
23 | - Tracks entity views within the current research session
24 | - Formats information in a structured, readable markdown format
25 | - Highlights relationships between research elements
26 | - Presents supporting quotes and evidence for themes and codes
27 | - Shows co-occurrence patterns between codes where available
28 | - Includes status information for tracking research progress
29 | - Displays priority assignments for critical research elements
30 | - Visualizes sequential relationships between research processes
31 |
32 | Parameters explained:
33 | 1. entityName: Required - The name of the entity to retrieve context for
34 | - Example: "Health Behavior Study", "Participant_P001", "Interview_20230315"
35 | 2. entityType: Optional - The type of entity being retrieved
36 | - Default: "project"
37 | - Helps the system format the output appropriately
38 | - Common types include: "project", "participant", "interview", "code", "theme", "memo", "researchQuestion", "status", "priority"
39 | 3. sessionId: Optional - The current session identifier
40 | - Typically provided by startsession
41 | - Used for tracking entity views within the session
42 |
43 | Each entity type returns specialized context information:
44 | - Project: Shows project status, description, research design, research questions, data collection stats, recent interviews, analysis progress (themes), and findings
45 | - Participant: Displays demographic information, interview history, observation records, notable quotes, and research memos
46 | - Interview: Shows project affiliation, participant, date, transcript content, applied codes, and notable quotes
47 | - Code: Displays definition, status, creation date, code group affiliations, supporting quotes, sources, associated themes, and code co-occurrence data
48 | - Theme: Shows description, status, creation date, project affiliation, supporting codes, example quotes, and analytical memos
49 | - Memo: Displays topic, date, project affiliation, content, and related entities
50 | - Research Question: Shows the question text, project affiliation, related findings, themes, and supporting quotes
51 | - Status: Shows all entities assigned this status value, organized by entity type
52 | - Priority: Shows all entities assigned this priority value, organized by entity type
53 | - Other Entity Types: Shows observations and relationship information for other entity types
54 |
55 | Status and Priority Information:
56 | - All entity displays include status information when available via has_status relations
57 | - Priority assignments are shown for tasks and other prioritized elements
58 | - Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
59 | - Valid priority values include: high, low
60 |
61 | Sequential Process Relationships:
62 | - Entity displays show preceding and following entities through precedes relations
63 | - Process sequences are visualized to show workflow between research activities
64 | - Research phases and activities display their position in the overall research process
65 |
66 | Return information:
67 | - Formatted markdown text with hierarchical structure
68 | - Sections adapted to the specific entity type
69 | - Related entities shown with their descriptions and connections
70 | - Status and priority information prominently displayed
71 | - Sequential relationships clearly indicated
72 | - Error messages if the entity doesn't exist or can't be retrieved
73 |
74 | You should:
75 | - Specify the exact entity name for accurate retrieval
76 | - Provide the entity type when possible for optimally formatted results
77 | - Start with project entities to get a high-level overview of research
78 | - Use participant context to understand individual perspectives
79 | - Examine interview context to see coding applied to raw data
80 | - Review code context to understand analytical categories
81 | - Explore theme context to see patterns and theoretical constructs
82 | - Use research question context to track progress toward answering key inquiries
83 | - Examine memo context to review analytical insights
84 | - Check status entities to see all research elements at the same stage
85 | - Review priority entities to identify critical research tasks
86 | - Explore sequential relationships to understand research process flow
87 | - After retrieving context, follow up on specific entities of interest
88 | - Use in conjunction with startsession to maintain session tracking
89 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```
--------------------------------------------------------------------------------
/main/descriptions/project_buildcontext.txt:
--------------------------------------------------------------------------------
```
1 | A versatile tool for constructing and enhancing your project management knowledge graph by adding new project elements, relationships, and observations.
2 |
3 | When to use this tool:
4 | - Creating new project entities (projects, tasks, milestones, team members, etc.)
5 | - Establishing relationships between project elements (e.g., connecting tasks to projects, assigning team members)
6 | - Adding observations, properties, or metadata to existing project entities
7 | - Building the project management structure incrementally as your project evolves
8 | - Organizing and structuring project data within your management framework
9 | - Documenting project status, risks, and decisions
10 | - Tracking project dependencies and assignments
11 | - Creating comprehensive project timelines with connected elements
12 | - Setting status values for project entities
13 | - Assigning priorities to tasks and other entities
14 | - Defining task sequencing and dependencies
15 |
16 | Key features:
17 | - Creates three distinct types of knowledge graph elements: entities, relations, and observations
18 | - Supports various project management entity types (projects, tasks, milestones, team members, etc.)
19 | - Validates entity and relation types against predefined standards for the project domain
20 | - Handles batch creation of multiple entities or relations in a single operation
21 | - Returns confirmation with details of created elements
22 | - Ensures proper data typing and structure for the project management knowledge graph
23 | - Enables comprehensive documentation of project structure and progress
24 | - Supports status and priority assignment through entity-relation model
25 | - Enables sequential task relationships through precedes relation
26 |
27 | Parameters explained:
28 | 1. type: The type of creation operation to perform
29 | - Accepts: "entities", "relations", or "observations"
30 | - Determines how the data parameter is interpreted
31 | 2. data: The content to add to the knowledge graph (structure varies by type):
32 | - For "entities": An array of objects, each containing:
33 | * name: Unique identifier for the entity
34 | * entityType: One of the valid entity types for project management
35 | * observations: Array of strings containing properties or metadata about the entity
36 | * embedding: (Optional) Vector embedding for enhanced semantic search
37 | - For "relations": An array of objects, each containing:
38 | * from: Name of the source entity
39 | * to: Name of the target entity
40 | * relationType: The type of relationship between entities (e.g., "depends_on", "assigned_to", "has_status")
41 | * observations: (Optional) Array of strings with metadata about the relationship
42 | - For "observations": Either a single object or an array of objects:
43 | * Single object format:
44 | * entityName: Name of the entity to add observations to
45 | * observations: Array of strings with new observations to add
46 | * Array format:
47 | * Each object containing:
48 | * entityName: Name of the entity to add observations to
49 | * contents: Array of strings with new observations to add
50 |
51 | Valid entity types:
52 | - project: Overall project container
53 | - task: Individual action items or work packages
54 | - milestone: Key project checkpoints
55 | - teamMember: Project team participants
56 | - risk: Potential project threats or issues
57 | - decision: Documented project decisions
58 | - resource: Project assets or materials
59 | - issue: Problems requiring resolution
60 | - dependency: Inter-element relationships
61 | - meeting: Project-related gatherings
62 | - document: Project files and documentation
63 | - stakeholder: Parties with interest in the project
64 | - status: Entity status (inactive, active, complete)
65 | - priority: Entity priority (low, high)
66 |
67 | Valid relation types:
68 | - part_of: Entity belongs to another entity
69 | - depends_on: Task dependency relationship
70 | - assigned_to: Assignment relationship between tasks and team members
71 | - responsible_for: Ownership of project elements
72 | - created_by: Authorship relationship
73 | - leads_to: Sequential relationship
74 | - blocks: Impediment relationship
75 | - reports_to: Organizational hierarchy
76 | - collaborates_with: Collaborative relationship
77 | - decides_on: Decision-making relationship
78 | - impacts: Effect relationship
79 | - has_status: Links entity to its status (inactive, active, complete)
80 | - has_priority: Links entity to its priority (low, high)
81 | - precedes: Task precedes another task (for sequencing)
82 |
83 | Status Values:
84 | - inactive: Work on the entity has not begun or is paused
85 | - active: Work is actively underway
86 | - complete: Work has been finished
87 |
88 | Priority Values:
89 | - low: Lower priority item
90 | - high: Higher priority item
91 |
92 | Return information:
93 | - JSON response indicating success or failure
94 | - For successful operations:
95 | * Success flag set to true
96 | * Details of created elements in the "created" field (for entities/relations) or info message for observations
97 | - For failed operations:
98 | * Success flag set to false
99 | * Error message describing the issue
100 |
101 | Error handling:
102 | - Returns descriptive error messages for invalid inputs
103 | - Gracefully handles type mismatches and formatting errors
104 | - Rejects operations with invalid types
105 |
106 | You should:
107 | - Use consistent naming conventions for entities to facilitate relationships and retrieval
108 | - Begin by creating projects before more specific project elements
109 | - Add detailed observations to entities to enhance context and searchability
110 | - Create relationships to build a comprehensive network of interconnected project data
111 | - Document project status and progress through has_status relations
112 | - Assign priorities to tasks using has_priority relations
113 | - Use the precedes relation to establish task sequences and dependencies
114 | - Assign specific team members to tasks using relations
115 | - Track project risks with detailed observations
116 | - Document decisions with context and rationale
117 | - Update entity observations regularly to reflect current project information
118 | - Check the operation result to confirm successful creation
```
--------------------------------------------------------------------------------
/project/project_buildcontext.txt:
--------------------------------------------------------------------------------
```
1 | A versatile tool for constructing and enhancing your project management knowledge graph by adding new project elements, relationships, and observations.
2 |
3 | When to use this tool:
4 | - Creating new project entities (projects, tasks, milestones, team members, etc.)
5 | - Establishing relationships between project elements (e.g., connecting tasks to projects, assigning team members)
6 | - Adding observations, properties, or metadata to existing project entities
7 | - Building the project management structure incrementally as your project evolves
8 | - Organizing and structuring project data within your management framework
9 | - Documenting project status, risks, and decisions
10 | - Tracking project dependencies and assignments
11 | - Creating comprehensive project timelines with connected elements
12 | - Setting status values for project entities
13 | - Assigning priorities to tasks and other entities
14 | - Defining task sequencing and dependencies
15 |
16 | Key features:
17 | - Creates three distinct types of knowledge graph elements: entities, relations, and observations
18 | - Supports various project management entity types (projects, tasks, milestones, team members, etc.)
19 | - Validates entity and relation types against predefined standards for the project domain
20 | - Handles batch creation of multiple entities or relations in a single operation
21 | - Returns confirmation with details of created elements
22 | - Ensures proper data typing and structure for the project management knowledge graph
23 | - Enables comprehensive documentation of project structure and progress
24 | - Supports status and priority assignment through entity-relation model
25 | - Enables sequential task relationships through precedes relation
26 |
27 | Parameters explained:
28 | 1. type: The type of creation operation to perform
29 | - Accepts: "entities", "relations", or "observations"
30 | - Determines how the data parameter is interpreted
31 | 2. data: The content to add to the knowledge graph (structure varies by type):
32 | - For "entities": An array of objects, each containing:
33 | * name: Unique identifier for the entity
34 | * entityType: One of the valid entity types for project management
35 | * observations: Array of strings containing properties or metadata about the entity
36 | * embedding: (Optional) Vector embedding for enhanced semantic search
37 | - For "relations": An array of objects, each containing:
38 | * from: Name of the source entity
39 | * to: Name of the target entity
40 | * relationType: The type of relationship between entities (e.g., "depends_on", "assigned_to", "has_status")
41 | * observations: (Optional) Array of strings with metadata about the relationship
42 | - For "observations": Either a single object or an array of objects:
43 | * Single object format:
44 | * entityName: Name of the entity to add observations to
45 | * observations: Array of strings with new observations to add
46 | * Array format:
47 | * Each object containing:
48 | * entityName: Name of the entity to add observations to
49 | * contents: Array of strings with new observations to add
50 |
51 | Valid entity types:
52 | - project: Overall project container
53 | - task: Individual action items or work packages
54 | - milestone: Key project checkpoints
55 | - teamMember: Project team participants
56 | - risk: Potential project threats or issues
57 | - decision: Documented project decisions
58 | - resource: Project assets or materials
59 | - issue: Problems requiring resolution
60 | - dependency: Inter-element relationships
61 | - meeting: Project-related gatherings
62 | - document: Project files and documentation
63 | - stakeholder: Parties with interest in the project
64 | - status: Entity status (inactive, active, complete)
65 | - priority: Entity priority (low, high)
66 |
67 | Valid relation types:
68 | - part_of: Entity belongs to another entity
69 | - depends_on: Task dependency relationship
70 | - assigned_to: Assignment relationship between tasks and team members
71 | - responsible_for: Ownership of project elements
72 | - created_by: Authorship relationship
73 | - leads_to: Sequential relationship
74 | - blocks: Impediment relationship
75 | - reports_to: Organizational hierarchy
76 | - collaborates_with: Collaborative relationship
77 | - decides_on: Decision-making relationship
78 | - impacts: Effect relationship
79 | - has_status: Links entity to its status (inactive, active, complete)
80 | - has_priority: Links entity to its priority (low, high)
81 | - precedes: Task precedes another task (for sequencing)
82 |
83 | Status Values:
84 | - inactive: Work on the entity has not begun or is paused
85 | - active: Work is actively underway
86 | - complete: Work has been finished
87 |
88 | Priority Values:
89 | - low: Lower priority item
90 | - high: Higher priority item
91 |
92 | Return information:
93 | - JSON response indicating success or failure
94 | - For successful operations:
95 | * Success flag set to true
96 | * Details of created elements in the "created" field (for entities/relations) or info message for observations
97 | - For failed operations:
98 | * Success flag set to false
99 | * Error message describing the issue
100 |
101 | Error handling:
102 | - Returns descriptive error messages for invalid inputs
103 | - Gracefully handles type mismatches and formatting errors
104 | - Rejects operations with invalid types
105 |
106 | You should:
107 | - Use consistent naming conventions for entities to facilitate relationships and retrieval
108 | - Begin by creating projects before more specific project elements
109 | - Add detailed observations to entities to enhance context and searchability
110 | - Create relationships to build a comprehensive network of interconnected project data
111 | - Document project status and progress through has_status relations
112 | - Assign priorities to tasks using has_priority relations
113 | - Use the precedes relation to establish task sequences and dependencies
114 | - Assign specific team members to tasks using relations
115 | - Track project risks with detailed observations
116 | - Document decisions with context and rationale
117 | - Update entity observations regularly to reflect current project information
118 | - Check the operation result to confirm successful creation
```
--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A precise tool for removing elements from the quantitative research knowledge graph, enabling researchers to maintain data accuracy and refine their analytical framework.
2 |
3 | When to use this tool:
4 | - Removing incorrect or duplicate research entities
5 | - Deleting erroneous relationships between research elements
6 | - Clearing outdated observations from research entities
7 | - Restructuring your research framework as analysis evolves
8 | - Removing invalid statistical tests or models
9 | - Correcting relationships between variables, datasets, or results
10 | - Cleaning up the knowledge graph during research refinement phases
11 | - Eliminating deprecated hypotheses or findings that are no longer supported
12 | - Removing preliminary analyses that have been superseded by more rigorous methods
13 | - Reorganizing your analytical structure by removing and recreating elements
14 | - Updating status assignments when research activities change state
15 | - Modifying priority assignments as research focus shifts
16 | - Restructuring sequential relationships between research processes
17 |
18 | Key features:
19 | - Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
20 | - Maintains knowledge graph integrity during deletion operations
21 | - Supports batch deletion of multiple items in a single operation
22 | - Returns clear confirmation of deletion results
23 | - Preserves the overall structure of the research knowledge graph while removing specific elements
24 | - Performs validation to ensure deletion requests are properly formatted
25 | - Handles status and priority relation management
26 | - Supports modification of sequential process relationships
27 |
28 | Parameters explained:
29 | 1. type: The type of deletion operation to perform
30 | - Accepts: "entities", "relations", or "observations"
31 | - Determines how the data parameter is interpreted
32 | 2. data: The elements to remove from the knowledge graph (structure varies by type):
33 | - For "entities": Array of entity names to delete
34 | * Example: ["Dataset_2021", "Hypothesis_A", "Model_Linear", "Status_Completed"]
35 | - For "relations": Array of relation objects, each containing:
36 | * from: Name of the source entity
37 | * to: Name of the target entity
38 | * relationType: Type of relationship to remove (e.g., "correlates_with", "has_status", "has_priority", "precedes")
39 | * Example: [{ "from": "Variable_Age", "to": "Variable_Income", "relationType": "correlates_with" }]
40 | - For "observations": Array of objects, each containing:
41 | * entityName: Name of the entity to remove observations from
42 | * observations: Array of specific observations to remove
43 | * Example: [{ "entityName": "Dataset_Main", "observations": ["size:1000", "collection_date:2022-05-15"] }]
44 |
45 | Deletion behavior by type:
46 | - Entities: Removes the specified entities and all their associated relations from the knowledge graph
47 | - Relations: Removes only the specified relationships, leaving the connected entities intact
48 | - Observations: Removes specific observations from entities while preserving the entities themselves
49 |
50 | Status and Priority Management:
51 | - When deleting status or priority entities, be aware of the impact on entities that reference them
52 | - For changing an entity's status, delete the existing has_status relation before creating a new one
53 | - For changing priority, delete the existing has_priority relation before creating a new one
54 | - Status values (active, completed, pending, abandoned) are managed through relations, not direct properties
55 | - Priority values (high, low) are managed through relations, not direct properties
56 |
57 | Sequential Process Management:
58 | - Removing precedes relations affects the logical flow of research processes
59 | - When reorganizing research phases, update all affected precedes relations
60 | - Consider restructuring sequential relationships after deletion to maintain methodological continuity
61 | - Sequential relationships are important for maintaining proper order in multi-step analyses
62 |
63 | Safety considerations:
64 | - Entity deletion is permanent and will also remove all relationships involving those entities
65 | - Consider exporting or backing up your research knowledge graph before performing large-scale deletions
66 | - For sensitive operations, consider removing specific observations rather than entire entities
67 | - When removing statistical tests or results, consider the impact on your overall analysis framework
68 | - Status changes should be carefully managed to maintain accurate research progress tracking
69 | - Changes to sequential relationships may affect dependent research activities
70 |
71 | Return information:
72 | - JSON response indicating success or failure
73 | - For successful operations:
74 | - Success flag set to true
75 | - Confirmation message with count of deleted items
76 | * For entities: "Deleted X entities"
77 | * For relations: "Deleted X relations"
78 | * For observations: "Deleted observations from X entities"
79 | - For failed operations:
80 | - Success flag set to false
81 | - Error message describing the issue
82 |
83 | You should:
84 | - Be specific in your deletion requests to avoid unintended data loss
85 | - Use relations deletion when you want to disconnect entities without removing them
86 | - For observations, provide the exact observations to ensure only the intended content is removed
87 | - When restructuring your analysis, consider how deletions will affect related elements
88 | - Use deletecontext in conjunction with buildcontext to refine and evolve your research framework
89 | - Regularly review your knowledge graph for elements that may need to be removed or updated
90 | - Consider the cascading effects of entity deletion on your overall research structure
91 | - Delete outdated statistical results when new analyses are performed
92 | - Remove incorrect relationships between variables when better understanding is gained
93 | - When updating entity status, delete the old has_status relation before creating a new one
94 | - When updating entity priority, delete the old has_priority relation before creating a new one
95 | - Maintain logical consistency when modifying sequential analysis relationships
```
--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_deletecontext.txt:
--------------------------------------------------------------------------------
```
1 | A precise tool for removing elements from the quantitative research knowledge graph, enabling researchers to maintain data accuracy and refine their analytical framework.
2 |
3 | When to use this tool:
4 | - Removing incorrect or duplicate research entities
5 | - Deleting erroneous relationships between research elements
6 | - Clearing outdated observations from research entities
7 | - Restructuring your research framework as analysis evolves
8 | - Removing invalid statistical tests or models
9 | - Correcting relationships between variables, datasets, or results
10 | - Cleaning up the knowledge graph during research refinement phases
11 | - Eliminating deprecated hypotheses or findings that are no longer supported
12 | - Removing preliminary analyses that have been superseded by more rigorous methods
13 | - Reorganizing your analytical structure by removing and recreating elements
14 | - Updating status assignments when research activities change state
15 | - Modifying priority assignments as research focus shifts
16 | - Restructuring sequential relationships between research processes
17 |
18 | Key features:
19 | - Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
20 | - Maintains knowledge graph integrity during deletion operations
21 | - Supports batch deletion of multiple items in a single operation
22 | - Returns clear confirmation of deletion results
23 | - Preserves the overall structure of the research knowledge graph while removing specific elements
24 | - Performs validation to ensure deletion requests are properly formatted
25 | - Handles status and priority relation management
26 | - Supports modification of sequential process relationships
27 |
28 | Parameters explained:
29 | 1. type: The type of deletion operation to perform
30 | - Accepts: "entities", "relations", or "observations"
31 | - Determines how the data parameter is interpreted
32 | 2. data: The elements to remove from the knowledge graph (structure varies by type):
33 | - For "entities": Array of entity names to delete
34 | * Example: ["Dataset_2021", "Hypothesis_A", "Model_Linear", "Status_Completed"]
35 | - For "relations": Array of relation objects, each containing:
36 | * from: Name of the source entity
37 | * to: Name of the target entity
38 | * relationType: Type of relationship to remove (e.g., "correlates_with", "has_status", "has_priority", "precedes")
39 | * Example: [{ "from": "Variable_Age", "to": "Variable_Income", "relationType": "correlates_with" }]
40 | - For "observations": Array of objects, each containing:
41 | * entityName: Name of the entity to remove observations from
42 | * observations: Array of specific observations to remove
43 | * Example: [{ "entityName": "Dataset_Main", "observations": ["size:1000", "collection_date:2022-05-15"] }]
44 |
45 | Deletion behavior by type:
46 | - Entities: Removes the specified entities and all their associated relations from the knowledge graph
47 | - Relations: Removes only the specified relationships, leaving the connected entities intact
48 | - Observations: Removes specific observations from entities while preserving the entities themselves
49 |
50 | Status and Priority Management:
51 | - When deleting status or priority entities, be aware of the impact on entities that reference them
52 | - For changing an entity's status, delete the existing has_status relation before creating a new one
53 | - For changing priority, delete the existing has_priority relation before creating a new one
54 | - Status values (active, completed, pending, abandoned) are managed through relations, not direct properties
55 | - Priority values (high, low) are managed through relations, not direct properties
56 |
57 | Sequential Process Management:
58 | - Removing precedes relations affects the logical flow of research processes
59 | - When reorganizing research phases, update all affected precedes relations
60 | - Consider restructuring sequential relationships after deletion to maintain methodological continuity
61 | - Sequential relationships are important for maintaining proper order in multi-step analyses
62 |
63 | Safety considerations:
64 | - Entity deletion is permanent and will also remove all relationships involving those entities
65 | - Consider exporting or backing up your research knowledge graph before performing large-scale deletions
66 | - For sensitive operations, consider removing specific observations rather than entire entities
67 | - When removing statistical tests or results, consider the impact on your overall analysis framework
68 | - Status changes should be carefully managed to maintain accurate research progress tracking
69 | - Changes to sequential relationships may affect dependent research activities
70 |
71 | Return information:
72 | - JSON response indicating success or failure
73 | - For successful operations:
74 | - Success flag set to true
75 | - Confirmation message with count of deleted items
76 | * For entities: "Deleted X entities"
77 | * For relations: "Deleted X relations"
78 | * For observations: "Deleted observations from X entities"
79 | - For failed operations:
80 | - Success flag set to false
81 | - Error message describing the issue
82 |
83 | You should:
84 | - Be specific in your deletion requests to avoid unintended data loss
85 | - Use relations deletion when you want to disconnect entities without removing them
86 | - For observations, provide the exact observations to ensure only the intended content is removed
87 | - When restructuring your analysis, consider how deletions will affect related elements
88 | - Use deletecontext in conjunction with buildcontext to refine and evolve your research framework
89 | - Regularly review your knowledge graph for elements that may need to be removed or updated
90 | - Consider the cascading effects of entity deletion on your overall research structure
91 | - Delete outdated statistical results when new analyses are performed
92 | - Remove incorrect relationships between variables when better understanding is gained
93 | - When updating entity status, delete the old has_status relation before creating a new one
94 | - When updating entity priority, delete the old has_priority relation before creating a new one
95 | - Maintain logical consistency when modifying sequential analysis relationships
```
--------------------------------------------------------------------------------
/main/descriptions/student_endsession.txt:
--------------------------------------------------------------------------------
```
1 | A multi-stage tool for documenting study sessions, tracking academic progress, recording concepts learned, updating assignment status, and enriching the student knowledge graph.
2 |
3 | When to use this tool:
4 | Only use this tool when the user explicity requests it or provides explicit approval.
5 |
6 | Key features:
7 | - Provides a structured, multi-stage workflow for session documentation
8 | - Records concepts learned in the knowledge graph
9 | - Updates assignment status using has_status relations (not_started, in_progress, complete)
10 | - Updates assignment priorities using has_priority relations (low, high)
11 | - Establishes sequential relationships between concepts using follows relations
12 | - Creates connections between concepts and courses
13 | - Updates course status metadata
14 | - Creates new concept entities for topics you've studied
15 | - Maintains session continuity with unique session IDs
16 | - Supports revision of previous stages when needed
17 | - Offers a comprehensive assembly stage that consolidates all session information
18 | - Organizes your academic knowledge into a coherent structure
19 |
20 | The endsession tool uses a sequential, multi-stage approach with 6 typical stages:
21 | 1. Summary Stage: Records basic session information
22 | 2. Concepts Learned Stage: Documents specific concepts studied
23 | 3. Assignment Updates Stage: Records status and priority changes to assignments
24 | 4. New Concepts Stage: Defines new concept entities to add
25 | 5. Course Status Stage: Updates the overall course status
26 | 6. Assembly Stage: Consolidates all information and finalizes the session record
27 |
28 | Parameters explained:
29 | 1. sessionId: Required - Unique identifier for the study session
30 | - Obtained from the startsession tool
31 | - Example: "stu_1234567890_abc123"
32 | 2. stage: Required - Current stage of the endsession workflow
33 | - Accepts: "summary", "conceptsLearned", "assignmentUpdates", "newConcepts", "courseStatus", or "assembly"
34 | - Each stage has specific data requirements and processing logic
35 | 3. stageNumber: Required - The sequence number of the current stage
36 | - Starts at 1 and typically progresses through 6 stages
37 | - Used to track progress through the session documentation workflow
38 | 4. totalStages: Required - Total number of stages planned for this workflow
39 | - Typically 6 for the complete workflow
40 | - Provides context for the progress within the overall process
41 | 5. analysis: Optional - Text analysis or observations for the current stage
42 | - Descriptive text explaining the work done in this stage
43 | - Example: "Analyzed progress on studying for the final exam"
44 | 6. stageData: Optional - Stage-specific structured data
45 | - Structure varies by stage type:
46 | * summary: { summary: "Session summary text", duration: "2 hours", course: "CourseName" }
47 | * conceptsLearned: { concepts: ["Concept A", "Concept B", "Concept C"] }
48 | * assignmentUpdates: { updates: [{ name: "Assignment1", status: "complete", priority: "high" }, { name: "Assignment2", status: "in_progress" }] }
49 | * newConcepts: { concepts: [{ name: "NewConcept1", description: "Definition of the concept", follows: "PriorConcept" }] }
50 | * courseStatus: { courseStatus: "in_progress", courseObservation: "Making good progress" }
51 | * assembly: No stageData needed - automatically assembled from previous stages
52 | 7. nextStageNeeded: Required - Whether additional stages are needed after this one
53 | - Boolean value (true/false)
54 | - Set to false on the final stage to complete the session
55 | 8. isRevision: Optional - Whether this is revising a previous stage
56 | - Boolean value (true/false)
57 | - Default: false
58 | 9. revisesStage: Optional - If revising, which stage number is being revised
59 | - Required when isRevision is true
60 | - Indicates which previous stage is being updated
61 |
62 | When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool performs these updates:
63 | 1. Concept Entities: Creates entities for each concept learned and links them to the course
64 | 2. Assignment Status Updates: Updates assignment status via has_status relations (not_started, in_progress, complete)
65 | 3. Assignment Priority Updates: Updates assignment priority via has_priority relations (low, high)
66 | 4. Sequential Concept Relationships: Establishes follows relations between concepts when specified
67 | 5. Course Status Update: Updates the course status via has_status relation, adds an updated timestamp, and records observations
68 | 6. New Concept Creation: Creates new concept entities, links them to the course, and establishes any sequential relationships
69 | 7. Session Recording: Marks the session as completed in persistent storage
70 |
71 | Return information:
72 | - JSON response with the following structure:
73 | * success: Boolean indicating whether the operation succeeded
74 | * stageCompleted: The stage that was just completed
75 | * nextStageNeeded: Whether more stages are required
76 | * stageResult: The processed result of the current stage
77 | * endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
78 | * sessionRecorded: (Final stage only) Whether the session was recorded
79 | * summaryMessage: (Final stage only) Formatted summary of all recorded information
80 | * error: (Only on failure) Error message describing the issue
81 | - Error information when operation fails
82 |
83 | Status and Priority Values:
84 | - Valid status values: not_started, in_progress, complete
85 | - Valid priority values: low, high
86 |
87 | You should:
88 | - Complete all stages in order for comprehensive session documentation
89 | - Provide specific details in each stage for accurate knowledge graph updates
90 | - Be precise about assignment names to ensure they match existing assignments
91 | - Use valid status values (not_started, in_progress, complete) when updating assignments
92 | - Use valid priority values (low, high) when specifying assignment importance
93 | - Specify sequential relationships between concepts when appropriate
94 | - Use clear, descriptive names for any new concepts
95 | - Include relevant observations for course status updates
96 | - If making a revision, specify which stage is being revised
97 | - Only mark nextStageNeeded as false on the final assembly stage
98 | - Review the final summary message to confirm all session details were recorded properly
99 | - Use the unique session ID consistently across all stages
```
--------------------------------------------------------------------------------
/student/student_endsession.txt:
--------------------------------------------------------------------------------
```
1 | A multi-stage tool for documenting study sessions, tracking academic progress, recording concepts learned, updating assignment status, and enriching the student knowledge graph.
2 |
3 | When to use this tool:
4 | Only use this tool when the user explicity requests it or provides explicit approval.
5 |
6 | Key features:
7 | - Provides a structured, multi-stage workflow for session documentation
8 | - Records concepts learned in the knowledge graph
9 | - Updates assignment status using has_status relations (not_started, in_progress, complete)
10 | - Updates assignment priorities using has_priority relations (low, high)
11 | - Establishes sequential relationships between concepts using follows relations
12 | - Creates connections between concepts and courses
13 | - Updates course status metadata
14 | - Creates new concept entities for topics you've studied
15 | - Maintains session continuity with unique session IDs
16 | - Supports revision of previous stages when needed
17 | - Offers a comprehensive assembly stage that consolidates all session information
18 | - Organizes your academic knowledge into a coherent structure
19 |
20 | The endsession tool uses a sequential, multi-stage approach with 6 typical stages:
21 | 1. Summary Stage: Records basic session information
22 | 2. Concepts Learned Stage: Documents specific concepts studied
23 | 3. Assignment Updates Stage: Records status and priority changes to assignments
24 | 4. New Concepts Stage: Defines new concept entities to add
25 | 5. Course Status Stage: Updates the overall course status
26 | 6. Assembly Stage: Consolidates all information and finalizes the session record
27 |
28 | Parameters explained:
29 | 1. sessionId: Required - Unique identifier for the study session
30 | - Obtained from the startsession tool
31 | - Example: "stu_1234567890_abc123"
32 | 2. stage: Required - Current stage of the endsession workflow
33 | - Accepts: "summary", "conceptsLearned", "assignmentUpdates", "newConcepts", "courseStatus", or "assembly"
34 | - Each stage has specific data requirements and processing logic
35 | 3. stageNumber: Required - The sequence number of the current stage
36 | - Starts at 1 and typically progresses through 6 stages
37 | - Used to track progress through the session documentation workflow
38 | 4. totalStages: Required - Total number of stages planned for this workflow
39 | - Typically 6 for the complete workflow
40 | - Provides context for the progress within the overall process
41 | 5. analysis: Optional - Text analysis or observations for the current stage
42 | - Descriptive text explaining the work done in this stage
43 | - Example: "Analyzed progress on studying for the final exam"
44 | 6. stageData: Optional - Stage-specific structured data
45 | - Structure varies by stage type:
46 | * summary: { summary: "Session summary text", duration: "2 hours", course: "CourseName" }
47 | * conceptsLearned: { concepts: ["Concept A", "Concept B", "Concept C"] }
48 | * assignmentUpdates: { updates: [{ name: "Assignment1", status: "complete", priority: "high" }, { name: "Assignment2", status: "in_progress" }] }
49 | * newConcepts: { concepts: [{ name: "NewConcept1", description: "Definition of the concept", follows: "PriorConcept" }] }
50 | * courseStatus: { courseStatus: "in_progress", courseObservation: "Making good progress" }
51 | * assembly: No stageData needed - automatically assembled from previous stages
52 | 7. nextStageNeeded: Required - Whether additional stages are needed after this one
53 | - Boolean value (true/false)
54 | - Set to false on the final stage to complete the session
55 | 8. isRevision: Optional - Whether this is revising a previous stage
56 | - Boolean value (true/false)
57 | - Default: false
58 | 9. revisesStage: Optional - If revising, which stage number is being revised
59 | - Required when isRevision is true
60 | - Indicates which previous stage is being updated
61 |
62 | When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool performs these updates:
63 | 1. Concept Entities: Creates entities for each concept learned and links them to the course
64 | 2. Assignment Status Updates: Updates assignment status via has_status relations (not_started, in_progress, complete)
65 | 3. Assignment Priority Updates: Updates assignment priority via has_priority relations (low, high)
66 | 4. Sequential Concept Relationships: Establishes follows relations between concepts when specified
67 | 5. Course Status Update: Updates the course status via has_status relation, adds an updated timestamp, and records observations
68 | 6. New Concept Creation: Creates new concept entities, links them to the course, and establishes any sequential relationships
69 | 7. Session Recording: Marks the session as completed in persistent storage
70 |
71 | Return information:
72 | - JSON response with the following structure:
73 | * success: Boolean indicating whether the operation succeeded
74 | * stageCompleted: The stage that was just completed
75 | * nextStageNeeded: Whether more stages are required
76 | * stageResult: The processed result of the current stage
77 | * endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
78 | * sessionRecorded: (Final stage only) Whether the session was recorded
79 | * summaryMessage: (Final stage only) Formatted summary of all recorded information
80 | * error: (Only on failure) Error message describing the issue
81 | - Error information when operation fails
82 |
83 | Status and Priority Values:
84 | - Valid status values: not_started, in_progress, complete
85 | - Valid priority values: low, high
86 |
87 | You should:
88 | - Complete all stages in order for comprehensive session documentation
89 | - Provide specific details in each stage for accurate knowledge graph updates
90 | - Be precise about assignment names to ensure they match existing assignments
91 | - Use valid status values (not_started, in_progress, complete) when updating assignments
92 | - Use valid priority values (low, high) when specifying assignment importance
93 | - Specify sequential relationships between concepts when appropriate
94 | - Use clear, descriptive names for any new concepts
95 | - Include relevant observations for course status updates
96 | - If making a revision, specify which stage is being revised
97 | - Only mark nextStageNeeded as false on the final assembly stage
98 | - Review the final summary message to confirm all session details were recorded properly
99 | - Use the unique session ID consistently across all stages
```
--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_buildcontext.txt:
--------------------------------------------------------------------------------
```
1 | A versatile tool for constructing and enhancing the qualitative research knowledge graph by adding new research elements, relationships, and observations.
2 |
3 | When to use this tool:
4 | - Creating new research entities (projects, participants, interviews, observations, codes, themes, memos, etc.)
5 | - Establishing relationships between research elements (e.g., connecting participants to projects, codes to data segments)
6 | - Adding observations, notes, or content to existing research entities
7 | - Building the research corpus incrementally as data collection and analysis progress
8 | - Organizing and structuring qualitative data within your research framework
9 | - Documenting emerging themes, codes, and analytical insights during research
10 | - Creating research questions and linking them to findings
11 | - Building code hierarchies and thematic frameworks
12 | - Setting status values for research activities and entities
13 | - Assigning priorities to research tasks and activities
14 | - Defining sequential relationships between research processes
15 |
16 | Key features:
17 | - Creates three distinct types of knowledge graph elements: entities, relations, and observations
18 | - Supports specialized qualitative research entity types (projects, participants, interviews, observations, documents, codes, etc.)
19 | - Validates entity and relation types against predefined standards for the qualitative research domain
20 | - Handles batch creation of multiple entities or relations in a single operation
21 | - Returns confirmation with details of created elements
22 | - Ensures proper data typing and structure for the qualitative research knowledge graph
23 | - Enables comprehensive documentation of the research process
24 | - Supports status and priority assignment through entity-relation model
25 | - Enables sequential relationships through precedes relation
26 |
27 | Parameters explained:
28 | 1. type: The type of creation operation to perform
29 | - Accepts: "entities", "relations", or "observations"
30 | - Determines how the data parameter is interpreted
31 | 2. data: The content to add to the knowledge graph (structure varies by type):
32 | - For "entities": An array of objects, each containing:
33 | * name: Unique identifier for the entity
34 | * entityType: One of the valid entity types (project, participant, interview, observation, document, code, codeGroup, memo, theme, quote, literature, researchQuestion, finding, status, priority)
35 | * observations: Array of strings containing notes or properties about the entity
36 | - For "relations": An array of objects, each containing:
37 | * from: Name of the source entity
38 | * to: Name of the target entity
39 | * relationType: The type of relationship between entities (e.g., "participated_in", "codes", "has_status", "has_priority")
40 | - For "observations": Either a single object or an array of objects, each containing:
41 | * entityName: Name of the entity to add observations to
42 | * contents: Array of strings with new observations to add
43 |
44 | Valid entity types:
45 | - project: Overall research study
46 | - participant: Research subjects
47 | - interview: Formal conversation with participants
48 | - observation: Field notes from observational research
49 | - document: External materials being analyzed
50 | - code: Labels applied to data segments
51 | - codeGroup: Categories or families of related codes
52 | - memo: Researcher's analytical notes
53 | - theme: Emergent patterns across data
54 | - quote: Notable excerpts from data sources
55 | - literature: Academic sources
56 | - researchQuestion: Formal questions guiding the study
57 | - finding: Results or conclusions
58 | - status: Entity status values
59 | - priority: Entity priority values
60 |
61 | Valid relation types:
62 | - participated_in: Links participants to interviews/observations
63 | - codes: Shows which codes apply to which data
64 | - contains: Hierarchical relationship
65 | - supports: Data supporting a theme or finding
66 | - contradicts: Data contradicting a theme or finding
67 | - answers: Data addressing a research question
68 | - cites: References to literature
69 | - followed_by: Temporal sequence
70 | - related_to: General connection
71 | - reflects_on: Memo reflecting on data/code/theme
72 | - compares: Comparative relationship
73 | - has_status: Links entity to its status
74 | - has_priority: Links entity to its priority
75 | - precedes: Entity comes before another entity in sequence
76 |
77 | Status information:
78 | - Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
79 | - Status is assigned through the has_status relation type
80 |
81 | Priority information:
82 | - Valid priority values: high, low
83 | - Priority is assigned through the has_priority relation type
84 |
85 | Return information:
86 | - JSON response indicating success or failure
87 | - For successful operations:
88 | * Success flag set to true
89 | * Details of created elements in the "created" field (for entities/relations) or "added" field (for observations)
90 | - For failed operations:
91 | * Success flag set to false
92 | * Error message describing the issue
93 |
94 | Error handling:
95 | - Validates entity types against the predefined list for qualitative research
96 | - Validates relation types against acceptable standards
97 | - Returns descriptive error messages for invalid inputs
98 | - Gracefully handles type mismatches and formatting errors
99 |
100 | You should:
101 | - Use consistent naming conventions for entities to facilitate relationships and retrieval
102 | - Begin by creating projects and participants before more specific research elements
103 | - Add detailed observations to entities to enhance context and retrievability
104 | - Create relationships to build a comprehensive network of interconnected research data
105 | - Use has_status relations to track the progress of research activities
106 | - Use has_priority relations to indicate important research elements
107 | - Use the precedes relation to establish sequences in research processes
108 | - Use observations to document the evolution of codes, themes, and analytical thinking
109 | - Regularly update entity observations as your understanding evolves
110 | - Build hierarchical structures using relations (e.g., codes within code groups, themes connecting multiple codes)
111 | - Document the full research journey by adding memos tied to specific analytical moments
112 | - Link quotes to codes, themes, and findings to maintain evidential chains
```
--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_buildcontext.txt:
--------------------------------------------------------------------------------
```
1 | A versatile tool for constructing and enhancing the qualitative research knowledge graph by adding new research elements, relationships, and observations.
2 |
3 | When to use this tool:
4 | - Creating new research entities (projects, participants, interviews, observations, codes, themes, memos, etc.)
5 | - Establishing relationships between research elements (e.g., connecting participants to projects, codes to data segments)
6 | - Adding observations, notes, or content to existing research entities
7 | - Building the research corpus incrementally as data collection and analysis progress
8 | - Organizing and structuring qualitative data within your research framework
9 | - Documenting emerging themes, codes, and analytical insights during research
10 | - Creating research questions and linking them to findings
11 | - Building code hierarchies and thematic frameworks
12 | - Setting status values for research activities and entities
13 | - Assigning priorities to research tasks and activities
14 | - Defining sequential relationships between research processes
15 |
16 | Key features:
17 | - Creates three distinct types of knowledge graph elements: entities, relations, and observations
18 | - Supports specialized qualitative research entity types (projects, participants, interviews, observations, documents, codes, etc.)
19 | - Validates entity and relation types against predefined standards for the qualitative research domain
20 | - Handles batch creation of multiple entities or relations in a single operation
21 | - Returns confirmation with details of created elements
22 | - Ensures proper data typing and structure for the qualitative research knowledge graph
23 | - Enables comprehensive documentation of the research process
24 | - Supports status and priority assignment through entity-relation model
25 | - Enables sequential relationships through precedes relation
26 |
27 | Parameters explained:
28 | 1. type: The type of creation operation to perform
29 | - Accepts: "entities", "relations", or "observations"
30 | - Determines how the data parameter is interpreted
31 | 2. data: The content to add to the knowledge graph (structure varies by type):
32 | - For "entities": An array of objects, each containing:
33 | * name: Unique identifier for the entity
34 | * entityType: One of the valid entity types (project, participant, interview, observation, document, code, codeGroup, memo, theme, quote, literature, researchQuestion, finding, status, priority)
35 | * observations: Array of strings containing notes or properties about the entity
36 | - For "relations": An array of objects, each containing:
37 | * from: Name of the source entity
38 | * to: Name of the target entity
39 | * relationType: The type of relationship between entities (e.g., "participated_in", "codes", "has_status", "has_priority")
40 | - For "observations": Either a single object or an array of objects, each containing:
41 | * entityName: Name of the entity to add observations to
42 | * contents: Array of strings with new observations to add
43 |
44 | Valid entity types:
45 | - project: Overall research study
46 | - participant: Research subjects
47 | - interview: Formal conversation with participants
48 | - observation: Field notes from observational research
49 | - document: External materials being analyzed
50 | - code: Labels applied to data segments
51 | - codeGroup: Categories or families of related codes
52 | - memo: Researcher's analytical notes
53 | - theme: Emergent patterns across data
54 | - quote: Notable excerpts from data sources
55 | - literature: Academic sources
56 | - researchQuestion: Formal questions guiding the study
57 | - finding: Results or conclusions
58 | - status: Entity status values
59 | - priority: Entity priority values
60 |
61 | Valid relation types:
62 | - participated_in: Links participants to interviews/observations
63 | - codes: Shows which codes apply to which data
64 | - contains: Hierarchical relationship
65 | - supports: Data supporting a theme or finding
66 | - contradicts: Data contradicting a theme or finding
67 | - answers: Data addressing a research question
68 | - cites: References to literature
69 | - followed_by: Temporal sequence
70 | - related_to: General connection
71 | - reflects_on: Memo reflecting on data/code/theme
72 | - compares: Comparative relationship
73 | - has_status: Links entity to its status
74 | - has_priority: Links entity to its priority
75 | - precedes: Entity comes before another entity in sequence
76 |
77 | Status information:
78 | - Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
79 | - Status is assigned through the has_status relation type
80 |
81 | Priority information:
82 | - Valid priority values: high, low
83 | - Priority is assigned through the has_priority relation type
84 |
85 | Return information:
86 | - JSON response indicating success or failure
87 | - For successful operations:
88 | * Success flag set to true
89 | * Details of created elements in the "created" field (for entities/relations) or "added" field (for observations)
90 | - For failed operations:
91 | * Success flag set to false
92 | * Error message describing the issue
93 |
94 | Error handling:
95 | - Validates entity types against the predefined list for qualitative research
96 | - Validates relation types against acceptable standards
97 | - Returns descriptive error messages for invalid inputs
98 | - Gracefully handles type mismatches and formatting errors
99 |
100 | You should:
101 | - Use consistent naming conventions for entities to facilitate relationships and retrieval
102 | - Begin by creating projects and participants before more specific research elements
103 | - Add detailed observations to entities to enhance context and retrievability
104 | - Create relationships to build a comprehensive network of interconnected research data
105 | - Use has_status relations to track the progress of research activities
106 | - Use has_priority relations to indicate important research elements
107 | - Use the precedes relation to establish sequences in research processes
108 | - Use observations to document the evolution of codes, themes, and analytical thinking
109 | - Regularly update entity observations as your understanding evolves
110 | - Build hierarchical structures using relations (e.g., codes within code groups, themes connecting multiple codes)
111 | - Document the full research journey by adding memos tied to specific analytical moments
112 | - Link quotes to codes, themes, and findings to maintain evidential chains
```
--------------------------------------------------------------------------------
/main/descriptions/common_loadcontext.txt:
--------------------------------------------------------------------------------
```
1 | A powerful tool for retrieving rich, contextual information about domain-specific entities, providing formatted details tailored to each entity type.
2 |
3 | When to use this tool:
4 | - Retrieving detailed information about domain-specific entities
5 | - Exploring relationships between connected entities
6 | - Examining status information and progress metrics
7 | - Understanding the structure and elements of complex entities
8 | - Reviewing progress, completion, and deadline information
9 | - Examining entity details, dependencies, and assignments
10 | - Preparing for work on a specific entity by establishing context
11 | - Analyzing knowledge graph connections to understand entity relationships
12 | - Getting a holistic view of status, progress, and upcoming work
13 | - Establishing context for effective planning and decision-making
14 |
15 | Key features:
16 | - Provides contextually rich, formatted information about domain-specific entities
17 | - Adapts output format based on entity type
18 | - Presents both direct entity information and related elements
19 | - Organizes information in a clear, hierarchical structure
20 | - Automatically identifies entity relationships and presents them systematically
21 | - Tracks loaded entities within the current session for continuity
22 | - Presents information in readable markdown format
23 |
24 | Parameters explained:
25 | 1. entityName: Required - The name of the entity to retrieve context for
26 | 2. entityType: Optional - The type of entity being retrieved (varies by domain)
27 | - Developer: project, component, task, issue, milestone, decision, feature, technology, documentation, dependency, developer
28 | - Student: course, assignment, exam, concept, term, resource, note, lecture, project, question, goal, professor
29 | - Qualitative Research: project, participant, interview, code, theme, memo, researchQuestion, observation, document, codeGroup, quote, literature, finding
30 | - Quantitative Research: project, dataset, variable, model, hypothesis, statisticalTest, result, analysisScript, visualization, literature, researchQuestion, finding, participant
31 | - Project Management: project, task, milestone, teamMember, resource, risk, decision, issue, dependency, meeting, document, stakeholder
32 | 3. sessionId: Optional - The current session identifier provided by startsession
33 |
34 | Domain-specific information returned:
35 | - Developer:
36 | * Project: Status, components, active features, active tasks, active issues, upcoming milestones, team members, and recent decisions
37 | * Component: Parent projects, implemented features, technologies used, active issues, documentation, team members, and dependencies
38 | * Feature: Status, priority, description, requirements, implementing components, and related tasks
39 | * Task: Project, status, priority, due date, description, assigned developers, related issues, and blocking items
40 | * Milestone: Status, deadline, description, progress percentage, deadline status, and tasks grouped by completion status
41 | * Other Entity Types: Observations and relationships within the knowledge graph
42 |
43 | - Student:
44 | * Course: Code, status, schedule, location, description, professor information, lectures, assignments, exams, key concepts, and resources
45 | * Assignment: Course, status, due date, points, time remaining, instructions, related concepts, helpful resources, and notes
46 | * Exam: Course, date, time remaining, location, format, duration, concepts to study, key lectures, and study resources
47 | * Concept: Difficulty level, description, related concepts, courses covering this concept, and learning resources
48 | * Term: Start date, end date, status, courses for the term, and upcoming deadlines
49 | * Other Entity Types: Observations and relationships within the knowledge graph
50 |
51 | - Qualitative Research:
52 | * Project: Status, description, research design, research questions, data collection stats, recent interviews, analysis progress (themes), and findings
53 | * Participant: Demographic information, interview history, observation records, notable quotes, and research memos
54 | * Interview: Project affiliation, participant, date, transcript content, applied codes, and notable quotes
55 | * Code: Definition, status, creation date, code group affiliations, supporting quotes, sources, associated themes, and code co-occurrence data
56 | * Theme: Description, status, creation date, project affiliation, supporting codes, example quotes, and analytical memos
57 | * Memo: Topic, date, project affiliation, content, and related entities
58 | * Research Question: Question text, project affiliation, related findings, themes, and supporting quotes
59 | * Other Entity Types: Observations and relationships within the knowledge graph
60 |
61 | - Quantitative Research:
62 | * Project: Status, description, datasets, hypotheses, statistical tests, models, and key visualizations
63 | * Dataset: Project affiliation, size, variable count, descriptive statistics, visualizations, and models trained on it
64 | * Variable: Data type, role, scale, descriptive statistics, normality tests, and correlations with other variables
65 | * Model: Type, training dataset, creation date, performance metrics, and model parameters
66 | * Hypothesis: Status, p-value, creation date, associated tests, and project affiliation
67 | * Statistical Test: Test type, result, p-value, date, variables analyzed, and hypotheses tested
68 | * Other Entity Types: Basic information and observations
69 |
70 | - Project Management:
71 | * Project: Status, description, timeline, budget, goal, tasks, milestones, issues, team members, risks, and task completion rate
72 | * Task: Project affiliation, status, due date, priority, assignee, description, critical path status, and task dependencies
73 | * Milestone: Project affiliation, status, date, completion criteria, description, progress percentage, days remaining, required tasks, and blocking tasks
74 | * Team Member: Role, skills, availability, workload, assigned tasks, projects, upcoming deadlines, and overdue tasks
75 | * Resource: Type, project affiliation, availability, capacity, cost, usage percentage, assigned tasks, and team members using the resource
76 | * Other Entity Types: Basic entity information, observations, incoming relations, and outgoing relations
77 |
78 | Return information:
79 | - Formatted markdown text with hierarchical structure
80 | - Sections adapted to the specific entity type within each domain
81 | - Related entities shown with their relationships and status information
82 | - Progress metrics and completion statistics where applicable
83 | - Error messages if the entity doesn't exist or can't be retrieved
84 |
85 | You should:
86 | - Specify the exact entity name for accurate retrieval
87 | - Provide the entity type when possible for optimally formatted results
88 | - Start with high-level entities (projects, courses) to get a broad overview
89 | - Explore specific entities to understand details and relationships
90 | - After retrieving context, follow up on specific entities of interest
91 | - Use in conjunction with startsession to maintain session tracking
92 | - Remember that this tool only retrieves existing information; use buildcontext to add new entities
```