This is page 2 of 9. Use http://codebase.md/tejpalvirk/contextmanager?lines=false&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

--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_startsession.txt:
--------------------------------------------------------------------------------

```
A comprehensive tool for initializing a new quantitative research session, providing structured information about ongoing research projects, datasets, statistical models, and recent research activities.

When to use this tool:
- Beginning a new quantitative analysis session
- Getting oriented to your current research state across multiple projects
- Planning which research elements to focus on in the current session
- Reviewing recent research activities and progress
- Identifying active research projects and their status
- Exploring available datasets for analysis
- Reviewing current research questions
- Examining statistical models and their performance
- Viewing recent visualizations of your data
- Establishing research context before diving into specific analysis tasks
- Re-engaging with your research after time away
- Prioritizing high-priority research tasks
- Tracking the status of various research activities
- Understanding sequential research processes

Key features:
- Generates a unique session identifier for tracking research activities
- Retrieves and displays recent research sessions with summaries
- Lists active research projects with status information
- Provides a sample of available datasets with key information
- Presents current research questions guiding your studies
- Highlights recent statistical models with performance metrics
- Displays recent visualizations with brief descriptions
- Formats information in an easily scannable format for quick orientation
- Integrates with the loadcontext tool for deeper exploration
- Maintains continuity between research sessions
- Tracks research session history for progress review
- Displays high-priority research tasks needing attention
- Shows status information for key research activities
- Presents sequential relationships between research processes

Parameters explained:
No parameters required - the tool automatically retrieves all relevant context.

Return information:
- Recent research sessions (up to 3) with:
  - Date
  - Project name
  - Brief summary
  
- Active research projects with:
  - Project name
  - Current status (via has_status relation)
  - Priority (if assigned via has_priority relation)
  
- Available datasets (up to 5) with:
  - Dataset name
  - Type of data
  - Associated project
  - Status (active, completed, pending, abandoned)
  
- Research questions (up to 5) with:
  - Question text
  - Associated project
  - Status (via has_status relation)
  
- Recent statistical models with:
  - Model name
  - Model type
  - Performance metrics
  - Status (via has_status relation)
  
- Recent visualizations with:
  - Visualization name
  - Type (chart, plot, etc.)
  - Associated dataset

- High-priority research tasks (up to 5) with:
  - Task name
  - Current status (active, completed, pending, abandoned)
  - Associated project

- Upcoming research activities (up to 3) with:
  - Activity name
  - Prerequisite activities (via precedes relation)
  - Current status (via has_status relation)

Status and Priority Information:
- Research activities are displayed with their current status values
- High-priority tasks are prominently highlighted for attention
- Valid status values include: active, completed, pending, abandoned
- Priority values (high, low) help indicate which tasks need immediate attention
- Status is retrieved through has_status relations
- Priority is retrieved through has_priority relations

Sequential Process Information:
- Upcoming activities show prerequisite tasks that must be completed first
- Research phases are presented in their logical sequence
- The precedes relation is used to determine activity ordering
- Sequential relationships help visualize the research workflow

Session Workflow:
1. Start a research session with startsession
2. Review the provided context to decide what to focus on
3. Use loadcontext to retrieve detailed information about specific research elements
4. Conduct your analysis, adding new elements with buildcontext as needed
5. End the session with endsession to record your research progress

You should:
- Begin each focused research period with startsession to establish context
- Review recent sessions to maintain continuity in your research
- Identify active projects that require attention
- Note available datasets for potential analysis
- Consider current research questions that need investigation
- Review existing statistical models before creating new ones
- Examine recent visualizations to understand data representation
- Prioritize high-priority tasks for immediate attention
- Check the status of research activities to maintain progress awareness
- Consider sequential relationships when planning your research activities
- Use the session ID when using other tools to maintain session tracking
- After completing a session, record your progress using endsession
- Establish a regular cadence of research sessions to maintain momentum
- Use the structured overview to make deliberate choices about where to focus your analytical effort 
```

--------------------------------------------------------------------------------
/main/descriptions/student_loadcontext.txt:
--------------------------------------------------------------------------------

```
A powerful tool for retrieving comprehensive, structured information about specific educational entities, providing context-rich details tailored to academic needs.

When to use this tool:
- Retrieving detailed information about courses, assignments, exams, and academic concepts
- Exploring course materials, lecture schedules, and assignment deadlines
- Preparing for upcoming exams by identifying key concepts and resources
- Tracking assignment status and due dates
- Understanding relationships between academic concepts
- Examining course structures and learning resources
- Planning study sessions around specific courses or topics
- Reviewing term schedules and upcoming deadlines
- Organizing academic resources by courses and concepts
- Establishing context for effective learning and study planning
- Viewing entity status information (not_started, in_progress, complete)
- Checking priority levels for assignments and tasks
- Understanding sequential relationships between academic entities

Key features:
- Provides richly formatted, context-aware information about educational entities
- Adapts output format based on entity type (course, assignment, exam, concept, term)
- Presents both direct entity information and related academic elements
- Shows time-sensitive information like due dates and exam schedules
- Tracks loaded entities within the current session for continuity
- Formats information in a clean, readable markdown structure
- Automatically identifies relationships between academic entities
- Displays status information via has_status relations
- Shows priority levels via has_priority relations
- Presents sequential relationships through follows relations
- Highlights status of assignments and upcoming deadlines
- Shows progress metrics for courses and assignment completion

Parameters explained:
1. entityName: Required - The name of the entity to retrieve context for
  - Example: "Introduction to Computer Science", "Midterm Paper", "Binary Trees"
2. entityType: Optional - The type of entity being retrieved
  - Default: "course"
  - Accepts values from valid entity types for the student domain
  - Helps the system format the output appropriately
3. sessionId: Optional - The current session identifier
  - Typically provided by startsession
  - Used for tracking entity views within the session

Each entity type returns specialized context information:
- Course: Shows code, status (via has_status), schedule, location, description, professor information, lectures, assignments (with status and priority), exams, key concepts, and resources
- 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
- Exam: Shows course, date, time remaining, location, format, duration, concepts to study, key lectures, and study resources
- Concept: Displays difficulty level, description, related concepts (including sequential relationships), courses covering this concept, and learning resources
- Term: Shows start date, end date, status, courses for the term (with completion percentages), and upcoming deadlines
- Other Entity Types: Shows observations and both incoming and outgoing relationships within the knowledge graph

Status and Priority:
- All entities include status values (not_started, in_progress, complete) retrieved via has_status relations
- Relevant entities include priority values (low, high) retrieved via has_priority relations
- Status information is used to calculate completion percentages and filter assignments
- Priority information helps identify important tasks and assignments

Sequential Relationships:
- Related entities may have follows relationships indicating recommended sequence
- Course view shows sequenced lectures and assignments
- Concept view shows prerequisite relationships between concepts

Return information:
- Formatted markdown text with hierarchical structure
- Sections adapted to the specific entity type
- Related entities shown with their status, priority, and descriptions
- Error messages if the entity doesn't exist or can't be retrieved

You should:
- Specify the exact entity name for accurate retrieval
- Provide the entity type when possible for optimally formatted results
- Start with course entities to get a high-level overview of academic materials
- Use assignment context to track deadlines and submission status
- Prepare for exams by examining exam context for study resources
- Explore concept context to understand relationships between academic topics
- Review term context to plan your academic schedule
- Pay attention to status values to identify incomplete assignments
- Consider priority information when planning your study schedule
- Follow sequential relationships to create effective learning paths
- After retrieving context, follow up on specific entities of interest
- Use in conjunction with startsession to maintain session tracking
- Combine with endsession to document your learning progress
- Remember that this tool only retrieves existing information; use buildcontext to add new entities 
```

--------------------------------------------------------------------------------
/student/student_loadcontext.txt:
--------------------------------------------------------------------------------

```
A powerful tool for retrieving comprehensive, structured information about specific educational entities, providing context-rich details tailored to academic needs.

When to use this tool:
- Retrieving detailed information about courses, assignments, exams, and academic concepts
- Exploring course materials, lecture schedules, and assignment deadlines
- Preparing for upcoming exams by identifying key concepts and resources
- Tracking assignment status and due dates
- Understanding relationships between academic concepts
- Examining course structures and learning resources
- Planning study sessions around specific courses or topics
- Reviewing term schedules and upcoming deadlines
- Organizing academic resources by courses and concepts
- Establishing context for effective learning and study planning
- Viewing entity status information (not_started, in_progress, complete)
- Checking priority levels for assignments and tasks
- Understanding sequential relationships between academic entities

Key features:
- Provides richly formatted, context-aware information about educational entities
- Adapts output format based on entity type (course, assignment, exam, concept, term)
- Presents both direct entity information and related academic elements
- Shows time-sensitive information like due dates and exam schedules
- Tracks loaded entities within the current session for continuity
- Formats information in a clean, readable markdown structure
- Automatically identifies relationships between academic entities
- Displays status information via has_status relations
- Shows priority levels via has_priority relations
- Presents sequential relationships through follows relations
- Highlights status of assignments and upcoming deadlines
- Shows progress metrics for courses and assignment completion

Parameters explained:
1. entityName: Required - The name of the entity to retrieve context for
  - Example: "Introduction to Computer Science", "Midterm Paper", "Binary Trees"
2. entityType: Optional - The type of entity being retrieved
  - Default: "course"
  - Accepts values from valid entity types for the student domain
  - Helps the system format the output appropriately
3. sessionId: Optional - The current session identifier
  - Typically provided by startsession
  - Used for tracking entity views within the session

Each entity type returns specialized context information:
- Course: Shows code, status (via has_status), schedule, location, description, professor information, lectures, assignments (with status and priority), exams, key concepts, and resources
- 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
- Exam: Shows course, date, time remaining, location, format, duration, concepts to study, key lectures, and study resources
- Concept: Displays difficulty level, description, related concepts (including sequential relationships), courses covering this concept, and learning resources
- Term: Shows start date, end date, status, courses for the term (with completion percentages), and upcoming deadlines
- Other Entity Types: Shows observations and both incoming and outgoing relationships within the knowledge graph

Status and Priority:
- All entities include status values (not_started, in_progress, complete) retrieved via has_status relations
- Relevant entities include priority values (low, high) retrieved via has_priority relations
- Status information is used to calculate completion percentages and filter assignments
- Priority information helps identify important tasks and assignments

Sequential Relationships:
- Related entities may have follows relationships indicating recommended sequence
- Course view shows sequenced lectures and assignments
- Concept view shows prerequisite relationships between concepts

Return information:
- Formatted markdown text with hierarchical structure
- Sections adapted to the specific entity type
- Related entities shown with their status, priority, and descriptions
- Error messages if the entity doesn't exist or can't be retrieved

You should:
- Specify the exact entity name for accurate retrieval
- Provide the entity type when possible for optimally formatted results
- Start with course entities to get a high-level overview of academic materials
- Use assignment context to track deadlines and submission status
- Prepare for exams by examining exam context for study resources
- Explore concept context to understand relationships between academic topics
- Review term context to plan your academic schedule
- Pay attention to status values to identify incomplete assignments
- Consider priority information when planning your study schedule
- Follow sequential relationships to create effective learning paths
- After retrieving context, follow up on specific entities of interest
- Use in conjunction with startsession to maintain session tracking
- Combine with endsession to document your learning progress
- Remember that this tool only retrieves existing information; use buildcontext to add new entities 
```

--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_deletecontext.txt:
--------------------------------------------------------------------------------

```
A precise tool for removing elements from the qualitative research knowledge graph, enabling researchers to maintain data accuracy and refine their analytical framework.

When to use this tool:
- Removing incorrect or duplicate research entities
- Deleting erroneous relationships between research elements
- Clearing outdated observations from research entities
- Restructuring your research framework as analysis evolves
- Removing pilot or test data that shouldn't be included in final analysis
- Cleaning up the knowledge graph during research refinement phases
- Eliminating deprecated codes, themes, or concepts that no longer fit your analytical framework
- Removing sensitive information that should not be retained
- Reorganizing your analytical structure by removing and recreating elements
- Updating status assignments when research activities change state
- Modifying priority assignments as research focus shifts
- Restructuring sequential relationships between research processes

Key features:
- Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
- Maintains knowledge graph integrity during deletion operations
- Supports batch deletion of multiple items in a single operation
- Returns clear confirmation of deletion results
- Preserves the overall structure of the research knowledge graph while removing specific elements
- Performs validation to ensure deletion requests are properly formatted
- Handles status and priority relation management
- Supports modification of sequential process relationships

Parameters explained:
1. type: The type of deletion operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted 
2. data: The elements to remove from the knowledge graph (structure varies by type):
  - For "entities": Array of entity names to delete
    * Example: ["Participant_A", "Interview_3"]
  - For "relations": Array of relation objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: Type of relationship to remove (e.g., "participated_in", "codes", "has_status", "has_priority", "precedes")
  - For "observations": Array of objects, each containing:
    * entityName: Name of the entity to remove observations from
    * indices: Array of numeric indices identifying which observations to remove

Deletion behavior by type:
- Entities: Removes the specified entities and all their associated relations from the knowledge graph
- Relations: Removes only the specified relationships, leaving the connected entities intact
- Observations: Removes specific observations from entities while preserving the entities themselves

Status and Priority Management:
- When deleting status or priority entities, be aware of the impact on entities that reference them
- For changing an entity's status or priority, first delete the existing has_status or has_priority relation, then create a new one
- Consider the research workflow implications when removing status entities or relations
- Deletion of a status entity will remove all has_status relations pointing to it

Sequential Process Management:
- Removing precedes relations affects the logical flow of research processes
- Consider restructuring sequential relationships after deletion to maintain process continuity
- When reorganizing research phases, update all affected precedes relations

Safety considerations:
- Entity deletion is permanent and will also remove all relationships involving those entities
- Consider exporting or backing up your research knowledge graph before performing large-scale deletions
- For sensitive operations, consider removing specific observations rather than entire entities
- When removing codes or themes, consider the impact on your analytical framework
- Status changes should be carefully managed to maintain accurate research progress tracking
- Changes to sequential relationships may affect dependent research activities

Return information:
- JSON response indicating success or failure
- For successful operations:
  * Success flag set to true
  * Confirmation message
- For failed operations:
  * Success flag set to false
  * Error message describing the issue

You should:
- Be specific in your deletion requests to avoid unintended data loss
- Use relations deletion when you want to disconnect entities without removing them
- For observations, provide the exact indices to ensure only the intended content is removed
- When restructuring your analysis, consider how deletions will affect related elements
- Use deletecontext in conjunction with buildcontext to refine and evolve your research framework
- Regularly review your knowledge graph for elements that may need to be removed or updated
- Consider the cascading effects of entity deletion on your overall research structure
- Use observation deletion for minor corrections rather than removing entire entities
- When updating entity status, delete the old has_status relation before creating a new one
- Maintain logical consistency when modifying sequential process relationships 
```

--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_deletecontext.txt:
--------------------------------------------------------------------------------

```
A precise tool for removing elements from the qualitative research knowledge graph, enabling researchers to maintain data accuracy and refine their analytical framework.

When to use this tool:
- Removing incorrect or duplicate research entities
- Deleting erroneous relationships between research elements
- Clearing outdated observations from research entities
- Restructuring your research framework as analysis evolves
- Removing pilot or test data that shouldn't be included in final analysis
- Cleaning up the knowledge graph during research refinement phases
- Eliminating deprecated codes, themes, or concepts that no longer fit your analytical framework
- Removing sensitive information that should not be retained
- Reorganizing your analytical structure by removing and recreating elements
- Updating status assignments when research activities change state
- Modifying priority assignments as research focus shifts
- Restructuring sequential relationships between research processes

Key features:
- Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
- Maintains knowledge graph integrity during deletion operations
- Supports batch deletion of multiple items in a single operation
- Returns clear confirmation of deletion results
- Preserves the overall structure of the research knowledge graph while removing specific elements
- Performs validation to ensure deletion requests are properly formatted
- Handles status and priority relation management
- Supports modification of sequential process relationships

Parameters explained:
1. type: The type of deletion operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted 
2. data: The elements to remove from the knowledge graph (structure varies by type):
  - For "entities": Array of entity names to delete
    * Example: ["Participant_A", "Interview_3"]
  - For "relations": Array of relation objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: Type of relationship to remove (e.g., "participated_in", "codes", "has_status", "has_priority", "precedes")
  - For "observations": Array of objects, each containing:
    * entityName: Name of the entity to remove observations from
    * indices: Array of numeric indices identifying which observations to remove

Deletion behavior by type:
- Entities: Removes the specified entities and all their associated relations from the knowledge graph
- Relations: Removes only the specified relationships, leaving the connected entities intact
- Observations: Removes specific observations from entities while preserving the entities themselves

Status and Priority Management:
- When deleting status or priority entities, be aware of the impact on entities that reference them
- For changing an entity's status or priority, first delete the existing has_status or has_priority relation, then create a new one
- Consider the research workflow implications when removing status entities or relations
- Deletion of a status entity will remove all has_status relations pointing to it

Sequential Process Management:
- Removing precedes relations affects the logical flow of research processes
- Consider restructuring sequential relationships after deletion to maintain process continuity
- When reorganizing research phases, update all affected precedes relations

Safety considerations:
- Entity deletion is permanent and will also remove all relationships involving those entities
- Consider exporting or backing up your research knowledge graph before performing large-scale deletions
- For sensitive operations, consider removing specific observations rather than entire entities
- When removing codes or themes, consider the impact on your analytical framework
- Status changes should be carefully managed to maintain accurate research progress tracking
- Changes to sequential relationships may affect dependent research activities

Return information:
- JSON response indicating success or failure
- For successful operations:
  * Success flag set to true
  * Confirmation message
- For failed operations:
  * Success flag set to false
  * Error message describing the issue

You should:
- Be specific in your deletion requests to avoid unintended data loss
- Use relations deletion when you want to disconnect entities without removing them
- For observations, provide the exact indices to ensure only the intended content is removed
- When restructuring your analysis, consider how deletions will affect related elements
- Use deletecontext in conjunction with buildcontext to refine and evolve your research framework
- Regularly review your knowledge graph for elements that may need to be removed or updated
- Consider the cascading effects of entity deletion on your overall research structure
- Use observation deletion for minor corrections rather than removing entire entities
- When updating entity status, delete the old has_status relation before creating a new one
- Maintain logical consistency when modifying sequential process relationships 
```

--------------------------------------------------------------------------------
/main/descriptions/project_loadcontext.txt:
--------------------------------------------------------------------------------

```
A powerful tool for retrieving detailed contextual information about project entities, providing rich insights tailored to each entity type in the project management domain.

When to use this tool:
- Retrieving comprehensive information about projects, tasks, milestones, and team members
- Exploring task dependencies and critical path information
- Examining milestone progress and completion status
- Reviewing team member assignments and workload
- Analyzing resource allocation and availability
- Inspecting project risks and issues
- Preparing for project status updates and planning meetings
- Examining project timelines and progress metrics
- Getting a holistic view of project status and health
- Understanding relationships between project entities
- Viewing entity status information (inactive, active, complete)
- Checking priority levels for tasks and activities
- Understanding sequential relationships between tasks

Key features:
- Provides richly formatted, context-aware information about project management entities
- Adapts output format based on entity type (project, task, milestone, teamMember, resource)
- Presents both direct entity information and related elements
- Shows project metrics, task completion rates, and milestone progress
- Tracks entity views within the current project session
- Formats information in a structured, readable markdown format
- Highlights relationships between tasks, milestones, and team members
- Presents critical path information for task dependencies
- Shows resource utilization metrics and availability
- Displays status information via has_status relations
- Shows priority levels via has_priority relations
- Presents sequential relationships through precedes relations

Parameters explained:
1. entityName: Required - The name of the entity to retrieve context for
  - Example: "Marketing Campaign Q4", "Design Homepage", "Website Launch"
2. entityType: Optional - The type of entity being retrieved
  - Default: "project"
  - Helps the system format the output appropriately
  - Common types include: "project", "task", "milestone", "teamMember", "resource", "status", "priority"
3. sessionId: Optional - The current session identifier
  - Typically provided by startsession
  - Used for tracking entity views within the session

Each entity type returns specialized context information:
- Project: Shows project status (via has_status), description, timeline, budget, goal, tasks, milestones, issues, team members, risks, and task completion rate
- 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)
- Milestone: Shows project affiliation, status (via has_status), date, completion criteria, description, progress percentage, days remaining, required tasks, and blocking tasks
- Team Member: Displays role, skills, availability, workload, assigned tasks, projects, upcoming deadlines, and overdue tasks
- Resource: Shows type, project affiliation, availability, capacity, cost, usage percentage, assigned tasks, and team members using the resource
- Status: Shows all entities assigned this status value, organized by entity type
- Priority: Shows all entities assigned this priority value, organized by entity type
- Other Entity Types: Shows basic entity information, observations, incoming relations, and outgoing relations

Status and Priority Information:
- All entity displays include status information when available via has_status relations
- Tasks and other prioritized elements show priority assignments via has_priority relations
- Valid status values include: inactive, active, complete
- Valid priority values include: high, low

Sequential Task Relationships:
- Task displays show preceding and following tasks through precedes relations
- Sequential relationships are visualized to show workflow between tasks
- Tasks display their position in the overall project workflow
- Critical path information highlights essential task sequences

Return information:
- Formatted markdown text with hierarchical structure
- Sections adapted to the specific entity type
- Related entities shown with their relationships
- Progress metrics and completion statistics where applicable
- Status and priority information prominently displayed
- Sequential relationships clearly indicated
- Error messages if the entity doesn't exist or can't be retrieved

You should:
- Specify the exact entity name for accurate retrieval
- Provide the entity type when possible for optimally formatted results
- Start with project entities to get a high-level overview
- Examine task context to understand dependencies and critical path
- Review milestone context to assess progress towards key deliverables
- Use team member context to evaluate workload and assignments
- Explore resource context to understand allocation and availability
- Check status entities to see all project elements at the same stage
- Review priority entities to identify critical project tasks
- Explore sequential relationships to understand task workflows
- After retrieving context, follow up on specific entities of interest
- Use in conjunction with startsession to maintain session tracking
- Remember that this tool only retrieves existing information; use buildcontext to add new entities 
```

--------------------------------------------------------------------------------
/project/project_loadcontext.txt:
--------------------------------------------------------------------------------

```
A powerful tool for retrieving detailed contextual information about project entities, providing rich insights tailored to each entity type in the project management domain.

When to use this tool:
- Retrieving comprehensive information about projects, tasks, milestones, and team members
- Exploring task dependencies and critical path information
- Examining milestone progress and completion status
- Reviewing team member assignments and workload
- Analyzing resource allocation and availability
- Inspecting project risks and issues
- Preparing for project status updates and planning meetings
- Examining project timelines and progress metrics
- Getting a holistic view of project status and health
- Understanding relationships between project entities
- Viewing entity status information (inactive, active, complete)
- Checking priority levels for tasks and activities
- Understanding sequential relationships between tasks

Key features:
- Provides richly formatted, context-aware information about project management entities
- Adapts output format based on entity type (project, task, milestone, teamMember, resource)
- Presents both direct entity information and related elements
- Shows project metrics, task completion rates, and milestone progress
- Tracks entity views within the current project session
- Formats information in a structured, readable markdown format
- Highlights relationships between tasks, milestones, and team members
- Presents critical path information for task dependencies
- Shows resource utilization metrics and availability
- Displays status information via has_status relations
- Shows priority levels via has_priority relations
- Presents sequential relationships through precedes relations

Parameters explained:
1. entityName: Required - The name of the entity to retrieve context for
  - Example: "Marketing Campaign Q4", "Design Homepage", "Website Launch"
2. entityType: Optional - The type of entity being retrieved
  - Default: "project"
  - Helps the system format the output appropriately
  - Common types include: "project", "task", "milestone", "teamMember", "resource", "status", "priority"
3. sessionId: Optional - The current session identifier
  - Typically provided by startsession
  - Used for tracking entity views within the session

Each entity type returns specialized context information:
- Project: Shows project status (via has_status), description, timeline, budget, goal, tasks, milestones, issues, team members, risks, and task completion rate
- 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)
- Milestone: Shows project affiliation, status (via has_status), date, completion criteria, description, progress percentage, days remaining, required tasks, and blocking tasks
- Team Member: Displays role, skills, availability, workload, assigned tasks, projects, upcoming deadlines, and overdue tasks
- Resource: Shows type, project affiliation, availability, capacity, cost, usage percentage, assigned tasks, and team members using the resource
- Status: Shows all entities assigned this status value, organized by entity type
- Priority: Shows all entities assigned this priority value, organized by entity type
- Other Entity Types: Shows basic entity information, observations, incoming relations, and outgoing relations

Status and Priority Information:
- All entity displays include status information when available via has_status relations
- Tasks and other prioritized elements show priority assignments via has_priority relations
- Valid status values include: inactive, active, complete
- Valid priority values include: high, low

Sequential Task Relationships:
- Task displays show preceding and following tasks through precedes relations
- Sequential relationships are visualized to show workflow between tasks
- Tasks display their position in the overall project workflow
- Critical path information highlights essential task sequences

Return information:
- Formatted markdown text with hierarchical structure
- Sections adapted to the specific entity type
- Related entities shown with their relationships
- Progress metrics and completion statistics where applicable
- Status and priority information prominently displayed
- Sequential relationships clearly indicated
- Error messages if the entity doesn't exist or can't be retrieved

You should:
- Specify the exact entity name for accurate retrieval
- Provide the entity type when possible for optimally formatted results
- Start with project entities to get a high-level overview
- Examine task context to understand dependencies and critical path
- Review milestone context to assess progress towards key deliverables
- Use team member context to evaluate workload and assignments
- Explore resource context to understand allocation and availability
- Check status entities to see all project elements at the same stage
- Review priority entities to identify critical project tasks
- Explore sequential relationships to understand task workflows
- After retrieving context, follow up on specific entities of interest
- Use in conjunction with startsession to maintain session tracking
- Remember that this tool only retrieves existing information; use buildcontext to add new entities 
```

--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_loadcontext.txt:
--------------------------------------------------------------------------------

```
A powerful tool for retrieving detailed contextual information about quantitative research entities, providing rich statistical insights tailored to each entity type.

When to use this tool:
- Retrieving comprehensive information about research projects, datasets, variables, and statistical elements
- Exploring the statistical relationships between variables
- Examining hypothesis tests and their results
- Reviewing model performance metrics and parameters
- Analyzing dataset properties and descriptive statistics
- Inspecting visualizations related to specific datasets or projects
- Understanding statistical test results and their significance
- Preparing for statistical analysis by establishing data context
- Examining variable distributions and correlations
- Getting a holistic view of quantitative research progress
- Tracking research activities by their current status
- Managing tasks based on their assigned priorities
- Understanding sequential relationships between research processes

Key features:
- Provides richly formatted, context-aware information about quantitative research entities
- Adapts output format based on entity type (project, dataset, variable, model, hypothesis, statistical_test)
- Presents both direct entity information and related statistical elements
- Shows statistical metrics, p-values, and significance levels
- Tracks entity views within the current research session
- Formats information in a structured, readable markdown format
- Highlights relationships between variables and statistical tests
- Presents performance metrics for statistical models
- Shows dataset characteristics and variable properties
- Includes status information for tracking research progress
- Displays priority assignments for critical research elements
- Visualizes sequential relationships between research processes

Parameters explained:
1. entityName: Required - The name of the entity to retrieve context for
  - Example: "Customer Satisfaction Study", "Survey_Dataset", "Age_Variable"
2. entityType: Optional - The type of entity being retrieved
  - Default: "project"
  - Helps the system format the output appropriately
  - Common types include: "project", "dataset", "variable", "model", "hypothesis", "statistical_test", "status", "priority"
3. sessionId: Optional - The current session identifier
  - Typically provided by startsession
  - Used for tracking entity views within the session

Each entity type returns specialized context information:
- Project: Shows project status (via has_status), description, datasets, hypotheses, statistical tests, models, key visualizations, and priority (via has_priority)
- Dataset: Displays project affiliation, status (via has_status), size, variable count, descriptive statistics, visualizations, and models trained on it
- Variable: Shows data type, role, scale, descriptive statistics, normality tests, and correlations with other variables
- Model: Displays type, training dataset, creation date, status (via has_status), performance metrics, and model parameters
- Hypothesis: Shows status (via has_status), p-value, creation date, associated tests, and project affiliation
- Statistical Test: Shows test type, result, p-value, date, variables analyzed, and hypotheses tested
- Status: Shows all entities assigned this status value, organized by entity type
- Priority: Shows all entities assigned this priority value, organized by entity type
- Other Entity Types: Shows basic entity information and observations

Status and Priority Information:
- All entity displays include status information when available via has_status relations
- Priority assignments are shown for research tasks and other prioritized elements
- Valid status values include: active, completed, pending, abandoned
- Valid priority values include: high, low

Sequential Process Relationships:
- Entity displays show preceding and following entities through precedes relations
- Process sequences are visualized to show workflow between research activities
- Research phases and activities display their position in the overall analytical pipeline
- Sequential relationships help understand dependencies in multi-step analysis processes

Return information:
- Formatted markdown text with hierarchical structure
- Sections adapted to the specific entity type
- Related entities shown with their statistical properties
- Status and priority information prominently displayed
- Sequential relationships clearly indicated
- Error messages if the entity doesn't exist or can't be retrieved

You should:
- Specify the exact entity name for accurate retrieval
- Provide the entity type when possible for optimally formatted results
- Start with project entities to get a high-level overview of research
- Examine dataset context to understand variable relationships
- Review variable context to understand distributions and correlations
- Use hypothesis context to assess research question outcomes
- Explore model context to evaluate predictive performance
- Examine statistical test context to understand analysis results
- Check status entities to see all research elements at the same stage
- Review priority entities to identify critical research tasks
- Explore sequential relationships to understand analysis workflows
- After retrieving context, follow up on specific entities of interest
- Use in conjunction with startsession to maintain session tracking
- Remember that this tool only retrieves existing information; use buildcontext to add new entities 
```

--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_loadcontext.txt:
--------------------------------------------------------------------------------

```
A powerful tool for retrieving detailed contextual information about quantitative research entities, providing rich statistical insights tailored to each entity type.

When to use this tool:
- Retrieving comprehensive information about research projects, datasets, variables, and statistical elements
- Exploring the statistical relationships between variables
- Examining hypothesis tests and their results
- Reviewing model performance metrics and parameters
- Analyzing dataset properties and descriptive statistics
- Inspecting visualizations related to specific datasets or projects
- Understanding statistical test results and their significance
- Preparing for statistical analysis by establishing data context
- Examining variable distributions and correlations
- Getting a holistic view of quantitative research progress
- Tracking research activities by their current status
- Managing tasks based on their assigned priorities
- Understanding sequential relationships between research processes

Key features:
- Provides richly formatted, context-aware information about quantitative research entities
- Adapts output format based on entity type (project, dataset, variable, model, hypothesis, statistical_test)
- Presents both direct entity information and related statistical elements
- Shows statistical metrics, p-values, and significance levels
- Tracks entity views within the current research session
- Formats information in a structured, readable markdown format
- Highlights relationships between variables and statistical tests
- Presents performance metrics for statistical models
- Shows dataset characteristics and variable properties
- Includes status information for tracking research progress
- Displays priority assignments for critical research elements
- Visualizes sequential relationships between research processes

Parameters explained:
1. entityName: Required - The name of the entity to retrieve context for
  - Example: "Customer Satisfaction Study", "Survey_Dataset", "Age_Variable"
2. entityType: Optional - The type of entity being retrieved
  - Default: "project"
  - Helps the system format the output appropriately
  - Common types include: "project", "dataset", "variable", "model", "hypothesis", "statistical_test", "status", "priority"
3. sessionId: Optional - The current session identifier
  - Typically provided by startsession
  - Used for tracking entity views within the session

Each entity type returns specialized context information:
- Project: Shows project status (via has_status), description, datasets, hypotheses, statistical tests, models, key visualizations, and priority (via has_priority)
- Dataset: Displays project affiliation, status (via has_status), size, variable count, descriptive statistics, visualizations, and models trained on it
- Variable: Shows data type, role, scale, descriptive statistics, normality tests, and correlations with other variables
- Model: Displays type, training dataset, creation date, status (via has_status), performance metrics, and model parameters
- Hypothesis: Shows status (via has_status), p-value, creation date, associated tests, and project affiliation
- Statistical Test: Shows test type, result, p-value, date, variables analyzed, and hypotheses tested
- Status: Shows all entities assigned this status value, organized by entity type
- Priority: Shows all entities assigned this priority value, organized by entity type
- Other Entity Types: Shows basic entity information and observations

Status and Priority Information:
- All entity displays include status information when available via has_status relations
- Priority assignments are shown for research tasks and other prioritized elements
- Valid status values include: active, completed, pending, abandoned
- Valid priority values include: high, low

Sequential Process Relationships:
- Entity displays show preceding and following entities through precedes relations
- Process sequences are visualized to show workflow between research activities
- Research phases and activities display their position in the overall analytical pipeline
- Sequential relationships help understand dependencies in multi-step analysis processes

Return information:
- Formatted markdown text with hierarchical structure
- Sections adapted to the specific entity type
- Related entities shown with their statistical properties
- Status and priority information prominently displayed
- Sequential relationships clearly indicated
- Error messages if the entity doesn't exist or can't be retrieved

You should:
- Specify the exact entity name for accurate retrieval
- Provide the entity type when possible for optimally formatted results
- Start with project entities to get a high-level overview of research
- Examine dataset context to understand variable relationships
- Review variable context to understand distributions and correlations
- Use hypothesis context to assess research question outcomes
- Explore model context to evaluate predictive performance
- Examine statistical test context to understand analysis results
- Check status entities to see all research elements at the same stage
- Review priority entities to identify critical research tasks
- Explore sequential relationships to understand analysis workflows
- After retrieving context, follow up on specific entities of interest
- Use in conjunction with startsession to maintain session tracking
- Remember that this tool only retrieves existing information; use buildcontext to add new entities 
```

--------------------------------------------------------------------------------
/main/descriptions/common_advancedcontext.txt:
--------------------------------------------------------------------------------

```
Advanced Context Tool

A sophisticated tool for advanced querying and analysis of domain-specific knowledge graphs.
This tool provides specialized operations to extract meaningful insights and contextual information from the graph structure.
It enables deep exploration of entities, relationships, and contextual information relevant to each domain.

When to use this tool:
- Retrieving the complete knowledge graph structure
- Searching for specific entities using keyword or partial matching
- Fetching details on a precise set of entities
- Exploring all relationships for a specific entity
- Examining domain-specific data structures and hierarchies
- Tracking progress on domain-specific elements
- Investigating dependencies and connections between entities
- Analyzing the evolution of projects, courses, or research
- Understanding the context surrounding specific entities
- Creating reports or summaries from your knowledge graph

Key features:
- Multiple specialized query operation types tailored to each domain
- Full graph retrieval with entities and relations
- Keyword-based search across entities and their properties
- Direct entity lookup by exact name
- Relationship exploration with filtering options
- Domain-specific operations for specialized analysis
- JSON-formatted response with query results
- Detailed error reporting when operations fail

Parameters explained:
- type: The query operation type to perform, which must be one of the domain-specific operation types:
  * Common operations across domains:
    - "graph" - Retrieve the entire knowledge graph (all entities and relations)
    - "search" - Find entities by keyword/partial match in name, type, or observations
    - "nodes" - Get specific entities by exact name
    - "related" - Get all entities related to a specific entity
  * Developer-specific operations:
    - "decisions" - Get the decision history for a project
    - "milestone" - Get progress tracking for a specific milestone
  * Student-specific operations:
    - "course" - Get comprehensive details about a specific course
    - "deadlines" - Get upcoming assignment and exam deadlines
    - "assignment" - Get detailed status of a specific assignment
    - "exam" - Get preparation materials for a specific exam
    - "concepts" - Find related concepts based on a starting concept
    - "lecture" - Track and organize notes for lectures
    - "term" - Get overview of an academic term
  * Qualitative Research-specific operations:
    - "project" - Get comprehensive project information
    - "participant" - Get participant profile with demographic information
    - "codes" - Get coding information filtered by project
    - "themes" - Get theme information with associated codes
    - "transcript" - Get interview transcript content
    - "memo" - Get memo content with metadata
    - "analysis" - Get analysis artifacts for a project
    - "codebook" - Generate a structured codebook for a project
  * Quantitative Research-specific operations:
    - "project" - Get comprehensive project information
    - "dataset" - Get dataset analysis with variables and statistics
    - "hypothesis" - Get hypothesis tests and results
    - "variables" - Get variable relationships and dependencies
    - "statistics" - Get statistical test results
    - "visualizations" - Get visualization metadata
    - "model" - Get model performance metrics
    - "question" - Get research question details
    - "distribution" - Get variable distribution analysis
  * Project Management-specific operations:
    - "project" - Get comprehensive project information
    - "dependencies" - Map task dependencies and critical paths
    - "assignments" - Get team member assignments and workload
    - "milestones" - Track milestone progress and completion
    - "timeline" - Generate project timeline with dependencies
    - "resources" - Analyze resource allocation
    - "risks" - Identify and prioritize project risks
    - "decisions" - Get decision log for governance
    - "health" - Assess project health with KPIs

- params: Operation-specific parameters structure (varies by type):
  * For common operations:
    - "graph": No parameters needed
    - "search": { query: "search text" }
    - "nodes": { names: ["EntityName1", "EntityName2", ...] }
    - "related": { entityName: "EntityName", relationTypes: ["type1", "type2", ...] }
  * For domain-specific operations: Refer to domain documentation for parameter details

Operation details:
- "graph" returns the complete knowledge graph structure for the active domain
- "search" performs partial matching on entity names, types, and observations
- "nodes" retrieves specific entities by exact name matching
- "related" finds all incoming and outgoing relationships for an entity
- Domain-specific operations provide specialized views and analytics tailored to that domain

Return structures:
- All operations return { success: true/false, ... } with operation-specific data
- Error responses include detailed error messages
- Domain-specific operations return structured data relevant to the operation type

You should:
1. Select the most appropriate query type for your information need
2. Provide the required parameters for your chosen operation type
3. Start with broader queries and refine to more specific ones
4. Use "search" for exploratory investigation when entity names are unknown
5. Use "related" to explore the neighborhood of a known entity
6. Use domain-specific operations for specialized analysis
7. Combine query results to build comprehensive understanding 
```

--------------------------------------------------------------------------------
/main/descriptions/student_advancedcontext.txt:
--------------------------------------------------------------------------------

```
A comprehensive tool for querying and analyzing your educational knowledge graph.
This tool provides specialized operations to extract meaningful insights and contextual information about your academic journey.
It enables deep exploration of courses, assignments, exams, concepts, and educational resources.

When to use this tool:
- Retrieving the complete educational knowledge graph
- Searching for specific academic entities using keyword matching
- Fetching details on a precise set of educational entities
- Getting comprehensive information about a specific course
- Finding upcoming assignment and exam deadlines
- Checking detailed status of a specific assignment
- Preparing for exams with concept retrieval
- Discovering connections between learning concepts
- Tracking and reviewing lecture notes
- Getting an overview of an entire academic term
- Identifying entities by status (not_started, in_progress, complete)
- Finding high-priority assignments and tasks
- Exploring sequential relationships between entities

Key features:
- Ten specialized query operation types
- Full educational graph retrieval with entities and relations
- Keyword-based search across academic entities and their properties
- Direct entity lookup by exact name
- Course details including lectures, assignments, exams, and resources
- Deadline tracking with time-based filtering
- Assignment status with progress tracking through has_status relations
- Priority information via has_priority relations
- Exam preparation with related concepts and materials
- Concept relationship mapping
- Sequential entity relationships via follows relations
- Lecture note organization
- Term-based academic overview
- JSON-formatted response with query results

Parameters explained:
- type: The query operation type to perform, which must be one of:
  * "graph" - Retrieve the entire educational knowledge graph
  * "search" - Find academic entities by keyword/partial match
  * "nodes" - Get specific educational entities by exact name
  * "course" - Get comprehensive details about a specific course
  * "deadlines" - Get upcoming assignment and exam deadlines
  * "assignment" - Get detailed status of a specific assignment
  * "exam" - Get preparation materials for a specific exam
  * "concepts" - Find related concepts based on a starting concept
  * "lecture" - Track and organize notes for lectures
  * "term" - Get overview of an academic term
- params: Operation-specific parameters structure:
  * For "graph": No parameters needed
  * For "search": { query: "search text" }
  * For "nodes": { names: ["EntityName1", "EntityName2", ...] }
  * For "course": { courseName: "Course Name" }
  * For "deadlines": { termName: "Term Name", courseName: "Course Name", daysAhead: 14 }
  * For "assignment": { assignmentName: "Assignment Name" }
  * For "exam": { examName: "Exam Name" }
  * For "concepts": { conceptName: "Concept Name", depth: 1 }
  * For "lecture": { courseName: "Course Name" }
  * For "term": { termName: "Term Name" }

Operation details:
- "graph" returns the complete educational knowledge graph structure
- "search" performs partial matching on entity names, types, and observations
- "nodes" retrieves specific entities by exact name matching
- "course" provides a comprehensive view of a course with its components
- "deadlines" finds upcoming assignments and exams with due dates
- "assignment" shows detailed status and related concepts for an assignment
- "exam" provides study resources and related concepts for exam preparation
- "concepts" maps relationships between different learning concepts
- "lecture" organizes and retrieves notes for course lectures
- "term" gives an overview of courses and work for an academic term

Status information:
- All entities include status information (not_started, in_progress, complete) via has_status relations
- Status can be used in search queries (e.g., "status:complete")
- Course views show assignment completion status
- Term views highlight course completion percentages based on status

Priority information:
- Entities can have priority values (low, high) via has_priority relations
- Priority can be used in search queries (e.g., "priority:high")
- High-priority items are highlighted in course and term views

Sequential relationships:
- Entities can have sequence relationships through follows relations
- Course views show recommended sequence of assignments and lectures
- Concept views show prerequisite relationships

Return structures:
- All operations return { success: true/false, ... } with operation-specific data
- Error responses include detailed error messages
- Complex operations return rich, structured data about academic entities
- Educational relationships are preserved in all returned data
- Status and priority information is included in relevant entity data

You should:
1. Select the most appropriate query type for your educational information need
2. Provide the required parameters for your chosen operation type
3. Start with broader queries and refine to more specific ones
4. Use "search" for exploratory investigation of your academic knowledge
5. Use "course" to get a comprehensive view of your coursework
6. Use "deadlines" to stay on top of upcoming academic work
7. Use "concepts" to understand relationships between learning topics
8. Filter search results by status to focus on incomplete work
9. Prioritize assignments based on priority values
10. Follow sequential relationships to create effective study plans
11. Combine query results to build comprehensive study strategies 
```

--------------------------------------------------------------------------------
/student/student_advancedcontext.txt:
--------------------------------------------------------------------------------

```
A comprehensive tool for querying and analyzing your educational knowledge graph.
This tool provides specialized operations to extract meaningful insights and contextual information about your academic journey.
It enables deep exploration of courses, assignments, exams, concepts, and educational resources.

When to use this tool:
- Retrieving the complete educational knowledge graph
- Searching for specific academic entities using keyword matching
- Fetching details on a precise set of educational entities
- Getting comprehensive information about a specific course
- Finding upcoming assignment and exam deadlines
- Checking detailed status of a specific assignment
- Preparing for exams with concept retrieval
- Discovering connections between learning concepts
- Tracking and reviewing lecture notes
- Getting an overview of an entire academic term
- Identifying entities by status (not_started, in_progress, complete)
- Finding high-priority assignments and tasks
- Exploring sequential relationships between entities

Key features:
- Ten specialized query operation types
- Full educational graph retrieval with entities and relations
- Keyword-based search across academic entities and their properties
- Direct entity lookup by exact name
- Course details including lectures, assignments, exams, and resources
- Deadline tracking with time-based filtering
- Assignment status with progress tracking through has_status relations
- Priority information via has_priority relations
- Exam preparation with related concepts and materials
- Concept relationship mapping
- Sequential entity relationships via follows relations
- Lecture note organization
- Term-based academic overview
- JSON-formatted response with query results

Parameters explained:
- type: The query operation type to perform, which must be one of:
  * "graph" - Retrieve the entire educational knowledge graph
  * "search" - Find academic entities by keyword/partial match
  * "nodes" - Get specific educational entities by exact name
  * "course" - Get comprehensive details about a specific course
  * "deadlines" - Get upcoming assignment and exam deadlines
  * "assignment" - Get detailed status of a specific assignment
  * "exam" - Get preparation materials for a specific exam
  * "concepts" - Find related concepts based on a starting concept
  * "lecture" - Track and organize notes for lectures
  * "term" - Get overview of an academic term
- params: Operation-specific parameters structure:
  * For "graph": No parameters needed
  * For "search": { query: "search text" }
  * For "nodes": { names: ["EntityName1", "EntityName2", ...] }
  * For "course": { courseName: "Course Name" }
  * For "deadlines": { termName: "Term Name", courseName: "Course Name", daysAhead: 14 }
  * For "assignment": { assignmentName: "Assignment Name" }
  * For "exam": { examName: "Exam Name" }
  * For "concepts": { conceptName: "Concept Name", depth: 1 }
  * For "lecture": { courseName: "Course Name" }
  * For "term": { termName: "Term Name" }

Operation details:
- "graph" returns the complete educational knowledge graph structure
- "search" performs partial matching on entity names, types, and observations
- "nodes" retrieves specific entities by exact name matching
- "course" provides a comprehensive view of a course with its components
- "deadlines" finds upcoming assignments and exams with due dates
- "assignment" shows detailed status and related concepts for an assignment
- "exam" provides study resources and related concepts for exam preparation
- "concepts" maps relationships between different learning concepts
- "lecture" organizes and retrieves notes for course lectures
- "term" gives an overview of courses and work for an academic term

Status information:
- All entities include status information (not_started, in_progress, complete) via has_status relations
- Status can be used in search queries (e.g., "status:complete")
- Course views show assignment completion status
- Term views highlight course completion percentages based on status

Priority information:
- Entities can have priority values (low, high) via has_priority relations
- Priority can be used in search queries (e.g., "priority:high")
- High-priority items are highlighted in course and term views

Sequential relationships:
- Entities can have sequence relationships through follows relations
- Course views show recommended sequence of assignments and lectures
- Concept views show prerequisite relationships

Return structures:
- All operations return { success: true/false, ... } with operation-specific data
- Error responses include detailed error messages
- Complex operations return rich, structured data about academic entities
- Educational relationships are preserved in all returned data
- Status and priority information is included in relevant entity data

You should:
1. Select the most appropriate query type for your educational information need
2. Provide the required parameters for your chosen operation type
3. Start with broader queries and refine to more specific ones
4. Use "search" for exploratory investigation of your academic knowledge
5. Use "course" to get a comprehensive view of your coursework
6. Use "deadlines" to stay on top of upcoming academic work
7. Use "concepts" to understand relationships between learning topics
8. Filter search results by status to focus on incomplete work
9. Prioritize assignments based on priority values
10. Follow sequential relationships to create effective study plans
11. Combine query results to build comprehensive study strategies 
```

--------------------------------------------------------------------------------
/main/descriptions/project_deletecontext.txt:
--------------------------------------------------------------------------------

```
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.

When to use this tool:
- Removing completed or canceled projects or tasks
- Deleting erroneous relationships between project elements
- Clearing outdated observations from project entities
- Restructuring your project organization as the project evolves
- Removing team members who are no longer part of the project
- Correcting relationships between tasks, milestones, and resources
- Cleaning up the knowledge graph during project phase transitions
- Eliminating deprecated risks or issues that are no longer relevant
- Removing preliminary project elements that have been superseded
- Reorganizing your project structure by removing and recreating elements
- Updating status assignments when task or project states change
- Modifying priority levels as project needs shift
- Restructuring sequential relationships between tasks and activities

Key features:
- Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
- Maintains knowledge graph integrity during deletion operations
- Supports batch deletion of multiple items in a single operation
- Returns clear confirmation of deletion results
- Preserves the overall structure of the project knowledge graph while removing specific elements
- Performs validation to ensure deletion requests are properly formatted
- Handles status and priority relation management
- Supports modification of task sequencing relationships

Parameters explained:
1. type: The type of deletion operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The elements to remove from the knowledge graph (structure varies by type):
  - For "entities": Array of entity names to delete
    * Example: ["Task_A", "Milestone_1"]
  - For "relations": Array of relation objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: Type of relationship to remove (e.g., "part_of", "has_status", "has_priority", "precedes")
    * Example: [{ "from": "Task_A", "to": "Milestone_1", "relationType": "part_of" }]
  - For "observations": Array of objects, each containing:
    * entityName: Name of the entity to remove observations from
    * observations: Array of specific observations to remove
    * Example: [{ "entityName": "Project_X", "observations": ["duration:3 months", "budget:10000"] }]

Deletion behavior by type:
- Entities: Removes the specified entities and all their associated relations from the knowledge graph
- Relations: Removes only the specified relationships, leaving the connected entities intact
- Observations: Removes specific observations from entities while preserving the entities themselves

Status and Priority Management:
- When deleting status or priority entities, be aware that all has_status or has_priority relations using these entities will be removed
- For changing an entity's status, delete the existing has_status relation before creating a new one
- For changing priority, delete the existing has_priority relation before creating a new one
- Status values (inactive, active, complete) are managed through relations, not direct properties
- Priority values (low, high) are managed through relations, not direct properties

Sequential Task Management:
- Removing precedes relations will affect task sequencing and dependencies
- When reorganizing project tasks, update all affected precedes relations
- Consider the impact on project timelines when modifying sequential relationships

Safety considerations:
- Entity deletion is permanent and will also remove all relationships involving those entities
- Consider exporting or backing up your project knowledge graph before performing large-scale deletions
- For sensitive operations, consider removing specific observations rather than entire entities
- When removing key project elements, consider the impact on your overall project structure
- Status changes should be carefully managed to maintain accurate project tracking
- Changes to task sequences may affect dependent project activities

Return information:
- JSON response indicating success or failure
- For successful operations:
  - Success flag set to true
  - Confirmation message with count of deleted items
    * For entities: "Deleted X entities"
    * For relations: "Deleted X relations"
    * For observations: "Deleted observations from X entities"
- For failed operations:
  - Success flag set to false
  - Error message describing the issue

You should:
- Be specific in your deletion requests to avoid unintended data loss
- Use relations deletion when you want to disconnect entities without removing them
- For observations, provide the exact observations to ensure only the intended content is removed
- When restructuring your project, consider how deletions will affect related elements
- Use deletecontext in conjunction with buildcontext to refine and evolve your project structure
- Regularly review your knowledge graph for elements that may need to be removed or updated
- Consider the cascading effects of entity deletion on your overall project structure
- Delete completed tasks and milestones systematically when closing project phases
- Remove resolved risks and issues to keep your project status current
- When updating entity status, delete the old has_status relation before creating a new one
- When updating entity priority, delete the old has_priority relation before creating a new one
- Maintain logical consistency when modifying sequential task relationships 
```

--------------------------------------------------------------------------------
/project/project_deletecontext.txt:
--------------------------------------------------------------------------------

```
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.

When to use this tool:
- Removing completed or canceled projects or tasks
- Deleting erroneous relationships between project elements
- Clearing outdated observations from project entities
- Restructuring your project organization as the project evolves
- Removing team members who are no longer part of the project
- Correcting relationships between tasks, milestones, and resources
- Cleaning up the knowledge graph during project phase transitions
- Eliminating deprecated risks or issues that are no longer relevant
- Removing preliminary project elements that have been superseded
- Reorganizing your project structure by removing and recreating elements
- Updating status assignments when task or project states change
- Modifying priority levels as project needs shift
- Restructuring sequential relationships between tasks and activities

Key features:
- Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
- Maintains knowledge graph integrity during deletion operations
- Supports batch deletion of multiple items in a single operation
- Returns clear confirmation of deletion results
- Preserves the overall structure of the project knowledge graph while removing specific elements
- Performs validation to ensure deletion requests are properly formatted
- Handles status and priority relation management
- Supports modification of task sequencing relationships

Parameters explained:
1. type: The type of deletion operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The elements to remove from the knowledge graph (structure varies by type):
  - For "entities": Array of entity names to delete
    * Example: ["Task_A", "Milestone_1"]
  - For "relations": Array of relation objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: Type of relationship to remove (e.g., "part_of", "has_status", "has_priority", "precedes")
    * Example: [{ "from": "Task_A", "to": "Milestone_1", "relationType": "part_of" }]
  - For "observations": Array of objects, each containing:
    * entityName: Name of the entity to remove observations from
    * observations: Array of specific observations to remove
    * Example: [{ "entityName": "Project_X", "observations": ["duration:3 months", "budget:10000"] }]

Deletion behavior by type:
- Entities: Removes the specified entities and all their associated relations from the knowledge graph
- Relations: Removes only the specified relationships, leaving the connected entities intact
- Observations: Removes specific observations from entities while preserving the entities themselves

Status and Priority Management:
- When deleting status or priority entities, be aware that all has_status or has_priority relations using these entities will be removed
- For changing an entity's status, delete the existing has_status relation before creating a new one
- For changing priority, delete the existing has_priority relation before creating a new one
- Status values (inactive, active, complete) are managed through relations, not direct properties
- Priority values (low, high) are managed through relations, not direct properties

Sequential Task Management:
- Removing precedes relations will affect task sequencing and dependencies
- When reorganizing project tasks, update all affected precedes relations
- Consider the impact on project timelines when modifying sequential relationships

Safety considerations:
- Entity deletion is permanent and will also remove all relationships involving those entities
- Consider exporting or backing up your project knowledge graph before performing large-scale deletions
- For sensitive operations, consider removing specific observations rather than entire entities
- When removing key project elements, consider the impact on your overall project structure
- Status changes should be carefully managed to maintain accurate project tracking
- Changes to task sequences may affect dependent project activities

Return information:
- JSON response indicating success or failure
- For successful operations:
  - Success flag set to true
  - Confirmation message with count of deleted items
    * For entities: "Deleted X entities"
    * For relations: "Deleted X relations"
    * For observations: "Deleted observations from X entities"
- For failed operations:
  - Success flag set to false
  - Error message describing the issue

You should:
- Be specific in your deletion requests to avoid unintended data loss
- Use relations deletion when you want to disconnect entities without removing them
- For observations, provide the exact observations to ensure only the intended content is removed
- When restructuring your project, consider how deletions will affect related elements
- Use deletecontext in conjunction with buildcontext to refine and evolve your project structure
- Regularly review your knowledge graph for elements that may need to be removed or updated
- Consider the cascading effects of entity deletion on your overall project structure
- Delete completed tasks and milestones systematically when closing project phases
- Remove resolved risks and issues to keep your project status current
- When updating entity status, delete the old has_status relation before creating a new one
- When updating entity priority, delete the old has_priority relation before creating a new one
- Maintain logical consistency when modifying sequential task relationships 
```

--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_loadcontext.txt:
--------------------------------------------------------------------------------

```
A sophisticated tool for retrieving rich, contextual information about qualitative research entities, providing structured insights tailored to different research components.

When to use this tool:
- Retrieving detailed information about research projects, participants, interviews, and analytical elements
- Exploring thematic analyses and research findings
- Reviewing participant profiles and interview transcripts
- Examining code definitions and their connections to data
- Analyzing emerging themes and their supporting evidence
- Investigating research questions and related findings
- Reviewing analytical memos and their connections to data
- Preparing for coding sessions by establishing contextual understanding
- Exploring relationships between codes, themes, and concepts
- Getting a comprehensive overview of project progress and insights
- Tracking research activities by their current status
- Managing tasks based on their assigned priorities
- Understanding sequential relationships between research processes

Key features:
- Provides richly formatted, context-aware information about research entities
- Adapts output format based on entity type (project, participant, interview, code, theme, memo, researchQuestion)
- Presents both direct entity information and related research elements
- Shows research design, methodology, and analysis progression
- Tracks entity views within the current research session
- Formats information in a structured, readable markdown format
- Highlights relationships between research elements
- Presents supporting quotes and evidence for themes and codes
- Shows co-occurrence patterns between codes where available
- Includes status information for tracking research progress
- Displays priority assignments for critical research elements
- Visualizes sequential relationships between research processes

Parameters explained:
1. entityName: Required - The name of the entity to retrieve context for
  - Example: "Health Behavior Study", "Participant_P001", "Interview_20230315"
2. entityType: Optional - The type of entity being retrieved
  - Default: "project"
  - Helps the system format the output appropriately
  - Common types include: "project", "participant", "interview", "code", "theme", "memo", "researchQuestion", "status", "priority"
3. sessionId: Optional - The current session identifier
  - Typically provided by startsession
  - Used for tracking entity views within the session

Each entity type returns specialized context information:
- Project: Shows project status, description, research design, research questions, data collection stats, recent interviews, analysis progress (themes), and findings
- Participant: Displays demographic information, interview history, observation records, notable quotes, and research memos
- Interview: Shows project affiliation, participant, date, transcript content, applied codes, and notable quotes
- Code: Displays definition, status, creation date, code group affiliations, supporting quotes, sources, associated themes, and code co-occurrence data
- Theme: Shows description, status, creation date, project affiliation, supporting codes, example quotes, and analytical memos
- Memo: Displays topic, date, project affiliation, content, and related entities
- Research Question: Shows the question text, project affiliation, related findings, themes, and supporting quotes
- Status: Shows all entities assigned this status value, organized by entity type
- Priority: Shows all entities assigned this priority value, organized by entity type
- Other Entity Types: Shows observations and relationship information for other entity types

Status and Priority Information:
- All entity displays include status information when available via has_status relations
- Priority assignments are shown for tasks and other prioritized elements
- Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Valid priority values include: high, low

Sequential Process Relationships:
- Entity displays show preceding and following entities through precedes relations
- Process sequences are visualized to show workflow between research activities
- Research phases and activities display their position in the overall research process

Return information:
- Formatted markdown text with hierarchical structure
- Sections adapted to the specific entity type
- Related entities shown with their descriptions and connections
- Status and priority information prominently displayed
- Sequential relationships clearly indicated
- Error messages if the entity doesn't exist or can't be retrieved

You should:
- Specify the exact entity name for accurate retrieval
- Provide the entity type when possible for optimally formatted results
- Start with project entities to get a high-level overview of research
- Use participant context to understand individual perspectives
- Examine interview context to see coding applied to raw data
- Review code context to understand analytical categories
- Explore theme context to see patterns and theoretical constructs
- Use research question context to track progress toward answering key inquiries
- Examine memo context to review analytical insights
- Check status entities to see all research elements at the same stage
- Review priority entities to identify critical research tasks
- Explore sequential relationships to understand research process flow
- After retrieving context, follow up on specific entities of interest
- Use in conjunction with startsession to maintain session tracking
- Remember that this tool only retrieves existing information; use buildcontext to add new entities 
```

--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_loadcontext.txt:
--------------------------------------------------------------------------------

```
A sophisticated tool for retrieving rich, contextual information about qualitative research entities, providing structured insights tailored to different research components.

When to use this tool:
- Retrieving detailed information about research projects, participants, interviews, and analytical elements
- Exploring thematic analyses and research findings
- Reviewing participant profiles and interview transcripts
- Examining code definitions and their connections to data
- Analyzing emerging themes and their supporting evidence
- Investigating research questions and related findings
- Reviewing analytical memos and their connections to data
- Preparing for coding sessions by establishing contextual understanding
- Exploring relationships between codes, themes, and concepts
- Getting a comprehensive overview of project progress and insights
- Tracking research activities by their current status
- Managing tasks based on their assigned priorities
- Understanding sequential relationships between research processes

Key features:
- Provides richly formatted, context-aware information about research entities
- Adapts output format based on entity type (project, participant, interview, code, theme, memo, researchQuestion)
- Presents both direct entity information and related research elements
- Shows research design, methodology, and analysis progression
- Tracks entity views within the current research session
- Formats information in a structured, readable markdown format
- Highlights relationships between research elements
- Presents supporting quotes and evidence for themes and codes
- Shows co-occurrence patterns between codes where available
- Includes status information for tracking research progress
- Displays priority assignments for critical research elements
- Visualizes sequential relationships between research processes

Parameters explained:
1. entityName: Required - The name of the entity to retrieve context for
  - Example: "Health Behavior Study", "Participant_P001", "Interview_20230315"
2. entityType: Optional - The type of entity being retrieved
  - Default: "project"
  - Helps the system format the output appropriately
  - Common types include: "project", "participant", "interview", "code", "theme", "memo", "researchQuestion", "status", "priority"
3. sessionId: Optional - The current session identifier
  - Typically provided by startsession
  - Used for tracking entity views within the session

Each entity type returns specialized context information:
- Project: Shows project status, description, research design, research questions, data collection stats, recent interviews, analysis progress (themes), and findings
- Participant: Displays demographic information, interview history, observation records, notable quotes, and research memos
- Interview: Shows project affiliation, participant, date, transcript content, applied codes, and notable quotes
- Code: Displays definition, status, creation date, code group affiliations, supporting quotes, sources, associated themes, and code co-occurrence data
- Theme: Shows description, status, creation date, project affiliation, supporting codes, example quotes, and analytical memos
- Memo: Displays topic, date, project affiliation, content, and related entities
- Research Question: Shows the question text, project affiliation, related findings, themes, and supporting quotes
- Status: Shows all entities assigned this status value, organized by entity type
- Priority: Shows all entities assigned this priority value, organized by entity type
- Other Entity Types: Shows observations and relationship information for other entity types

Status and Priority Information:
- All entity displays include status information when available via has_status relations
- Priority assignments are shown for tasks and other prioritized elements
- Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Valid priority values include: high, low

Sequential Process Relationships:
- Entity displays show preceding and following entities through precedes relations
- Process sequences are visualized to show workflow between research activities
- Research phases and activities display their position in the overall research process

Return information:
- Formatted markdown text with hierarchical structure
- Sections adapted to the specific entity type
- Related entities shown with their descriptions and connections
- Status and priority information prominently displayed
- Sequential relationships clearly indicated
- Error messages if the entity doesn't exist or can't be retrieved

You should:
- Specify the exact entity name for accurate retrieval
- Provide the entity type when possible for optimally formatted results
- Start with project entities to get a high-level overview of research
- Use participant context to understand individual perspectives
- Examine interview context to see coding applied to raw data
- Review code context to understand analytical categories
- Explore theme context to see patterns and theoretical constructs
- Use research question context to track progress toward answering key inquiries
- Examine memo context to review analytical insights
- Check status entities to see all research elements at the same stage
- Review priority entities to identify critical research tasks
- Explore sequential relationships to understand research process flow
- After retrieving context, follow up on specific entities of interest
- Use in conjunction with startsession to maintain session tracking
- Remember that this tool only retrieves existing information; use buildcontext to add new entities 
```

--------------------------------------------------------------------------------
/main/descriptions/project_buildcontext.txt:
--------------------------------------------------------------------------------

```
A versatile tool for constructing and enhancing your project management knowledge graph by adding new project elements, relationships, and observations.

When to use this tool:
- Creating new project entities (projects, tasks, milestones, team members, etc.)
- Establishing relationships between project elements (e.g., connecting tasks to projects, assigning team members)
- Adding observations, properties, or metadata to existing project entities
- Building the project management structure incrementally as your project evolves
- Organizing and structuring project data within your management framework
- Documenting project status, risks, and decisions
- Tracking project dependencies and assignments
- Creating comprehensive project timelines with connected elements
- Setting status values for project entities
- Assigning priorities to tasks and other entities
- Defining task sequencing and dependencies

Key features:
- Creates three distinct types of knowledge graph elements: entities, relations, and observations
- Supports various project management entity types (projects, tasks, milestones, team members, etc.)
- Validates entity and relation types against predefined standards for the project domain
- Handles batch creation of multiple entities or relations in a single operation
- Returns confirmation with details of created elements
- Ensures proper data typing and structure for the project management knowledge graph
- Enables comprehensive documentation of project structure and progress
- Supports status and priority assignment through entity-relation model
- Enables sequential task relationships through precedes relation

Parameters explained:
1. type: The type of creation operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The content to add to the knowledge graph (structure varies by type):
  - For "entities": An array of objects, each containing:
    * name: Unique identifier for the entity
    * entityType: One of the valid entity types for project management
    * observations: Array of strings containing properties or metadata about the entity
    * embedding: (Optional) Vector embedding for enhanced semantic search
  - For "relations": An array of objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: The type of relationship between entities (e.g., "depends_on", "assigned_to", "has_status")
    * observations: (Optional) Array of strings with metadata about the relationship
  - For "observations": Either a single object or an array of objects:
    * Single object format:
      * entityName: Name of the entity to add observations to
      * observations: Array of strings with new observations to add
    * Array format:
      * Each object containing:
        * entityName: Name of the entity to add observations to
        * contents: Array of strings with new observations to add

Valid entity types:
- project: Overall project container
- task: Individual action items or work packages
- milestone: Key project checkpoints
- teamMember: Project team participants
- risk: Potential project threats or issues
- decision: Documented project decisions
- resource: Project assets or materials
- issue: Problems requiring resolution
- dependency: Inter-element relationships
- meeting: Project-related gatherings
- document: Project files and documentation
- stakeholder: Parties with interest in the project
- status: Entity status (inactive, active, complete)
- priority: Entity priority (low, high)

Valid relation types:
- part_of: Entity belongs to another entity
- depends_on: Task dependency relationship
- assigned_to: Assignment relationship between tasks and team members
- responsible_for: Ownership of project elements
- created_by: Authorship relationship
- leads_to: Sequential relationship
- blocks: Impediment relationship
- reports_to: Organizational hierarchy
- collaborates_with: Collaborative relationship
- decides_on: Decision-making relationship
- impacts: Effect relationship
- has_status: Links entity to its status (inactive, active, complete)
- has_priority: Links entity to its priority (low, high)
- precedes: Task precedes another task (for sequencing)

Status Values:
- inactive: Work on the entity has not begun or is paused
- active: Work is actively underway
- complete: Work has been finished

Priority Values:
- low: Lower priority item
- high: Higher priority item

Return information:
- JSON response indicating success or failure
- For successful operations:
  * Success flag set to true
  * Details of created elements in the "created" field (for entities/relations) or info message for observations
- For failed operations:
  * Success flag set to false
  * Error message describing the issue

Error handling:
- Returns descriptive error messages for invalid inputs
- Gracefully handles type mismatches and formatting errors
- Rejects operations with invalid types

You should:
- Use consistent naming conventions for entities to facilitate relationships and retrieval
- Begin by creating projects before more specific project elements
- Add detailed observations to entities to enhance context and searchability
- Create relationships to build a comprehensive network of interconnected project data
- Document project status and progress through has_status relations
- Assign priorities to tasks using has_priority relations
- Use the precedes relation to establish task sequences and dependencies
- Assign specific team members to tasks using relations
- Track project risks with detailed observations
- Document decisions with context and rationale
- Update entity observations regularly to reflect current project information
- Check the operation result to confirm successful creation 
```

--------------------------------------------------------------------------------
/project/project_buildcontext.txt:
--------------------------------------------------------------------------------

```
A versatile tool for constructing and enhancing your project management knowledge graph by adding new project elements, relationships, and observations.

When to use this tool:
- Creating new project entities (projects, tasks, milestones, team members, etc.)
- Establishing relationships between project elements (e.g., connecting tasks to projects, assigning team members)
- Adding observations, properties, or metadata to existing project entities
- Building the project management structure incrementally as your project evolves
- Organizing and structuring project data within your management framework
- Documenting project status, risks, and decisions
- Tracking project dependencies and assignments
- Creating comprehensive project timelines with connected elements
- Setting status values for project entities
- Assigning priorities to tasks and other entities
- Defining task sequencing and dependencies

Key features:
- Creates three distinct types of knowledge graph elements: entities, relations, and observations
- Supports various project management entity types (projects, tasks, milestones, team members, etc.)
- Validates entity and relation types against predefined standards for the project domain
- Handles batch creation of multiple entities or relations in a single operation
- Returns confirmation with details of created elements
- Ensures proper data typing and structure for the project management knowledge graph
- Enables comprehensive documentation of project structure and progress
- Supports status and priority assignment through entity-relation model
- Enables sequential task relationships through precedes relation

Parameters explained:
1. type: The type of creation operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The content to add to the knowledge graph (structure varies by type):
  - For "entities": An array of objects, each containing:
    * name: Unique identifier for the entity
    * entityType: One of the valid entity types for project management
    * observations: Array of strings containing properties or metadata about the entity
    * embedding: (Optional) Vector embedding for enhanced semantic search
  - For "relations": An array of objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: The type of relationship between entities (e.g., "depends_on", "assigned_to", "has_status")
    * observations: (Optional) Array of strings with metadata about the relationship
  - For "observations": Either a single object or an array of objects:
    * Single object format:
      * entityName: Name of the entity to add observations to
      * observations: Array of strings with new observations to add
    * Array format:
      * Each object containing:
        * entityName: Name of the entity to add observations to
        * contents: Array of strings with new observations to add

Valid entity types:
- project: Overall project container
- task: Individual action items or work packages
- milestone: Key project checkpoints
- teamMember: Project team participants
- risk: Potential project threats or issues
- decision: Documented project decisions
- resource: Project assets or materials
- issue: Problems requiring resolution
- dependency: Inter-element relationships
- meeting: Project-related gatherings
- document: Project files and documentation
- stakeholder: Parties with interest in the project
- status: Entity status (inactive, active, complete)
- priority: Entity priority (low, high)

Valid relation types:
- part_of: Entity belongs to another entity
- depends_on: Task dependency relationship
- assigned_to: Assignment relationship between tasks and team members
- responsible_for: Ownership of project elements
- created_by: Authorship relationship
- leads_to: Sequential relationship
- blocks: Impediment relationship
- reports_to: Organizational hierarchy
- collaborates_with: Collaborative relationship
- decides_on: Decision-making relationship
- impacts: Effect relationship
- has_status: Links entity to its status (inactive, active, complete)
- has_priority: Links entity to its priority (low, high)
- precedes: Task precedes another task (for sequencing)

Status Values:
- inactive: Work on the entity has not begun or is paused
- active: Work is actively underway
- complete: Work has been finished

Priority Values:
- low: Lower priority item
- high: Higher priority item

Return information:
- JSON response indicating success or failure
- For successful operations:
  * Success flag set to true
  * Details of created elements in the "created" field (for entities/relations) or info message for observations
- For failed operations:
  * Success flag set to false
  * Error message describing the issue

Error handling:
- Returns descriptive error messages for invalid inputs
- Gracefully handles type mismatches and formatting errors
- Rejects operations with invalid types

You should:
- Use consistent naming conventions for entities to facilitate relationships and retrieval
- Begin by creating projects before more specific project elements
- Add detailed observations to entities to enhance context and searchability
- Create relationships to build a comprehensive network of interconnected project data
- Document project status and progress through has_status relations
- Assign priorities to tasks using has_priority relations
- Use the precedes relation to establish task sequences and dependencies
- Assign specific team members to tasks using relations
- Track project risks with detailed observations
- Document decisions with context and rationale
- Update entity observations regularly to reflect current project information
- Check the operation result to confirm successful creation 
```

--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_deletecontext.txt:
--------------------------------------------------------------------------------

```
A precise tool for removing elements from the quantitative research knowledge graph, enabling researchers to maintain data accuracy and refine their analytical framework.

When to use this tool:
- Removing incorrect or duplicate research entities
- Deleting erroneous relationships between research elements
- Clearing outdated observations from research entities
- Restructuring your research framework as analysis evolves
- Removing invalid statistical tests or models
- Correcting relationships between variables, datasets, or results
- Cleaning up the knowledge graph during research refinement phases
- Eliminating deprecated hypotheses or findings that are no longer supported
- Removing preliminary analyses that have been superseded by more rigorous methods
- Reorganizing your analytical structure by removing and recreating elements
- Updating status assignments when research activities change state
- Modifying priority assignments as research focus shifts
- Restructuring sequential relationships between research processes

Key features:
- Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
- Maintains knowledge graph integrity during deletion operations
- Supports batch deletion of multiple items in a single operation
- Returns clear confirmation of deletion results
- Preserves the overall structure of the research knowledge graph while removing specific elements
- Performs validation to ensure deletion requests are properly formatted
- Handles status and priority relation management
- Supports modification of sequential process relationships

Parameters explained:
1. type: The type of deletion operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The elements to remove from the knowledge graph (structure varies by type):
  - For "entities": Array of entity names to delete
    * Example: ["Dataset_2021", "Hypothesis_A", "Model_Linear", "Status_Completed"]
  - For "relations": Array of relation objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: Type of relationship to remove (e.g., "correlates_with", "has_status", "has_priority", "precedes")
    * Example: [{ "from": "Variable_Age", "to": "Variable_Income", "relationType": "correlates_with" }]
  - For "observations": Array of objects, each containing:
    * entityName: Name of the entity to remove observations from
    * observations: Array of specific observations to remove
    * Example: [{ "entityName": "Dataset_Main", "observations": ["size:1000", "collection_date:2022-05-15"] }]

Deletion behavior by type:
- Entities: Removes the specified entities and all their associated relations from the knowledge graph
- Relations: Removes only the specified relationships, leaving the connected entities intact
- Observations: Removes specific observations from entities while preserving the entities themselves

Status and Priority Management:
- When deleting status or priority entities, be aware of the impact on entities that reference them
- For changing an entity's status, delete the existing has_status relation before creating a new one
- For changing priority, delete the existing has_priority relation before creating a new one
- Status values (active, completed, pending, abandoned) are managed through relations, not direct properties
- Priority values (high, low) are managed through relations, not direct properties

Sequential Process Management:
- Removing precedes relations affects the logical flow of research processes
- When reorganizing research phases, update all affected precedes relations
- Consider restructuring sequential relationships after deletion to maintain methodological continuity
- Sequential relationships are important for maintaining proper order in multi-step analyses

Safety considerations:
- Entity deletion is permanent and will also remove all relationships involving those entities
- Consider exporting or backing up your research knowledge graph before performing large-scale deletions
- For sensitive operations, consider removing specific observations rather than entire entities
- When removing statistical tests or results, consider the impact on your overall analysis framework
- Status changes should be carefully managed to maintain accurate research progress tracking
- Changes to sequential relationships may affect dependent research activities

Return information:
- JSON response indicating success or failure
- For successful operations:
  - Success flag set to true
  - Confirmation message with count of deleted items
    * For entities: "Deleted X entities"
    * For relations: "Deleted X relations"
    * For observations: "Deleted observations from X entities"
- For failed operations:
  - Success flag set to false
  - Error message describing the issue

You should:
- Be specific in your deletion requests to avoid unintended data loss
- Use relations deletion when you want to disconnect entities without removing them
- For observations, provide the exact observations to ensure only the intended content is removed
- When restructuring your analysis, consider how deletions will affect related elements
- Use deletecontext in conjunction with buildcontext to refine and evolve your research framework
- Regularly review your knowledge graph for elements that may need to be removed or updated
- Consider the cascading effects of entity deletion on your overall research structure
- Delete outdated statistical results when new analyses are performed
- Remove incorrect relationships between variables when better understanding is gained
- When updating entity status, delete the old has_status relation before creating a new one
- When updating entity priority, delete the old has_priority relation before creating a new one
- Maintain logical consistency when modifying sequential analysis relationships 
```

--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_deletecontext.txt:
--------------------------------------------------------------------------------

```
A precise tool for removing elements from the quantitative research knowledge graph, enabling researchers to maintain data accuracy and refine their analytical framework.

When to use this tool:
- Removing incorrect or duplicate research entities
- Deleting erroneous relationships between research elements
- Clearing outdated observations from research entities
- Restructuring your research framework as analysis evolves
- Removing invalid statistical tests or models
- Correcting relationships between variables, datasets, or results
- Cleaning up the knowledge graph during research refinement phases
- Eliminating deprecated hypotheses or findings that are no longer supported
- Removing preliminary analyses that have been superseded by more rigorous methods
- Reorganizing your analytical structure by removing and recreating elements
- Updating status assignments when research activities change state
- Modifying priority assignments as research focus shifts
- Restructuring sequential relationships between research processes

Key features:
- Provides targeted deletion capabilities for three distinct types of knowledge graph elements: entities, relations, and observations
- Maintains knowledge graph integrity during deletion operations
- Supports batch deletion of multiple items in a single operation
- Returns clear confirmation of deletion results
- Preserves the overall structure of the research knowledge graph while removing specific elements
- Performs validation to ensure deletion requests are properly formatted
- Handles status and priority relation management
- Supports modification of sequential process relationships

Parameters explained:
1. type: The type of deletion operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The elements to remove from the knowledge graph (structure varies by type):
  - For "entities": Array of entity names to delete
    * Example: ["Dataset_2021", "Hypothesis_A", "Model_Linear", "Status_Completed"]
  - For "relations": Array of relation objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: Type of relationship to remove (e.g., "correlates_with", "has_status", "has_priority", "precedes")
    * Example: [{ "from": "Variable_Age", "to": "Variable_Income", "relationType": "correlates_with" }]
  - For "observations": Array of objects, each containing:
    * entityName: Name of the entity to remove observations from
    * observations: Array of specific observations to remove
    * Example: [{ "entityName": "Dataset_Main", "observations": ["size:1000", "collection_date:2022-05-15"] }]

Deletion behavior by type:
- Entities: Removes the specified entities and all their associated relations from the knowledge graph
- Relations: Removes only the specified relationships, leaving the connected entities intact
- Observations: Removes specific observations from entities while preserving the entities themselves

Status and Priority Management:
- When deleting status or priority entities, be aware of the impact on entities that reference them
- For changing an entity's status, delete the existing has_status relation before creating a new one
- For changing priority, delete the existing has_priority relation before creating a new one
- Status values (active, completed, pending, abandoned) are managed through relations, not direct properties
- Priority values (high, low) are managed through relations, not direct properties

Sequential Process Management:
- Removing precedes relations affects the logical flow of research processes
- When reorganizing research phases, update all affected precedes relations
- Consider restructuring sequential relationships after deletion to maintain methodological continuity
- Sequential relationships are important for maintaining proper order in multi-step analyses

Safety considerations:
- Entity deletion is permanent and will also remove all relationships involving those entities
- Consider exporting or backing up your research knowledge graph before performing large-scale deletions
- For sensitive operations, consider removing specific observations rather than entire entities
- When removing statistical tests or results, consider the impact on your overall analysis framework
- Status changes should be carefully managed to maintain accurate research progress tracking
- Changes to sequential relationships may affect dependent research activities

Return information:
- JSON response indicating success or failure
- For successful operations:
  - Success flag set to true
  - Confirmation message with count of deleted items
    * For entities: "Deleted X entities"
    * For relations: "Deleted X relations"
    * For observations: "Deleted observations from X entities"
- For failed operations:
  - Success flag set to false
  - Error message describing the issue

You should:
- Be specific in your deletion requests to avoid unintended data loss
- Use relations deletion when you want to disconnect entities without removing them
- For observations, provide the exact observations to ensure only the intended content is removed
- When restructuring your analysis, consider how deletions will affect related elements
- Use deletecontext in conjunction with buildcontext to refine and evolve your research framework
- Regularly review your knowledge graph for elements that may need to be removed or updated
- Consider the cascading effects of entity deletion on your overall research structure
- Delete outdated statistical results when new analyses are performed
- Remove incorrect relationships between variables when better understanding is gained
- When updating entity status, delete the old has_status relation before creating a new one
- When updating entity priority, delete the old has_priority relation before creating a new one
- Maintain logical consistency when modifying sequential analysis relationships 
```

--------------------------------------------------------------------------------
/main/descriptions/student_endsession.txt:
--------------------------------------------------------------------------------

```
A multi-stage tool for documenting study sessions, tracking academic progress, recording concepts learned, updating assignment status, and enriching the student knowledge graph.

When to use this tool: 
Only use this tool when the user explicity requests it or provides explicit approval.

Key features:
- Provides a structured, multi-stage workflow for session documentation
- Records concepts learned in the knowledge graph
- Updates assignment status using has_status relations (not_started, in_progress, complete)
- Updates assignment priorities using has_priority relations (low, high)
- Establishes sequential relationships between concepts using follows relations
- Creates connections between concepts and courses
- Updates course status metadata
- Creates new concept entities for topics you've studied
- Maintains session continuity with unique session IDs
- Supports revision of previous stages when needed
- Offers a comprehensive assembly stage that consolidates all session information
- Organizes your academic knowledge into a coherent structure

The endsession tool uses a sequential, multi-stage approach with 6 typical stages:
1. Summary Stage: Records basic session information
2. Concepts Learned Stage: Documents specific concepts studied
3. Assignment Updates Stage: Records status and priority changes to assignments
4. New Concepts Stage: Defines new concept entities to add
5. Course Status Stage: Updates the overall course status
6. Assembly Stage: Consolidates all information and finalizes the session record

Parameters explained:
1. sessionId: Required - Unique identifier for the study session
  - Obtained from the startsession tool
  - Example: "stu_1234567890_abc123"
2. stage: Required - Current stage of the endsession workflow
  - Accepts: "summary", "conceptsLearned", "assignmentUpdates", "newConcepts", "courseStatus", or "assembly"
  - Each stage has specific data requirements and processing logic
3. stageNumber: Required - The sequence number of the current stage
  - Starts at 1 and typically progresses through 6 stages
  - Used to track progress through the session documentation workflow
4. totalStages: Required - Total number of stages planned for this workflow
  - Typically 6 for the complete workflow
  - Provides context for the progress within the overall process
5. analysis: Optional - Text analysis or observations for the current stage
  - Descriptive text explaining the work done in this stage
  - Example: "Analyzed progress on studying for the final exam"
6. stageData: Optional - Stage-specific structured data
  - Structure varies by stage type:
    * summary: { summary: "Session summary text", duration: "2 hours", course: "CourseName" }
    * conceptsLearned: { concepts: ["Concept A", "Concept B", "Concept C"] }
    * assignmentUpdates: { updates: [{ name: "Assignment1", status: "complete", priority: "high" }, { name: "Assignment2", status: "in_progress" }] }
    * newConcepts: { concepts: [{ name: "NewConcept1", description: "Definition of the concept", follows: "PriorConcept" }] }
    * courseStatus: { courseStatus: "in_progress", courseObservation: "Making good progress" }
    * assembly: No stageData needed - automatically assembled from previous stages
7. nextStageNeeded: Required - Whether additional stages are needed after this one
  - Boolean value (true/false)
  - Set to false on the final stage to complete the session
8. isRevision: Optional - Whether this is revising a previous stage
  - Boolean value (true/false)
  - Default: false
9. revisesStage: Optional - If revising, which stage number is being revised
  - Required when isRevision is true
  - Indicates which previous stage is being updated

When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool performs these updates:
1. Concept Entities: Creates entities for each concept learned and links them to the course
2. Assignment Status Updates: Updates assignment status via has_status relations (not_started, in_progress, complete)
3. Assignment Priority Updates: Updates assignment priority via has_priority relations (low, high)
4. Sequential Concept Relationships: Establishes follows relations between concepts when specified
5. Course Status Update: Updates the course status via has_status relation, adds an updated timestamp, and records observations
6. New Concept Creation: Creates new concept entities, links them to the course, and establishes any sequential relationships
7. Session Recording: Marks the session as completed in persistent storage

Return information:
- JSON response with the following structure:
  * success: Boolean indicating whether the operation succeeded
  * stageCompleted: The stage that was just completed
  * nextStageNeeded: Whether more stages are required
  * stageResult: The processed result of the current stage
  * endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
  * sessionRecorded: (Final stage only) Whether the session was recorded
  * summaryMessage: (Final stage only) Formatted summary of all recorded information
  * error: (Only on failure) Error message describing the issue
- Error information when operation fails

Status and Priority Values:
- Valid status values: not_started, in_progress, complete
- Valid priority values: low, high

You should:
- Complete all stages in order for comprehensive session documentation
- Provide specific details in each stage for accurate knowledge graph updates
- Be precise about assignment names to ensure they match existing assignments
- Use valid status values (not_started, in_progress, complete) when updating assignments
- Use valid priority values (low, high) when specifying assignment importance
- Specify sequential relationships between concepts when appropriate
- Use clear, descriptive names for any new concepts
- Include relevant observations for course status updates
- If making a revision, specify which stage is being revised
- Only mark nextStageNeeded as false on the final assembly stage
- Review the final summary message to confirm all session details were recorded properly
- Use the unique session ID consistently across all stages 
```

--------------------------------------------------------------------------------
/student/student_endsession.txt:
--------------------------------------------------------------------------------

```
A multi-stage tool for documenting study sessions, tracking academic progress, recording concepts learned, updating assignment status, and enriching the student knowledge graph.

When to use this tool: 
Only use this tool when the user explicity requests it or provides explicit approval.

Key features:
- Provides a structured, multi-stage workflow for session documentation
- Records concepts learned in the knowledge graph
- Updates assignment status using has_status relations (not_started, in_progress, complete)
- Updates assignment priorities using has_priority relations (low, high)
- Establishes sequential relationships between concepts using follows relations
- Creates connections between concepts and courses
- Updates course status metadata
- Creates new concept entities for topics you've studied
- Maintains session continuity with unique session IDs
- Supports revision of previous stages when needed
- Offers a comprehensive assembly stage that consolidates all session information
- Organizes your academic knowledge into a coherent structure

The endsession tool uses a sequential, multi-stage approach with 6 typical stages:
1. Summary Stage: Records basic session information
2. Concepts Learned Stage: Documents specific concepts studied
3. Assignment Updates Stage: Records status and priority changes to assignments
4. New Concepts Stage: Defines new concept entities to add
5. Course Status Stage: Updates the overall course status
6. Assembly Stage: Consolidates all information and finalizes the session record

Parameters explained:
1. sessionId: Required - Unique identifier for the study session
  - Obtained from the startsession tool
  - Example: "stu_1234567890_abc123"
2. stage: Required - Current stage of the endsession workflow
  - Accepts: "summary", "conceptsLearned", "assignmentUpdates", "newConcepts", "courseStatus", or "assembly"
  - Each stage has specific data requirements and processing logic
3. stageNumber: Required - The sequence number of the current stage
  - Starts at 1 and typically progresses through 6 stages
  - Used to track progress through the session documentation workflow
4. totalStages: Required - Total number of stages planned for this workflow
  - Typically 6 for the complete workflow
  - Provides context for the progress within the overall process
5. analysis: Optional - Text analysis or observations for the current stage
  - Descriptive text explaining the work done in this stage
  - Example: "Analyzed progress on studying for the final exam"
6. stageData: Optional - Stage-specific structured data
  - Structure varies by stage type:
    * summary: { summary: "Session summary text", duration: "2 hours", course: "CourseName" }
    * conceptsLearned: { concepts: ["Concept A", "Concept B", "Concept C"] }
    * assignmentUpdates: { updates: [{ name: "Assignment1", status: "complete", priority: "high" }, { name: "Assignment2", status: "in_progress" }] }
    * newConcepts: { concepts: [{ name: "NewConcept1", description: "Definition of the concept", follows: "PriorConcept" }] }
    * courseStatus: { courseStatus: "in_progress", courseObservation: "Making good progress" }
    * assembly: No stageData needed - automatically assembled from previous stages
7. nextStageNeeded: Required - Whether additional stages are needed after this one
  - Boolean value (true/false)
  - Set to false on the final stage to complete the session
8. isRevision: Optional - Whether this is revising a previous stage
  - Boolean value (true/false)
  - Default: false
9. revisesStage: Optional - If revising, which stage number is being revised
  - Required when isRevision is true
  - Indicates which previous stage is being updated

When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool performs these updates:
1. Concept Entities: Creates entities for each concept learned and links them to the course
2. Assignment Status Updates: Updates assignment status via has_status relations (not_started, in_progress, complete)
3. Assignment Priority Updates: Updates assignment priority via has_priority relations (low, high)
4. Sequential Concept Relationships: Establishes follows relations between concepts when specified
5. Course Status Update: Updates the course status via has_status relation, adds an updated timestamp, and records observations
6. New Concept Creation: Creates new concept entities, links them to the course, and establishes any sequential relationships
7. Session Recording: Marks the session as completed in persistent storage

Return information:
- JSON response with the following structure:
  * success: Boolean indicating whether the operation succeeded
  * stageCompleted: The stage that was just completed
  * nextStageNeeded: Whether more stages are required
  * stageResult: The processed result of the current stage
  * endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
  * sessionRecorded: (Final stage only) Whether the session was recorded
  * summaryMessage: (Final stage only) Formatted summary of all recorded information
  * error: (Only on failure) Error message describing the issue
- Error information when operation fails

Status and Priority Values:
- Valid status values: not_started, in_progress, complete
- Valid priority values: low, high

You should:
- Complete all stages in order for comprehensive session documentation
- Provide specific details in each stage for accurate knowledge graph updates
- Be precise about assignment names to ensure they match existing assignments
- Use valid status values (not_started, in_progress, complete) when updating assignments
- Use valid priority values (low, high) when specifying assignment importance
- Specify sequential relationships between concepts when appropriate
- Use clear, descriptive names for any new concepts
- Include relevant observations for course status updates
- If making a revision, specify which stage is being revised
- Only mark nextStageNeeded as false on the final assembly stage
- Review the final summary message to confirm all session details were recorded properly
- Use the unique session ID consistently across all stages 
```

--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_buildcontext.txt:
--------------------------------------------------------------------------------

```
A versatile tool for constructing and enhancing the qualitative research knowledge graph by adding new research elements, relationships, and observations.

When to use this tool:
- Creating new research entities (projects, participants, interviews, observations, codes, themes, memos, etc.)
- Establishing relationships between research elements (e.g., connecting participants to projects, codes to data segments)
- Adding observations, notes, or content to existing research entities
- Building the research corpus incrementally as data collection and analysis progress
- Organizing and structuring qualitative data within your research framework
- Documenting emerging themes, codes, and analytical insights during research
- Creating research questions and linking them to findings
- Building code hierarchies and thematic frameworks
- Setting status values for research activities and entities
- Assigning priorities to research tasks and activities
- Defining sequential relationships between research processes

Key features:
- Creates three distinct types of knowledge graph elements: entities, relations, and observations
- Supports specialized qualitative research entity types (projects, participants, interviews, observations, documents, codes, etc.)
- Validates entity and relation types against predefined standards for the qualitative research domain
- Handles batch creation of multiple entities or relations in a single operation
- Returns confirmation with details of created elements
- Ensures proper data typing and structure for the qualitative research knowledge graph
- Enables comprehensive documentation of the research process
- Supports status and priority assignment through entity-relation model
- Enables sequential relationships through precedes relation

Parameters explained:
1. type: The type of creation operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The content to add to the knowledge graph (structure varies by type):
  - For "entities": An array of objects, each containing:
    * name: Unique identifier for the entity
    * entityType: One of the valid entity types (project, participant, interview, observation, document, code, codeGroup, memo, theme, quote, literature, researchQuestion, finding, status, priority)
    * observations: Array of strings containing notes or properties about the entity
  - For "relations": An array of objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: The type of relationship between entities (e.g., "participated_in", "codes", "has_status", "has_priority")
  - For "observations": Either a single object or an array of objects, each containing:
    * entityName: Name of the entity to add observations to
    * contents: Array of strings with new observations to add

Valid entity types:
- project: Overall research study
- participant: Research subjects
- interview: Formal conversation with participants
- observation: Field notes from observational research
- document: External materials being analyzed
- code: Labels applied to data segments
- codeGroup: Categories or families of related codes
- memo: Researcher's analytical notes
- theme: Emergent patterns across data
- quote: Notable excerpts from data sources
- literature: Academic sources
- researchQuestion: Formal questions guiding the study
- finding: Results or conclusions
- status: Entity status values
- priority: Entity priority values

Valid relation types:
- participated_in: Links participants to interviews/observations
- codes: Shows which codes apply to which data
- contains: Hierarchical relationship
- supports: Data supporting a theme or finding
- contradicts: Data contradicting a theme or finding
- answers: Data addressing a research question
- cites: References to literature
- followed_by: Temporal sequence
- related_to: General connection
- reflects_on: Memo reflecting on data/code/theme
- compares: Comparative relationship
- has_status: Links entity to its status
- has_priority: Links entity to its priority
- precedes: Entity comes before another entity in sequence

Status information:
- Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Status is assigned through the has_status relation type

Priority information:
- Valid priority values: high, low
- Priority is assigned through the has_priority relation type

Return information:
- JSON response indicating success or failure
- For successful operations:
  * Success flag set to true
  * Details of created elements in the "created" field (for entities/relations) or "added" field (for observations)
- For failed operations:
  * Success flag set to false
  * Error message describing the issue

Error handling:
- Validates entity types against the predefined list for qualitative research
- Validates relation types against acceptable standards
- Returns descriptive error messages for invalid inputs
- Gracefully handles type mismatches and formatting errors

You should:
- Use consistent naming conventions for entities to facilitate relationships and retrieval
- Begin by creating projects and participants before more specific research elements
- Add detailed observations to entities to enhance context and retrievability
- Create relationships to build a comprehensive network of interconnected research data
- Use has_status relations to track the progress of research activities
- Use has_priority relations to indicate important research elements
- Use the precedes relation to establish sequences in research processes
- Use observations to document the evolution of codes, themes, and analytical thinking
- Regularly update entity observations as your understanding evolves
- Build hierarchical structures using relations (e.g., codes within code groups, themes connecting multiple codes)
- Document the full research journey by adding memos tied to specific analytical moments
- Link quotes to codes, themes, and findings to maintain evidential chains 
```

--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_buildcontext.txt:
--------------------------------------------------------------------------------

```
A versatile tool for constructing and enhancing the qualitative research knowledge graph by adding new research elements, relationships, and observations.

When to use this tool:
- Creating new research entities (projects, participants, interviews, observations, codes, themes, memos, etc.)
- Establishing relationships between research elements (e.g., connecting participants to projects, codes to data segments)
- Adding observations, notes, or content to existing research entities
- Building the research corpus incrementally as data collection and analysis progress
- Organizing and structuring qualitative data within your research framework
- Documenting emerging themes, codes, and analytical insights during research
- Creating research questions and linking them to findings
- Building code hierarchies and thematic frameworks
- Setting status values for research activities and entities
- Assigning priorities to research tasks and activities
- Defining sequential relationships between research processes

Key features:
- Creates three distinct types of knowledge graph elements: entities, relations, and observations
- Supports specialized qualitative research entity types (projects, participants, interviews, observations, documents, codes, etc.)
- Validates entity and relation types against predefined standards for the qualitative research domain
- Handles batch creation of multiple entities or relations in a single operation
- Returns confirmation with details of created elements
- Ensures proper data typing and structure for the qualitative research knowledge graph
- Enables comprehensive documentation of the research process
- Supports status and priority assignment through entity-relation model
- Enables sequential relationships through precedes relation

Parameters explained:
1. type: The type of creation operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The content to add to the knowledge graph (structure varies by type):
  - For "entities": An array of objects, each containing:
    * name: Unique identifier for the entity
    * entityType: One of the valid entity types (project, participant, interview, observation, document, code, codeGroup, memo, theme, quote, literature, researchQuestion, finding, status, priority)
    * observations: Array of strings containing notes or properties about the entity
  - For "relations": An array of objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: The type of relationship between entities (e.g., "participated_in", "codes", "has_status", "has_priority")
  - For "observations": Either a single object or an array of objects, each containing:
    * entityName: Name of the entity to add observations to
    * contents: Array of strings with new observations to add

Valid entity types:
- project: Overall research study
- participant: Research subjects
- interview: Formal conversation with participants
- observation: Field notes from observational research
- document: External materials being analyzed
- code: Labels applied to data segments
- codeGroup: Categories or families of related codes
- memo: Researcher's analytical notes
- theme: Emergent patterns across data
- quote: Notable excerpts from data sources
- literature: Academic sources
- researchQuestion: Formal questions guiding the study
- finding: Results or conclusions
- status: Entity status values
- priority: Entity priority values

Valid relation types:
- participated_in: Links participants to interviews/observations
- codes: Shows which codes apply to which data
- contains: Hierarchical relationship
- supports: Data supporting a theme or finding
- contradicts: Data contradicting a theme or finding
- answers: Data addressing a research question
- cites: References to literature
- followed_by: Temporal sequence
- related_to: General connection
- reflects_on: Memo reflecting on data/code/theme
- compares: Comparative relationship
- has_status: Links entity to its status
- has_priority: Links entity to its priority
- precedes: Entity comes before another entity in sequence

Status information:
- Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Status is assigned through the has_status relation type

Priority information:
- Valid priority values: high, low
- Priority is assigned through the has_priority relation type

Return information:
- JSON response indicating success or failure
- For successful operations:
  * Success flag set to true
  * Details of created elements in the "created" field (for entities/relations) or "added" field (for observations)
- For failed operations:
  * Success flag set to false
  * Error message describing the issue

Error handling:
- Validates entity types against the predefined list for qualitative research
- Validates relation types against acceptable standards
- Returns descriptive error messages for invalid inputs
- Gracefully handles type mismatches and formatting errors

You should:
- Use consistent naming conventions for entities to facilitate relationships and retrieval
- Begin by creating projects and participants before more specific research elements
- Add detailed observations to entities to enhance context and retrievability
- Create relationships to build a comprehensive network of interconnected research data
- Use has_status relations to track the progress of research activities
- Use has_priority relations to indicate important research elements
- Use the precedes relation to establish sequences in research processes
- Use observations to document the evolution of codes, themes, and analytical thinking
- Regularly update entity observations as your understanding evolves
- Build hierarchical structures using relations (e.g., codes within code groups, themes connecting multiple codes)
- Document the full research journey by adding memos tied to specific analytical moments
- Link quotes to codes, themes, and findings to maintain evidential chains 
```

--------------------------------------------------------------------------------
/main/descriptions/common_loadcontext.txt:
--------------------------------------------------------------------------------

```
A powerful tool for retrieving rich, contextual information about domain-specific entities, providing formatted details tailored to each entity type.

When to use this tool:
- Retrieving detailed information about domain-specific entities
- Exploring relationships between connected entities
- Examining status information and progress metrics
- Understanding the structure and elements of complex entities
- Reviewing progress, completion, and deadline information
- Examining entity details, dependencies, and assignments
- Preparing for work on a specific entity by establishing context
- Analyzing knowledge graph connections to understand entity relationships
- Getting a holistic view of status, progress, and upcoming work
- Establishing context for effective planning and decision-making

Key features:
- Provides contextually rich, formatted information about domain-specific entities
- Adapts output format based on entity type
- Presents both direct entity information and related elements
- Organizes information in a clear, hierarchical structure
- Automatically identifies entity relationships and presents them systematically
- Tracks loaded entities within the current session for continuity
- Presents information in readable markdown format

Parameters explained:
1. entityName: Required - The name of the entity to retrieve context for
2. entityType: Optional - The type of entity being retrieved (varies by domain)
  - Developer: project, component, task, issue, milestone, decision, feature, technology, documentation, dependency, developer
  - Student: course, assignment, exam, concept, term, resource, note, lecture, project, question, goal, professor
  - Qualitative Research: project, participant, interview, code, theme, memo, researchQuestion, observation, document, codeGroup, quote, literature, finding
  - Quantitative Research: project, dataset, variable, model, hypothesis, statisticalTest, result, analysisScript, visualization, literature, researchQuestion, finding, participant
  - Project Management: project, task, milestone, teamMember, resource, risk, decision, issue, dependency, meeting, document, stakeholder
3. sessionId: Optional - The current session identifier provided by startsession

Domain-specific information returned:
- Developer:
  * Project: Status, components, active features, active tasks, active issues, upcoming milestones, team members, and recent decisions
  * Component: Parent projects, implemented features, technologies used, active issues, documentation, team members, and dependencies
  * Feature: Status, priority, description, requirements, implementing components, and related tasks
  * Task: Project, status, priority, due date, description, assigned developers, related issues, and blocking items
  * Milestone: Status, deadline, description, progress percentage, deadline status, and tasks grouped by completion status
  * Other Entity Types: Observations and relationships within the knowledge graph
  
- Student:
  * Course: Code, status, schedule, location, description, professor information, lectures, assignments, exams, key concepts, and resources
  * Assignment: Course, status, due date, points, time remaining, instructions, related concepts, helpful resources, and notes
  * Exam: Course, date, time remaining, location, format, duration, concepts to study, key lectures, and study resources
  * Concept: Difficulty level, description, related concepts, courses covering this concept, and learning resources
  * Term: Start date, end date, status, courses for the term, and upcoming deadlines
  * Other Entity Types: Observations and relationships within the knowledge graph
  
- Qualitative Research:
  * Project: Status, description, research design, research questions, data collection stats, recent interviews, analysis progress (themes), and findings
  * Participant: Demographic information, interview history, observation records, notable quotes, and research memos
  * Interview: Project affiliation, participant, date, transcript content, applied codes, and notable quotes
  * Code: Definition, status, creation date, code group affiliations, supporting quotes, sources, associated themes, and code co-occurrence data
  * Theme: Description, status, creation date, project affiliation, supporting codes, example quotes, and analytical memos
  * Memo: Topic, date, project affiliation, content, and related entities
  * Research Question: Question text, project affiliation, related findings, themes, and supporting quotes
  * Other Entity Types: Observations and relationships within the knowledge graph
  
- Quantitative Research:
  * Project: Status, description, datasets, hypotheses, statistical tests, models, and key visualizations
  * Dataset: Project affiliation, size, variable count, descriptive statistics, visualizations, and models trained on it
  * Variable: Data type, role, scale, descriptive statistics, normality tests, and correlations with other variables
  * Model: Type, training dataset, creation date, performance metrics, and model parameters
  * Hypothesis: Status, p-value, creation date, associated tests, and project affiliation
  * Statistical Test: Test type, result, p-value, date, variables analyzed, and hypotheses tested
  * Other Entity Types: Basic information and observations
  
- Project Management:
  * Project: Status, description, timeline, budget, goal, tasks, milestones, issues, team members, risks, and task completion rate
  * Task: Project affiliation, status, due date, priority, assignee, description, critical path status, and task dependencies
  * Milestone: Project affiliation, status, date, completion criteria, description, progress percentage, days remaining, required tasks, and blocking tasks
  * Team Member: Role, skills, availability, workload, assigned tasks, projects, upcoming deadlines, and overdue tasks
  * Resource: Type, project affiliation, availability, capacity, cost, usage percentage, assigned tasks, and team members using the resource
  * Other Entity Types: Basic entity information, observations, incoming relations, and outgoing relations

Return information:
- Formatted markdown text with hierarchical structure
- Sections adapted to the specific entity type within each domain
- Related entities shown with their relationships and status information
- Progress metrics and completion statistics where applicable
- Error messages if the entity doesn't exist or can't be retrieved

You should:
- Specify the exact entity name for accurate retrieval
- Provide the entity type when possible for optimally formatted results
- Start with high-level entities (projects, courses) to get a broad overview
- Explore specific entities to understand details and relationships
- After retrieving context, follow up on specific entities of interest
- Use in conjunction with startsession to maintain session tracking
- Remember that this tool only retrieves existing information; use buildcontext to add new entities 
```

--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_buildcontext.txt:
--------------------------------------------------------------------------------

```
A versatile tool for constructing and enhancing the quantitative research knowledge graph by adding new research elements, relationships, and observations.

When to use this tool:
- Creating new research entities (projects, datasets, variables, hypotheses, statistical tests, etc.)
- Establishing relationships between research elements (e.g., connecting variables to datasets, statistical tests to hypotheses)
- Adding observations, properties, or metadata to existing research entities
- Building the research corpus incrementally as data collection and analysis progress
- Organizing and structuring quantitative data within your research framework
- Documenting statistical analyses, models, and their results
- Tracking research questions and linking them to findings
- Creating visualizations and connecting them to data and analyses
- Setting status values for research activities and entities
- Assigning priorities to research tasks and activities
- Defining sequential relationships between research processes

Key features:
- Creates three distinct types of knowledge graph elements: entities, relations, and observations
- Supports specialized quantitative research entity types (projects, datasets, variables, hypotheses, statistical tests, etc.)
- Validates entity and relation types against predefined standards for the quantitative research domain
- Handles batch creation of multiple entities or relations in a single operation
- Returns confirmation with details of created elements
- Ensures proper data typing and structure for the quantitative research knowledge graph
- Enables comprehensive documentation of statistical analysis processes
- Supports status and priority assignment through entity-relation model
- Enables sequential relationships through precedes relation

Parameters explained:
1. type: The type of creation operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The content to add to the knowledge graph (structure varies by type):
  - For "entities": An array of objects, each containing:
    * name: Unique identifier for the entity
    * entityType: One of the valid entity types (project, dataset, variable, hypothesis, statisticalTest, result, analysisScript, visualization, model, literature, researchQuestion, finding, participant, status, priority)
    * observations: Array of strings containing notes or properties about the entity
  - For "relations": An array of objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: The type of relationship between entities (e.g., correlates_with, predicts, tests, analyzes, produces, has_status, has_priority, precedes)
  - For "observations": Either a single object or an array of objects, each containing:
    * entityName: Name of the entity to add observations to
    * contents: Array of strings with new observations to add

Valid entity types:
- project: Overall research study
- dataset: Collection of data used for analysis
- variable: Specific measurable attribute in a dataset
- hypothesis: Formal testable statement
- statisticalTest: Analysis method applied to data
- result: Outcome of statistical analysis
- analysisScript: Code used to perform analysis
- visualization: Visual representation of data
- model: Statistical/mathematical model
- literature: Academic sources
- researchQuestion: Formal questions guiding the study
- finding: Results or conclusions
- participant: Research subjects
- status: Entity status values
- priority: Entity priority values

Valid relation types:
- correlates_with: Statistical correlation between variables
- predicts: Predictive relationship from independent to dependent variable
- tests: Statistical test examines hypothesis
- analyzes: Analysis performed on dataset
- produces: Analysis produces result
- visualizes: Visualization displays data or result
- contains: Hierarchical relationship
- part_of: Entity is part of another entity
- depends_on: Dependency relationship
- supports: Evidence supporting a hypothesis or finding
- contradicts: Evidence contradicting a hypothesis or finding
- derived_from: Entity is derived from another entity
- controls_for: Variable/method controls for confounds
- moderates: Variable moderates a relationship
- mediates: Variable mediates a relationship
- implements: Script implements statistical test/model
- compares: Statistical comparison between groups/variables
- includes: Model includes variables
- validates: Validates a model or result
- cites: References literature
- has_status: Links entity to its status
- has_priority: Links entity to its priority
- precedes: Entity comes before another entity in sequence

Status information:
- Valid status values include: active, completed, pending, abandoned
- Status is assigned through the has_status relation type
- Status helps track progress of research activities

Priority information:
- Valid priority values: high, low
- Priority is assigned through the has_priority relation type
- Priority helps identify critical research tasks

Sequential Process Information:
- The precedes relation establishes logical ordering between research processes
- Sequential relationships document the flow of the research methodology
- Helps maintain proper order in multi-step analysis procedures

Return information:
- JSON response indicating success or failure
- For successful operations:
  * Success flag set to true
  * Details of created elements in the "created" field (for entities/relations) or "added" field (for observations)
- For failed operations:
  * Success flag set to false
  * Error message describing the issue

Error handling:
- Validates entity types against the predefined list for quantitative research
- Validates relation types against acceptable standards
- Returns descriptive error messages for invalid inputs
- Gracefully handles type mismatches and formatting errors

You should:
- Use consistent naming conventions for entities to facilitate relationships and retrieval
- Begin by creating projects and datasets before more specific research elements
- Add detailed observations to entities to enhance context and retrievability
- Create relationships to build a comprehensive network of interconnected research data
- Document statistical methodology thoroughly by connecting tests, variables, and hypotheses
- Add statistical results with appropriate metadata (p-values, effect sizes, confidence intervals)
- Create visualizations and link them to the data they represent
- Use relations to document the flow of analysis from data to findings
- Connect literature to support hypotheses and contextualize findings
- Structure models with clear relationships to the variables they include
- Document analysis scripts with information about their purpose and implementation
- Use has_status relations to track the progress of research activities (active, completed, pending, abandoned)
- Use has_priority relations to indicate important research elements (high, low)
- Use precedes relations to establish sequences in research methodologies 
```

--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_buildcontext.txt:
--------------------------------------------------------------------------------

```
A versatile tool for constructing and enhancing the quantitative research knowledge graph by adding new research elements, relationships, and observations.

When to use this tool:
- Creating new research entities (projects, datasets, variables, hypotheses, statistical tests, etc.)
- Establishing relationships between research elements (e.g., connecting variables to datasets, statistical tests to hypotheses)
- Adding observations, properties, or metadata to existing research entities
- Building the research corpus incrementally as data collection and analysis progress
- Organizing and structuring quantitative data within your research framework
- Documenting statistical analyses, models, and their results
- Tracking research questions and linking them to findings
- Creating visualizations and connecting them to data and analyses
- Setting status values for research activities and entities
- Assigning priorities to research tasks and activities
- Defining sequential relationships between research processes

Key features:
- Creates three distinct types of knowledge graph elements: entities, relations, and observations
- Supports specialized quantitative research entity types (projects, datasets, variables, hypotheses, statistical tests, etc.)
- Validates entity and relation types against predefined standards for the quantitative research domain
- Handles batch creation of multiple entities or relations in a single operation
- Returns confirmation with details of created elements
- Ensures proper data typing and structure for the quantitative research knowledge graph
- Enables comprehensive documentation of statistical analysis processes
- Supports status and priority assignment through entity-relation model
- Enables sequential relationships through precedes relation

Parameters explained:
1. type: The type of creation operation to perform
  - Accepts: "entities", "relations", or "observations"
  - Determines how the data parameter is interpreted
2. data: The content to add to the knowledge graph (structure varies by type):
  - For "entities": An array of objects, each containing:
    * name: Unique identifier for the entity
    * entityType: One of the valid entity types (project, dataset, variable, hypothesis, statisticalTest, result, analysisScript, visualization, model, literature, researchQuestion, finding, participant, status, priority)
    * observations: Array of strings containing notes or properties about the entity
  - For "relations": An array of objects, each containing:
    * from: Name of the source entity
    * to: Name of the target entity
    * relationType: The type of relationship between entities (e.g., correlates_with, predicts, tests, analyzes, produces, has_status, has_priority, precedes)
  - For "observations": Either a single object or an array of objects, each containing:
    * entityName: Name of the entity to add observations to
    * contents: Array of strings with new observations to add

Valid entity types:
- project: Overall research study
- dataset: Collection of data used for analysis
- variable: Specific measurable attribute in a dataset
- hypothesis: Formal testable statement
- statisticalTest: Analysis method applied to data
- result: Outcome of statistical analysis
- analysisScript: Code used to perform analysis
- visualization: Visual representation of data
- model: Statistical/mathematical model
- literature: Academic sources
- researchQuestion: Formal questions guiding the study
- finding: Results or conclusions
- participant: Research subjects
- status: Entity status values
- priority: Entity priority values

Valid relation types:
- correlates_with: Statistical correlation between variables
- predicts: Predictive relationship from independent to dependent variable
- tests: Statistical test examines hypothesis
- analyzes: Analysis performed on dataset
- produces: Analysis produces result
- visualizes: Visualization displays data or result
- contains: Hierarchical relationship
- part_of: Entity is part of another entity
- depends_on: Dependency relationship
- supports: Evidence supporting a hypothesis or finding
- contradicts: Evidence contradicting a hypothesis or finding
- derived_from: Entity is derived from another entity
- controls_for: Variable/method controls for confounds
- moderates: Variable moderates a relationship
- mediates: Variable mediates a relationship
- implements: Script implements statistical test/model
- compares: Statistical comparison between groups/variables
- includes: Model includes variables
- validates: Validates a model or result
- cites: References literature
- has_status: Links entity to its status
- has_priority: Links entity to its priority
- precedes: Entity comes before another entity in sequence

Status information:
- Valid status values include: active, completed, pending, abandoned
- Status is assigned through the has_status relation type
- Status helps track progress of research activities

Priority information:
- Valid priority values: high, low
- Priority is assigned through the has_priority relation type
- Priority helps identify critical research tasks

Sequential Process Information:
- The precedes relation establishes logical ordering between research processes
- Sequential relationships document the flow of the research methodology
- Helps maintain proper order in multi-step analysis procedures

Return information:
- JSON response indicating success or failure
- For successful operations:
  * Success flag set to true
  * Details of created elements in the "created" field (for entities/relations) or "added" field (for observations)
- For failed operations:
  * Success flag set to false
  * Error message describing the issue

Error handling:
- Validates entity types against the predefined list for quantitative research
- Validates relation types against acceptable standards
- Returns descriptive error messages for invalid inputs
- Gracefully handles type mismatches and formatting errors

You should:
- Use consistent naming conventions for entities to facilitate relationships and retrieval
- Begin by creating projects and datasets before more specific research elements
- Add detailed observations to entities to enhance context and retrievability
- Create relationships to build a comprehensive network of interconnected research data
- Document statistical methodology thoroughly by connecting tests, variables, and hypotheses
- Add statistical results with appropriate metadata (p-values, effect sizes, confidence intervals)
- Create visualizations and link them to the data they represent
- Use relations to document the flow of analysis from data to findings
- Connect literature to support hypotheses and contextualize findings
- Structure models with clear relationships to the variables they include
- Document analysis scripts with information about their purpose and implementation
- Use has_status relations to track the progress of research activities (active, completed, pending, abandoned)
- Use has_priority relations to indicate important research elements (high, low)
- Use precedes relations to establish sequences in research methodologies 
```

--------------------------------------------------------------------------------
/main/descriptions/project_endsession.txt:
--------------------------------------------------------------------------------

```
A multi-stage tool for documenting project management sessions, recording achievements, tracking task updates, and creating a structured record of project evolution.

When to use this tool:
- Concluding a project planning or review session
- Documenting decisions made during team meetings
- Recording updates to tasks and their status
- Tracking new tasks created during work sessions
- Documenting changes to project risk assessments
- Updating overall project status information
- Creating a structured record of project activities
- Establishing a formal conclusion to a focused work period
- Building a historical record of project development
- Preserving context for future team members or sessions
- Updating entity status values and tracking progress
- Modifying task priorities as project needs evolve
- Establishing or modifying sequential relationships between tasks

Key features:
- Provides a structured, multi-stage workflow for project session documentation
- Records project decisions and achievements in the knowledge graph
- Captures task status updates and progress information
- Tracks creation of new tasks with descriptions and priorities
- Documents risk updates with impact and probability assessments
- Updates project status information
- Maintains session continuity with unique session IDs
- Supports revision of previous stages when needed
- Offers a comprehensive assembly stage that consolidates all session information
- Manages status progression of project entities via has_status relations
- Tracks priority assignments for tasks via has_priority relations
- Documents sequential task relationships via precedes relations

The endsession tool uses a sequential, multi-stage approach with 7 typical stages:
1. Summary Stage: Records basic session information
2. Achievements Stage: Documents decisions and accomplishments
3. Task Updates Stage: Records changes to existing tasks
4. New Tasks Stage: Documents newly created tasks
5. Status Updates Stage: Records changes to entity status values
6. Project Status Stage: Updates the overall project status
7. Assembly Stage: Consolidates all information and finalizes the session record

Parameters explained:
1. sessionId: Required - Unique identifier for the project session
  - Obtained from the startsession tool
  - Example: "proj_1234567890_abc123"
2. stage: Required - Current stage of the endsession workflow
  - Accepts: "summary", "achievements", "taskUpdates", "newTasks", "statusUpdates", "projectStatus", or "assembly"
  - Each stage has specific data requirements and processing logic
3. stageNumber: Required - The sequence number of the current stage
  - Starts at 1 and typically progresses through the stages
  - Used to track progress through the session documentation workflow
4. totalStages: Required - Total number of stages planned for this workflow
  - Typically 7 for the complete workflow
  - Provides context for the progress within the overall process
5. analysis: Optional - Text analysis or observations for the current stage
  - Descriptive text explaining the work done in this stage
  - Example: "Analyzed progress on the marketing campaign project"
6. stageData: Optional - Stage-specific structured data
  - Structure varies by stage type:
    * summary: { summary: "Session summary text", duration: "3 hours", project: "ProjectName" }
    * achievements: { achievements: ["Decision 1", "Accomplishment 2"] }
    * taskUpdates: { updates: [{ name: "Task1", status: "active", progress: "50%" }] }
    * newTasks: { tasks: [{ name: "New Task", description: "Details", priority: "high", precedes: "Task3" }] }
    * statusUpdates: { statusUpdates: [{ entityName: "Task1", newStatus: "complete", note: "Finished implementation" }, { entityName: "Risk1", newStatus: "inactive", note: "Risk mitigated" }] }
    * projectStatus: { projectStatus: "active", projectObservation: "Good progress", priorityUpdates: [{ entityName: "Task2", priority: "high", note: "Critical for launch" }], sequenceUpdates: [{ before: "Task1", after: "Task4", note: "Rearranged sequence to optimize workflow" }] }
    * assembly: No stageData needed - automatically assembled from previous stages
7. nextStageNeeded: Required - Whether additional stages are needed after this one
  - Boolean value (true/false)
  - Set to false on the final stage to complete the session
8. isRevision: Optional - Whether this is revising a previous stage
  - Boolean value (true/false)
  - Default: false
9. revisesStage: Optional - If revising, which stage number is being revised
  - Required when isRevision is true
  - Indicates which previous stage is being updated

Status and Priority Management:
- The statusUpdates stage allows for batch updates to entity status values
- Valid status values include: inactive, active, complete
- Priority assignments (high, low) can be modified in the projectStatus stage
- Status changes are implemented through has_status relations
- Priority changes are implemented through has_priority relations
- Status and priority changes are tracked to maintain project progress history

Sequential Task Management:
- The projectStatus stage allows for defining or modifying sequential relationships
- The precedes relation is used to establish logical ordering between tasks
- New tasks can specify which tasks they precede or follow
- Sequential updates help maintain a coherent project workflow
- Task sequences can be visualized through the loadcontext tool

When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool performs these actions:
1. Records the session completion in persistent storage
2. Creates a summary of all documented information
3. Updates the project status in the knowledge graph
4. Links all achievements, task updates, and risk information
5. Updates status, priority, and sequential relationships for relevant entities

Return information:
- JSON response with the following structure when stages are in progress:
  * success: Boolean indicating whether the operation succeeded
  * stageCompleted: The stage that was just completed
  * nextStageNeeded: Whether more stages are required
  * stageResult: The processed result of the current stage
- Formatted markdown text summary when the session is completed, including:
  * Session date and project name
  * Decisions documented
  * Task updates
  * Status changes
  * Priority modifications
  * Task sequencing changes
  * Project status
  * New tasks added
  * Risk updates
  * Session summary

You should:
- Complete all stages in order for comprehensive session documentation
- Provide specific details in each stage for accurate project documentation
- Specify task updates with clear status information using valid values (inactive, active, complete)
- Include priority levels (high, low) when adding new tasks or updating priorities
- Document all key decisions made during the session as achievements
- Update entity status using has_status relations with valid status values
- Define task sequences using precedes relations to establish workflow
- If making a revision, specify which stage is being revised
- Only mark nextStageNeeded as false on the final assembly stage
- Review the final summary message to confirm all session details were recorded properly
- Use the unique session ID consistently across all stages 
```

--------------------------------------------------------------------------------
/project/project_endsession.txt:
--------------------------------------------------------------------------------

```
A multi-stage tool for documenting project management sessions, recording achievements, tracking task updates, and creating a structured record of project evolution.

When to use this tool:
- Concluding a project planning or review session
- Documenting decisions made during team meetings
- Recording updates to tasks and their status
- Tracking new tasks created during work sessions
- Documenting changes to project risk assessments
- Updating overall project status information
- Creating a structured record of project activities
- Establishing a formal conclusion to a focused work period
- Building a historical record of project development
- Preserving context for future team members or sessions
- Updating entity status values and tracking progress
- Modifying task priorities as project needs evolve
- Establishing or modifying sequential relationships between tasks

Key features:
- Provides a structured, multi-stage workflow for project session documentation
- Records project decisions and achievements in the knowledge graph
- Captures task status updates and progress information
- Tracks creation of new tasks with descriptions and priorities
- Documents risk updates with impact and probability assessments
- Updates project status information
- Maintains session continuity with unique session IDs
- Supports revision of previous stages when needed
- Offers a comprehensive assembly stage that consolidates all session information
- Manages status progression of project entities via has_status relations
- Tracks priority assignments for tasks via has_priority relations
- Documents sequential task relationships via precedes relations

The endsession tool uses a sequential, multi-stage approach with 7 typical stages:
1. Summary Stage: Records basic session information
2. Achievements Stage: Documents decisions and accomplishments
3. Task Updates Stage: Records changes to existing tasks
4. New Tasks Stage: Documents newly created tasks
5. Status Updates Stage: Records changes to entity status values
6. Project Status Stage: Updates the overall project status
7. Assembly Stage: Consolidates all information and finalizes the session record

Parameters explained:
1. sessionId: Required - Unique identifier for the project session
  - Obtained from the startsession tool
  - Example: "proj_1234567890_abc123"
2. stage: Required - Current stage of the endsession workflow
  - Accepts: "summary", "achievements", "taskUpdates", "newTasks", "statusUpdates", "projectStatus", or "assembly"
  - Each stage has specific data requirements and processing logic
3. stageNumber: Required - The sequence number of the current stage
  - Starts at 1 and typically progresses through the stages
  - Used to track progress through the session documentation workflow
4. totalStages: Required - Total number of stages planned for this workflow
  - Typically 7 for the complete workflow
  - Provides context for the progress within the overall process
5. analysis: Optional - Text analysis or observations for the current stage
  - Descriptive text explaining the work done in this stage
  - Example: "Analyzed progress on the marketing campaign project"
6. stageData: Optional - Stage-specific structured data
  - Structure varies by stage type:
    * summary: { summary: "Session summary text", duration: "3 hours", project: "ProjectName" }
    * achievements: { achievements: ["Decision 1", "Accomplishment 2"] }
    * taskUpdates: { updates: [{ name: "Task1", status: "active", progress: "50%" }] }
    * newTasks: { tasks: [{ name: "New Task", description: "Details", priority: "high", precedes: "Task3" }] }
    * statusUpdates: { statusUpdates: [{ entityName: "Task1", newStatus: "complete", note: "Finished implementation" }, { entityName: "Risk1", newStatus: "inactive", note: "Risk mitigated" }] }
    * projectStatus: { projectStatus: "active", projectObservation: "Good progress", priorityUpdates: [{ entityName: "Task2", priority: "high", note: "Critical for launch" }], sequenceUpdates: [{ before: "Task1", after: "Task4", note: "Rearranged sequence to optimize workflow" }] }
    * assembly: No stageData needed - automatically assembled from previous stages
7. nextStageNeeded: Required - Whether additional stages are needed after this one
  - Boolean value (true/false)
  - Set to false on the final stage to complete the session
8. isRevision: Optional - Whether this is revising a previous stage
  - Boolean value (true/false)
  - Default: false
9. revisesStage: Optional - If revising, which stage number is being revised
  - Required when isRevision is true
  - Indicates which previous stage is being updated

Status and Priority Management:
- The statusUpdates stage allows for batch updates to entity status values
- Valid status values include: inactive, active, complete
- Priority assignments (high, low) can be modified in the projectStatus stage
- Status changes are implemented through has_status relations
- Priority changes are implemented through has_priority relations
- Status and priority changes are tracked to maintain project progress history

Sequential Task Management:
- The projectStatus stage allows for defining or modifying sequential relationships
- The precedes relation is used to establish logical ordering between tasks
- New tasks can specify which tasks they precede or follow
- Sequential updates help maintain a coherent project workflow
- Task sequences can be visualized through the loadcontext tool

When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool performs these actions:
1. Records the session completion in persistent storage
2. Creates a summary of all documented information
3. Updates the project status in the knowledge graph
4. Links all achievements, task updates, and risk information
5. Updates status, priority, and sequential relationships for relevant entities

Return information:
- JSON response with the following structure when stages are in progress:
  * success: Boolean indicating whether the operation succeeded
  * stageCompleted: The stage that was just completed
  * nextStageNeeded: Whether more stages are required
  * stageResult: The processed result of the current stage
- Formatted markdown text summary when the session is completed, including:
  * Session date and project name
  * Decisions documented
  * Task updates
  * Status changes
  * Priority modifications
  * Task sequencing changes
  * Project status
  * New tasks added
  * Risk updates
  * Session summary

You should:
- Complete all stages in order for comprehensive session documentation
- Provide specific details in each stage for accurate project documentation
- Specify task updates with clear status information using valid values (inactive, active, complete)
- Include priority levels (high, low) when adding new tasks or updating priorities
- Document all key decisions made during the session as achievements
- Update entity status using has_status relations with valid status values
- Define task sequences using precedes relations to establish workflow
- If making a revision, specify which stage is being revised
- Only mark nextStageNeeded as false on the final assembly stage
- Review the final summary message to confirm all session details were recorded properly
- Use the unique session ID consistently across all stages 
```

--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_advancedcontext.txt:
--------------------------------------------------------------------------------

```
A sophisticated query tool for exploring, analyzing, and retrieving complex information from the qualitative research knowledge graph.

When to use this tool:
- Retrieving a comprehensive view of your entire research knowledge structure
- Searching for specific research entities across your qualitative data corpus
- Getting detailed information about particular research projects, participants, or analytical elements
- Exploring relationships between research components (codes, themes, quotes)
- Analyzing code frequencies and distributions across your data
- Retrieving interview or observation transcripts for analysis
- Accessing memo content for reflection on the research process
- Generating codebooks or analytical frameworks for documentation
- Finding connections between different aspects of your research
- Creating research reports or summaries from your data
- Exploring thematic structures and their evidentiary basis
- Identifying entities by status to track research progress
- Filtering tasks by priority to manage research workflow
- Analyzing sequential relationships between research processes

Key features:
- Offers specialized operations for querying different aspects of qualitative research data
- Retrieves complete or filtered views of the research knowledge graph
- Provides flexible search capabilities across all research entities
- Supports detailed exploration of specific entities by name
- Generates specialized views for projects, participants, codes, and themes
- Retrieves content and metadata for interviews, transcripts, and memos
- Creates codebooks and thematic frameworks for documentation
- Identifies related entities to explore connections within your research
- Returns consistently structured JSON responses for easy processing
- Facilitates depth and breadth exploration of qualitative data
- Supports status-based filtering of research entities
- Enables priority-based task management
- Provides sequential process analysis capabilities

Parameters explained:
1. type: The type of query operation to perform
  - Accepts one of the specialized operations: "graph", "search", "nodes", "project", "participant", "codes", "themes", "transcript", "memo", "analysis", "codebook", "related", "status", "priority", "sequence"
  - Determines how the params parameter is interpreted 
2. params: Operation-specific parameters (structure varies by type):
  - For "graph": No parameters needed (retrieves the full research knowledge graph)
  - For "search": Object containing:
    * query: Search string to find entities (supports entity type filters)
  - For "nodes": Object containing:
    * names: Array of entity names to retrieve
  - For "project": Object containing:
    * projectName: Name of the project to retrieve details for
  - For "participant": Object containing:
    * participantName: Name of the participant to retrieve profile for
  - For "codes": Object containing:
    * projectName: (Optional) Project name to filter codes by
  - For "themes": Object containing:
    * projectName: (Optional) Project name to filter themes by
  - For "transcript": Object containing:
    * participantName: Participant associated with the transcript
    * interviewId: (Optional) Specific interview identifier
  - For "memo": Object containing:
    * memoName: Name of the memo to retrieve
  - For "analysis": Object containing:
    * projectName: Project name to retrieve analysis artifacts for
  - For "codebook": Object containing:
    * projectName: Project name to generate codebook for
  - For "related": Object containing:
    * entityName: Name of the entity to find related entities for
  - For "status": Object containing:
    * statusValue: The status value to filter by (e.g., "planning", "data_collection", "analysis")
  - For "priority": Object containing:
    * priorityValue: The priority value to filter by (e.g., "high", "low")
  - For "sequence": Object containing:
    * entityName: Name of the entity to find sequential relationships for

Operation details:
- graph: Returns the complete research knowledge graph with all entities and relationships
- search: Performs text-based search across entity names and observations
- nodes: Retrieves detailed information about specific entities by name
- project: Returns comprehensive project information including participants, interviews, codes, and findings
- participant: Generates a participant profile with demographic information and associated data
- codes: Lists all codes, optionally filtered by project, with reference counts and descriptions
- themes: Returns all themes, optionally filtered by project, with associated codes and descriptions
- transcript: Retrieves interview transcript content for specific participant/interview combinations
- memo: Returns the full content of an analytical memo with metadata
- analysis: Collects all analysis artifacts (codes, themes, memos) for a specific project
- codebook: Generates a structured codebook for a project with code definitions and examples
- related: Identifies all entities directly connected to a specific entity
- status: Retrieves all entities with a specific status value
- priority: Retrieves all entities with a specific priority value
- sequence: Identifies sequential relationships for a specific entity showing preceding and following entities

Status and Priority Information:
- Status queries return entities organized by their current research stage
- Priority queries help identify critical research tasks and elements
- Status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Priority values include: high, low

Sequential Process Information:
- Sequence queries identify entities that come before or after in a research process
- Sequential relationships help visualize the research workflow
- The sequence operation shows both incoming and outgoing precedes relations

Return information:
- JSON response with a consistent structure:
  - success: Boolean indicating whether the operation succeeded
  - Additional fields depend on the operation type:
    * graph: Complete knowledge graph
    * results: For search operations
    * nodes: For specific entity retrieval
    * project/participant/etc.: For specialized views
    * status/priority: Lists of entities with specified status/priority values
    * sequence: Preceding and following entities in research processes
- Error information when operations fail

You should:
- Start with broad queries ("graph", "search") to explore your research corpus
- Use specific entity queries ("nodes", "project", "participant") for detailed information
- Combine search and related queries to discover connections in your data
- Generate codebooks and project overviews for documentation and reporting
- Use transcript retrieval to access primary data when needed
- Explore thematic structures through themes and related entity queries
- Review memos to track your analytical process over time
- Filter code and theme queries by project for more focused results
- Use search with entity type filters to find specific types of research elements
- Use status queries to identify all entities at a particular research stage
- Use priority queries to focus on high-priority research tasks
- Use sequence queries to understand process flows in your research methodology 
```

--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_advancedcontext.txt:
--------------------------------------------------------------------------------

```
A sophisticated query tool for exploring, analyzing, and retrieving complex information from the qualitative research knowledge graph.

When to use this tool:
- Retrieving a comprehensive view of your entire research knowledge structure
- Searching for specific research entities across your qualitative data corpus
- Getting detailed information about particular research projects, participants, or analytical elements
- Exploring relationships between research components (codes, themes, quotes)
- Analyzing code frequencies and distributions across your data
- Retrieving interview or observation transcripts for analysis
- Accessing memo content for reflection on the research process
- Generating codebooks or analytical frameworks for documentation
- Finding connections between different aspects of your research
- Creating research reports or summaries from your data
- Exploring thematic structures and their evidentiary basis
- Identifying entities by status to track research progress
- Filtering tasks by priority to manage research workflow
- Analyzing sequential relationships between research processes

Key features:
- Offers specialized operations for querying different aspects of qualitative research data
- Retrieves complete or filtered views of the research knowledge graph
- Provides flexible search capabilities across all research entities
- Supports detailed exploration of specific entities by name
- Generates specialized views for projects, participants, codes, and themes
- Retrieves content and metadata for interviews, transcripts, and memos
- Creates codebooks and thematic frameworks for documentation
- Identifies related entities to explore connections within your research
- Returns consistently structured JSON responses for easy processing
- Facilitates depth and breadth exploration of qualitative data
- Supports status-based filtering of research entities
- Enables priority-based task management
- Provides sequential process analysis capabilities

Parameters explained:
1. type: The type of query operation to perform
  - Accepts one of the specialized operations: "graph", "search", "nodes", "project", "participant", "codes", "themes", "transcript", "memo", "analysis", "codebook", "related", "status", "priority", "sequence"
  - Determines how the params parameter is interpreted 
2. params: Operation-specific parameters (structure varies by type):
  - For "graph": No parameters needed (retrieves the full research knowledge graph)
  - For "search": Object containing:
    * query: Search string to find entities (supports entity type filters)
  - For "nodes": Object containing:
    * names: Array of entity names to retrieve
  - For "project": Object containing:
    * projectName: Name of the project to retrieve details for
  - For "participant": Object containing:
    * participantName: Name of the participant to retrieve profile for
  - For "codes": Object containing:
    * projectName: (Optional) Project name to filter codes by
  - For "themes": Object containing:
    * projectName: (Optional) Project name to filter themes by
  - For "transcript": Object containing:
    * participantName: Participant associated with the transcript
    * interviewId: (Optional) Specific interview identifier
  - For "memo": Object containing:
    * memoName: Name of the memo to retrieve
  - For "analysis": Object containing:
    * projectName: Project name to retrieve analysis artifacts for
  - For "codebook": Object containing:
    * projectName: Project name to generate codebook for
  - For "related": Object containing:
    * entityName: Name of the entity to find related entities for
  - For "status": Object containing:
    * statusValue: The status value to filter by (e.g., "planning", "data_collection", "analysis")
  - For "priority": Object containing:
    * priorityValue: The priority value to filter by (e.g., "high", "low")
  - For "sequence": Object containing:
    * entityName: Name of the entity to find sequential relationships for

Operation details:
- graph: Returns the complete research knowledge graph with all entities and relationships
- search: Performs text-based search across entity names and observations
- nodes: Retrieves detailed information about specific entities by name
- project: Returns comprehensive project information including participants, interviews, codes, and findings
- participant: Generates a participant profile with demographic information and associated data
- codes: Lists all codes, optionally filtered by project, with reference counts and descriptions
- themes: Returns all themes, optionally filtered by project, with associated codes and descriptions
- transcript: Retrieves interview transcript content for specific participant/interview combinations
- memo: Returns the full content of an analytical memo with metadata
- analysis: Collects all analysis artifacts (codes, themes, memos) for a specific project
- codebook: Generates a structured codebook for a project with code definitions and examples
- related: Identifies all entities directly connected to a specific entity
- status: Retrieves all entities with a specific status value
- priority: Retrieves all entities with a specific priority value
- sequence: Identifies sequential relationships for a specific entity showing preceding and following entities

Status and Priority Information:
- Status queries return entities organized by their current research stage
- Priority queries help identify critical research tasks and elements
- Status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Priority values include: high, low

Sequential Process Information:
- Sequence queries identify entities that come before or after in a research process
- Sequential relationships help visualize the research workflow
- The sequence operation shows both incoming and outgoing precedes relations

Return information:
- JSON response with a consistent structure:
  - success: Boolean indicating whether the operation succeeded
  - Additional fields depend on the operation type:
    * graph: Complete knowledge graph
    * results: For search operations
    * nodes: For specific entity retrieval
    * project/participant/etc.: For specialized views
    * status/priority: Lists of entities with specified status/priority values
    * sequence: Preceding and following entities in research processes
- Error information when operations fail

You should:
- Start with broad queries ("graph", "search") to explore your research corpus
- Use specific entity queries ("nodes", "project", "participant") for detailed information
- Combine search and related queries to discover connections in your data
- Generate codebooks and project overviews for documentation and reporting
- Use transcript retrieval to access primary data when needed
- Explore thematic structures through themes and related entity queries
- Review memos to track your analytical process over time
- Filter code and theme queries by project for more focused results
- Use search with entity type filters to find specific types of research elements
- Use status queries to identify all entities at a particular research stage
- Use priority queries to focus on high-priority research tasks
- Use sequence queries to understand process flows in your research methodology 
```

--------------------------------------------------------------------------------
/main/descriptions/project_advancedcontext.txt:
--------------------------------------------------------------------------------

```
A sophisticated query tool for exploring, analyzing, and retrieving complex information from the project management knowledge graph.

When to use this tool:
- Retrieving a comprehensive view of your entire project management structure
- Searching for specific project entities across your initiatives
- Getting detailed information about particular projects or project elements
- Exploring task dependencies and their critical paths
- Analyzing team member assignments and workload
- Tracking milestone progress and completion status
- Examining project timelines and schedules
- Assessing resource allocation across projects
- Identifying and monitoring project risks
- Finding connections between related projects
- Reviewing decision logs and project governance
- Evaluating overall project health and status
- Filtering entities by status values (inactive, active, complete)
- Finding high-priority tasks and activities
- Analyzing sequential relationships between tasks

Key features:
- Offers specialized operations for querying different aspects of project management data
- Retrieves complete or filtered views of the project knowledge graph
- Provides flexible search capabilities across all project entities
- Supports detailed exploration of specific entities by name
- Generates comprehensive project overviews with related elements
- Maps task dependencies to identify critical paths
- Tracks team member assignments and responsibilities
- Monitors milestone progress with completion metrics
- Creates project timelines with key dates and dependencies
- Manages resource allocation across project activities
- Identifies and prioritizes project risks
- Finds relationships between projects for portfolio management
- Records and retrieves decision logs for governance
- Assesses project health with key performance indicators
- Filters entities by status via has_status relations
- Identifies high-priority items via has_priority relations
- Analyzes task sequencing through precedes relations

Parameters explained:
1. type: The type of query operation to perform
  - Accepts one of the specialized operations: "graph", "search", "nodes", "project", "dependencies", "assignments", "milestones", "timeline", "resources", "risks", "related", "decisions", "health", "status", "priority", "sequence"
  - Determines how the params parameter is interpreted
2. params: Operation-specific parameters (structure varies by type):
  - For "graph": No parameters needed (retrieves the full project knowledge graph)
  - For "search": Object containing:
    * query: Search string to find entities (supports entity type filters)
  - For "nodes": Object containing:
    * names: Array of entity names to retrieve
  - For "project": Object containing:
    * projectName: Name of the project to retrieve details for
  - For "dependencies": Object containing:
    * taskName: Name of the task to analyze dependencies for
    * depth: (Optional) How many levels of dependencies to retrieve (default: 2)
  - For "assignments": Object containing:
    * teamMemberName: Name of the team member to retrieve assignments for
  - For "milestones": Object containing:
    * projectName: Project name to retrieve milestones for
    * milestoneName: (Optional) Specific milestone to retrieve details for
  - For "timeline": Object containing:
    * projectName: Project name to generate timeline for
  - For "resources": Object containing:
    * projectName: Project name to analyze resource allocation for
    * resourceName: (Optional) Specific resource to analyze allocation for
  - For "risks": Object containing:
    * projectName: Project name to retrieve risks for
  - For "related": Object containing:
    * projectName: Project name to find related projects for
    * depth: (Optional) Depth of project relationships to explore (default: 1)
  - For "decisions": Object containing:
    * projectName: Project name to retrieve decision log for
  - For "health": Object containing:
    * projectName: Project name to assess health for
  - For "status": Object containing:
    * statusValue: The status value to filter by (e.g., "inactive", "active", "complete")
  - For "priority": Object containing:
    * priorityValue: The priority value to filter by (e.g., "high", "low")
  - For "sequence": Object containing:
    * taskName: Name of the task to analyze sequential relationships for

Operation details:
- graph: Returns the complete project knowledge graph with all entities and relationships
- search: Performs text-based search across entity names and observations
- nodes: Retrieves detailed information about specific entities by name
- project: Returns comprehensive project information including tasks, milestones, and team members
- dependencies: Maps task dependencies to identify critical paths and bottlenecks
- assignments: Lists all assignments for a specific team member with workload information
- milestones: Tracks milestone progress with completion status and metrics
- timeline: Generates a project timeline with key dates, dependencies, and current status
- resources: Analyzes resource allocation across project activities
- risks: Identifies and prioritizes project risks with mitigation strategies
- related: Finds connections between projects for portfolio management
- decisions: Retrieves decision log for project governance and audit
- health: Assesses project health with key performance indicators and metrics
- status: Retrieves all entities with a specific status value (inactive, active, complete)
- priority: Retrieves all entities with a specific priority value (high, low)
- sequence: Identifies sequential relationships for tasks, showing preceding and following tasks

Status and Priority Information:
- Status queries return entities organized by their current state in the project lifecycle
- Priority queries help identify critical project tasks and elements
- Status values include: inactive, active, complete
- Priority values include: high, low
- Status and priority are assigned through has_status and has_priority relations

Sequential Task Information:
- Sequence queries identify tasks that come before or after in a project workflow
- Sequential relationships help visualize the project workflow and dependencies
- The sequence operation shows both incoming and outgoing precedes relations
- Task sequences are critical for project planning and critical path identification

Return information:
- success: Boolean indicating whether the operation succeeded
- Additional fields depend on the operation type:
  * graph: Complete knowledge graph
  * results: For search operations
  * nodes: For specific entity retrieval
  * project/dependencies/assignments/etc.: For specialized views
  * status/priority: Lists of entities with specified status/priority values
  * sequence: Preceding and following tasks in project workflows

You should:
- Start with broad queries ("graph", "search") to explore your project portfolio
- Use specific entity queries ("nodes", "project") for detailed information
- Map task dependencies to identify critical paths and bottlenecks
- Track team member assignments to manage workload and availability
- Monitor milestone progress to ensure project timeline adherence
- Generate project timelines for planning and tracking purposes
- Analyze resource allocation to optimize utilization
- Identify and prioritize project risks for proactive management
- Find relationships between projects for portfolio-level insights
- Review decision logs for governance and accountability
- Assess project health regularly with the health operation
- Use status queries to filter entities by their current state
- Use priority queries to focus on high-priority items
- Use sequence queries to understand task workflows and dependencies
- Combine multiple operations to build comprehensive project dashboards 
```

--------------------------------------------------------------------------------
/project/project_advancedcontext.txt:
--------------------------------------------------------------------------------

```
A sophisticated query tool for exploring, analyzing, and retrieving complex information from the project management knowledge graph.

When to use this tool:
- Retrieving a comprehensive view of your entire project management structure
- Searching for specific project entities across your initiatives
- Getting detailed information about particular projects or project elements
- Exploring task dependencies and their critical paths
- Analyzing team member assignments and workload
- Tracking milestone progress and completion status
- Examining project timelines and schedules
- Assessing resource allocation across projects
- Identifying and monitoring project risks
- Finding connections between related projects
- Reviewing decision logs and project governance
- Evaluating overall project health and status
- Filtering entities by status values (inactive, active, complete)
- Finding high-priority tasks and activities
- Analyzing sequential relationships between tasks

Key features:
- Offers specialized operations for querying different aspects of project management data
- Retrieves complete or filtered views of the project knowledge graph
- Provides flexible search capabilities across all project entities
- Supports detailed exploration of specific entities by name
- Generates comprehensive project overviews with related elements
- Maps task dependencies to identify critical paths
- Tracks team member assignments and responsibilities
- Monitors milestone progress with completion metrics
- Creates project timelines with key dates and dependencies
- Manages resource allocation across project activities
- Identifies and prioritizes project risks
- Finds relationships between projects for portfolio management
- Records and retrieves decision logs for governance
- Assesses project health with key performance indicators
- Filters entities by status via has_status relations
- Identifies high-priority items via has_priority relations
- Analyzes task sequencing through precedes relations

Parameters explained:
1. type: The type of query operation to perform
  - Accepts one of the specialized operations: "graph", "search", "nodes", "project", "dependencies", "assignments", "milestones", "timeline", "resources", "risks", "related", "decisions", "health", "status", "priority", "sequence"
  - Determines how the params parameter is interpreted
2. params: Operation-specific parameters (structure varies by type):
  - For "graph": No parameters needed (retrieves the full project knowledge graph)
  - For "search": Object containing:
    * query: Search string to find entities (supports entity type filters)
  - For "nodes": Object containing:
    * names: Array of entity names to retrieve
  - For "project": Object containing:
    * projectName: Name of the project to retrieve details for
  - For "dependencies": Object containing:
    * taskName: Name of the task to analyze dependencies for
    * depth: (Optional) How many levels of dependencies to retrieve (default: 2)
  - For "assignments": Object containing:
    * teamMemberName: Name of the team member to retrieve assignments for
  - For "milestones": Object containing:
    * projectName: Project name to retrieve milestones for
    * milestoneName: (Optional) Specific milestone to retrieve details for
  - For "timeline": Object containing:
    * projectName: Project name to generate timeline for
  - For "resources": Object containing:
    * projectName: Project name to analyze resource allocation for
    * resourceName: (Optional) Specific resource to analyze allocation for
  - For "risks": Object containing:
    * projectName: Project name to retrieve risks for
  - For "related": Object containing:
    * projectName: Project name to find related projects for
    * depth: (Optional) Depth of project relationships to explore (default: 1)
  - For "decisions": Object containing:
    * projectName: Project name to retrieve decision log for
  - For "health": Object containing:
    * projectName: Project name to assess health for
  - For "status": Object containing:
    * statusValue: The status value to filter by (e.g., "inactive", "active", "complete")
  - For "priority": Object containing:
    * priorityValue: The priority value to filter by (e.g., "high", "low")
  - For "sequence": Object containing:
    * taskName: Name of the task to analyze sequential relationships for

Operation details:
- graph: Returns the complete project knowledge graph with all entities and relationships
- search: Performs text-based search across entity names and observations
- nodes: Retrieves detailed information about specific entities by name
- project: Returns comprehensive project information including tasks, milestones, and team members
- dependencies: Maps task dependencies to identify critical paths and bottlenecks
- assignments: Lists all assignments for a specific team member with workload information
- milestones: Tracks milestone progress with completion status and metrics
- timeline: Generates a project timeline with key dates, dependencies, and current status
- resources: Analyzes resource allocation across project activities
- risks: Identifies and prioritizes project risks with mitigation strategies
- related: Finds connections between projects for portfolio management
- decisions: Retrieves decision log for project governance and audit
- health: Assesses project health with key performance indicators and metrics
- status: Retrieves all entities with a specific status value (inactive, active, complete)
- priority: Retrieves all entities with a specific priority value (high, low)
- sequence: Identifies sequential relationships for tasks, showing preceding and following tasks

Status and Priority Information:
- Status queries return entities organized by their current state in the project lifecycle
- Priority queries help identify critical project tasks and elements
- Status values include: inactive, active, complete
- Priority values include: high, low
- Status and priority are assigned through has_status and has_priority relations

Sequential Task Information:
- Sequence queries identify tasks that come before or after in a project workflow
- Sequential relationships help visualize the project workflow and dependencies
- The sequence operation shows both incoming and outgoing precedes relations
- Task sequences are critical for project planning and critical path identification

Return information:
- success: Boolean indicating whether the operation succeeded
- Additional fields depend on the operation type:
  * graph: Complete knowledge graph
  * results: For search operations
  * nodes: For specific entity retrieval
  * project/dependencies/assignments/etc.: For specialized views
  * status/priority: Lists of entities with specified status/priority values
  * sequence: Preceding and following tasks in project workflows

You should:
- Start with broad queries ("graph", "search") to explore your project portfolio
- Use specific entity queries ("nodes", "project") for detailed information
- Map task dependencies to identify critical paths and bottlenecks
- Track team member assignments to manage workload and availability
- Monitor milestone progress to ensure project timeline adherence
- Generate project timelines for planning and tracking purposes
- Analyze resource allocation to optimize utilization
- Identify and prioritize project risks for proactive management
- Find relationships between projects for portfolio-level insights
- Review decision logs for governance and accountability
- Assess project health regularly with the health operation
- Use status queries to filter entities by their current state
- Use priority queries to focus on high-priority items
- Use sequence queries to understand task workflows and dependencies
- Combine multiple operations to build comprehensive project dashboards 
```

--------------------------------------------------------------------------------
/main/descriptions/qualitativeresearch_endsession.txt:
--------------------------------------------------------------------------------

```
A multi-stage tool for documenting qualitative research sessions, recording analysis progress, tracking coding activities, and creating a structured record of research evolution.

When to use this tool:
- Concluding a qualitative research analysis session
- Documenting interview data collection activities
- Recording newly created analytical memos
- Tracking coding activities and code applications
- Documenting emerging themes and theoretical constructs
- Updating overall project status and progress
- Creating a structured record of research activities
- Establishing a formal conclusion to a focused research period
- Building a historical record of project development
- Documenting observations and insights from a research session
- Updating status values for research activities and entities
- Assigning or modifying priority levels for research tasks
- Establishing or modifying sequential relationships between research processes

Key features:
- Provides a structured, multi-stage workflow for research session documentation
- Records interview data collection in the knowledge graph
- Captures newly created analytical memos
- Tracks coding activities across data sources
- Documents emerging themes and their connections to codes
- Updates project status information
- Maintains session continuity with unique session IDs
- Supports revision of previous stages when needed
- Offers a comprehensive assembly stage that consolidates all session information
- Organizes qualitative research activity into a coherent narrative
- Manages status progression of research activities
- Tracks priority assignments for research tasks
- Documents sequential relationships between research processes

The endsession tool uses a sequential, multi-stage approach with typically 8 stages:
1. Summary Stage: Records basic session information
2. Interview Data Stage: Documents new interviews conducted
3. Memos Stage: Records new analytical memos created
4. Coding Activity Stage: Documents code applications and coding work
5. Themes Stage: Records emerging themes and theoretical insights
6. Status Updates Stage: Records changes to entity status values
7. Project Status Stage: Updates the overall project status
8. Assembly Stage: Consolidates all information and finalizes the session record

Parameters explained:
1. sessionId: Required - Unique identifier for the research session
  - Obtained from the startsession tool
  - Example: "qual_1234567890_abc123"
2. stage: Required - Current stage of the endsession workflow
  - Accepts: "summary", "interviewData", "memos", "codingActivity", "themes", "statusUpdates", "projectStatus", or "assembly"
  - Each stage has specific data requirements and processing logic
3. stageNumber: Required - The sequence number of the current stage
  - Starts at 1 and typically progresses through the stages
  - Used to track progress through the session documentation workflow
4. totalStages: Required - Total number of stages planned for this workflow
  - Typically 8 for the complete workflow
  - Provides context for the progress within the overall process
5. analysis: Optional - Text analysis or observations for the current stage
  - Descriptive text explaining the work done in this stage
  - Example: "Analyzed interview transcripts and identified recurring patterns"
6. stageData: Optional - Stage-specific structured data
  - Structure varies by stage type:
    * summary: { summary: "Session summary text", duration: "3 hours", project: "ProjectName" }
    * interviewData: { interviews: [{ participant: "P001", notes: "Interview notes", date: "2023-04-15" }] }
    * memos: { memos: [{ topic: "Emerging patterns", content: "Detailed memo text" }] }
    * codingActivity: { codes: [{ code: "coping_strategy", dataItem: "Interview_P001", note: "Applied to discussion of stress management" }] }
    * themes: { themes: [{ name: "Social Support", codes: ["family_support", "peer_networks"], description: "The role of social connections in coping" }] }
    * statusUpdates: { statusUpdates: [{ entityName: "Interview_P003", newStatus: "transcribed", note: "Completed transcription" }, { entityName: "Code_Resilience", newStatus: "established", note: "Well-supported by data" }] }
    * projectStatus: { projectStatus: "data_analysis", projectObservation: "Making good progress on initial coding", priorityUpdates: [{ entityName: "Transcribe_P004", priority: "high", note: "Critical for thematic development" }], sequenceUpdates: [{ before: "Coding_Phase1", after: "Theme_Development", note: "Ready to move from coding to theme creation" }] }
    * assembly: No stageData needed - automatically assembled from previous stages
7. nextStageNeeded: Required - Whether additional stages are needed after this one
  - Boolean value (true/false)
  - Set to false on the final stage to complete the session
8. isRevision: Optional - Whether this is revising a previous stage
  - Boolean value (true/false)
  - Default: false
9. revisesStage: Optional - If revising, which stage number is being revised
  - Required when isRevision is true
  - Indicates which previous stage is being updated

Status and Priority Management:
- The statusUpdates stage allows for batch updates to entity status values
- Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Priority assignments (high, low) can be modified in the projectStatus stage
- Status changes are tracked to maintain a history of research progression
- Priority changes help reallocate focus as research needs evolve

Sequential Process Management:
- The projectStatus stage allows for defining or modifying sequential relationships
- The precedes relation is used to establish logical ordering between research activities
- Sequential updates help maintain a coherent research workflow
- Process sequences can be visualized through the loadcontext tool

When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool:
1. Records the session completion in persistent storage
2. Creates a formatted summary of all session information
3. Updates the status, priority, and sequential relationships for relevant entities
4. Preserves the record of research activities for future reference

Return information:
- JSON response with the following structure:
  * success: Boolean indicating whether the operation succeeded
  * stageCompleted: The stage that was just completed
  * nextStageNeeded: Whether more stages are required
  * stageResult: The processed result of the current stage
  * endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
  * sessionRecorded: (Final stage only) Whether the session was recorded
  * summaryMessage: (Final stage only) Formatted summary of all recorded information
  * error: (Only on failure) Error message describing the issue

You should:
- Complete all stages in order for comprehensive session documentation
- Provide specific details in each stage for accurate research documentation
- Document interview data with participant identifiers and key notes
- Create descriptive titles for analytical memos
- Be specific about which codes were applied to which data items
- Connect emerging themes to their supporting codes
- Update status values to reflect progress in research activities
- Assign appropriate priorities to focus attention on critical tasks
- Define logical sequences between research processes with precedes relations
- Include relevant observations for project status updates
- If making a revision, specify which stage is being revised
- Only mark nextStageNeeded as false on the final assembly stage
- Review the final summary message to confirm all session details were recorded properly
- Use the unique session ID consistently across all stages 
```

--------------------------------------------------------------------------------
/qualitativeresearch/qualitativeresearch_endsession.txt:
--------------------------------------------------------------------------------

```
A multi-stage tool for documenting qualitative research sessions, recording analysis progress, tracking coding activities, and creating a structured record of research evolution.

When to use this tool:
- Concluding a qualitative research analysis session
- Documenting interview data collection activities
- Recording newly created analytical memos
- Tracking coding activities and code applications
- Documenting emerging themes and theoretical constructs
- Updating overall project status and progress
- Creating a structured record of research activities
- Establishing a formal conclusion to a focused research period
- Building a historical record of project development
- Documenting observations and insights from a research session
- Updating status values for research activities and entities
- Assigning or modifying priority levels for research tasks
- Establishing or modifying sequential relationships between research processes

Key features:
- Provides a structured, multi-stage workflow for research session documentation
- Records interview data collection in the knowledge graph
- Captures newly created analytical memos
- Tracks coding activities across data sources
- Documents emerging themes and their connections to codes
- Updates project status information
- Maintains session continuity with unique session IDs
- Supports revision of previous stages when needed
- Offers a comprehensive assembly stage that consolidates all session information
- Organizes qualitative research activity into a coherent narrative
- Manages status progression of research activities
- Tracks priority assignments for research tasks
- Documents sequential relationships between research processes

The endsession tool uses a sequential, multi-stage approach with typically 8 stages:
1. Summary Stage: Records basic session information
2. Interview Data Stage: Documents new interviews conducted
3. Memos Stage: Records new analytical memos created
4. Coding Activity Stage: Documents code applications and coding work
5. Themes Stage: Records emerging themes and theoretical insights
6. Status Updates Stage: Records changes to entity status values
7. Project Status Stage: Updates the overall project status
8. Assembly Stage: Consolidates all information and finalizes the session record

Parameters explained:
1. sessionId: Required - Unique identifier for the research session
  - Obtained from the startsession tool
  - Example: "qual_1234567890_abc123"
2. stage: Required - Current stage of the endsession workflow
  - Accepts: "summary", "interviewData", "memos", "codingActivity", "themes", "statusUpdates", "projectStatus", or "assembly"
  - Each stage has specific data requirements and processing logic
3. stageNumber: Required - The sequence number of the current stage
  - Starts at 1 and typically progresses through the stages
  - Used to track progress through the session documentation workflow
4. totalStages: Required - Total number of stages planned for this workflow
  - Typically 8 for the complete workflow
  - Provides context for the progress within the overall process
5. analysis: Optional - Text analysis or observations for the current stage
  - Descriptive text explaining the work done in this stage
  - Example: "Analyzed interview transcripts and identified recurring patterns"
6. stageData: Optional - Stage-specific structured data
  - Structure varies by stage type:
    * summary: { summary: "Session summary text", duration: "3 hours", project: "ProjectName" }
    * interviewData: { interviews: [{ participant: "P001", notes: "Interview notes", date: "2023-04-15" }] }
    * memos: { memos: [{ topic: "Emerging patterns", content: "Detailed memo text" }] }
    * codingActivity: { codes: [{ code: "coping_strategy", dataItem: "Interview_P001", note: "Applied to discussion of stress management" }] }
    * themes: { themes: [{ name: "Social Support", codes: ["family_support", "peer_networks"], description: "The role of social connections in coping" }] }
    * statusUpdates: { statusUpdates: [{ entityName: "Interview_P003", newStatus: "transcribed", note: "Completed transcription" }, { entityName: "Code_Resilience", newStatus: "established", note: "Well-supported by data" }] }
    * projectStatus: { projectStatus: "data_analysis", projectObservation: "Making good progress on initial coding", priorityUpdates: [{ entityName: "Transcribe_P004", priority: "high", note: "Critical for thematic development" }], sequenceUpdates: [{ before: "Coding_Phase1", after: "Theme_Development", note: "Ready to move from coding to theme creation" }] }
    * assembly: No stageData needed - automatically assembled from previous stages
7. nextStageNeeded: Required - Whether additional stages are needed after this one
  - Boolean value (true/false)
  - Set to false on the final stage to complete the session
8. isRevision: Optional - Whether this is revising a previous stage
  - Boolean value (true/false)
  - Default: false
9. revisesStage: Optional - If revising, which stage number is being revised
  - Required when isRevision is true
  - Indicates which previous stage is being updated

Status and Priority Management:
- The statusUpdates stage allows for batch updates to entity status values
- Valid status values include: planning, data_collection, analysis, writing, complete, scheduled, conducted, transcribed, coded, analyzed, emerging, developing, established, preliminary, draft, final, active, in_progress
- Priority assignments (high, low) can be modified in the projectStatus stage
- Status changes are tracked to maintain a history of research progression
- Priority changes help reallocate focus as research needs evolve

Sequential Process Management:
- The projectStatus stage allows for defining or modifying sequential relationships
- The precedes relation is used to establish logical ordering between research activities
- Sequential updates help maintain a coherent research workflow
- Process sequences can be visualized through the loadcontext tool

When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool:
1. Records the session completion in persistent storage
2. Creates a formatted summary of all session information
3. Updates the status, priority, and sequential relationships for relevant entities
4. Preserves the record of research activities for future reference

Return information:
- JSON response with the following structure:
  * success: Boolean indicating whether the operation succeeded
  * stageCompleted: The stage that was just completed
  * nextStageNeeded: Whether more stages are required
  * stageResult: The processed result of the current stage
  * endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
  * sessionRecorded: (Final stage only) Whether the session was recorded
  * summaryMessage: (Final stage only) Formatted summary of all recorded information
  * error: (Only on failure) Error message describing the issue

You should:
- Complete all stages in order for comprehensive session documentation
- Provide specific details in each stage for accurate research documentation
- Document interview data with participant identifiers and key notes
- Create descriptive titles for analytical memos
- Be specific about which codes were applied to which data items
- Connect emerging themes to their supporting codes
- Update status values to reflect progress in research activities
- Assign appropriate priorities to focus attention on critical tasks
- Define logical sequences between research processes with precedes relations
- Include relevant observations for project status updates
- If making a revision, specify which stage is being revised
- Only mark nextStageNeeded as false on the final assembly stage
- Review the final summary message to confirm all session details were recorded properly
- Use the unique session ID consistently across all stages 
```

--------------------------------------------------------------------------------
/main/descriptions/quantitativeresearch_advancedcontext.txt:
--------------------------------------------------------------------------------

```
A sophisticated query tool for exploring, analyzing, and retrieving complex information from the quantitative research knowledge graph.

When to use this tool:
- Retrieving a comprehensive view of your entire research knowledge structure
- Searching for specific research entities across your quantitative data projects
- Getting detailed information about particular research projects, datasets, or statistical elements
- Exploring relationships between variables and their statistical properties
- Analyzing hypothesis test results and their implications
- Retrieving statistical model performance metrics
- Accessing visualization galleries for specific projects or datasets
- Examining variable distributions and their statistical properties
- Finding connections between different aspects of your research
- Creating statistical reports or summaries from your data
- Exploring the relationships between research questions and findings
- Identifying entities by status to track research progress
- Filtering tasks by priority to manage research workflow
- Analyzing sequential relationships between research processes

Key features:
- Offers specialized operations for querying different aspects of quantitative research data
- Retrieves complete or filtered views of the research knowledge graph
- Provides flexible search capabilities across all research entities
- Supports detailed exploration of specific entities by name
- Generates specialized views for projects, datasets, hypotheses, and variables
- Retrieves statistical results, visualizations, and model performance metrics
- Provides detailed variable distribution analysis
- Identifies related entities to explore connections within your research
- Returns consistently structured JSON responses for easy processing
- Facilitates depth and breadth exploration of quantitative data
- Supports status-based filtering of research entities
- Enables priority-based task management
- Provides sequential process analysis capabilities

Parameters explained:
1. type: The type of query operation to perform
  - Accepts one of the specialized operations: "graph", "search", "nodes", "project", "dataset", "hypothesis", "variables", "statistics", "visualizations", "model", "question", "distribution", "related", "status", "priority", "sequence"
  - Determines how the params parameter is interpreted
2. params: Operation-specific parameters (structure varies by type):
  - For "graph": No parameters needed (retrieves the full research knowledge graph)
  - For "search": Object containing:
    * query: Search string to find entities (supports entity type filters)
  - For "nodes": Object containing:
    * names: Array of entity names to retrieve
  - For "project": Object containing:
    * projectName: Name of the project to retrieve details for
  - For "dataset": Object containing:
    * datasetName: Name of the dataset to retrieve analysis for
  - For "hypothesis": Object containing:
    * projectName: Project name to filter hypotheses by
    * hypothesisName: (Optional) Specific hypothesis to retrieve tests for
  - For "variables": Object containing:
    * variableName: Name of the variable to retrieve relationship information for
  - For "statistics": Object containing:
    * projectName: Project name to retrieve statistical results for
    * testType: (Optional) Type of statistical test to filter by
  - For "visualizations": Object containing:
    * projectName: Project name to retrieve visualizations for
    * datasetName: (Optional) Dataset name to filter visualizations by
  - For "model": Object containing:
    * modelName: Name of the model to retrieve performance metrics for
  - For "question": Object containing:
    * questionName: Name of the research question to retrieve results for
  - For "distribution": Object containing:
    * variableName: Name of the variable to analyze distribution of
    * datasetName: (Optional) Dataset name to contextualize the variable
  - For "related": Object containing:
    * entityName: Name of the entity to find related entities for
  - For "status": Object containing:
    * statusValue: The status value to filter by (e.g., "active", "completed", "pending", "abandoned")
  - For "priority": Object containing:
    * priorityValue: The priority value to filter by (e.g., "high", "low")
  - For "sequence": Object containing:
    * entityName: Name of the entity to find sequential relationships for

Operation details:
- graph: Returns the complete research knowledge graph with all entities and relationships
- search: Performs text-based search across entity names and observations
- nodes: Retrieves detailed information about specific entities by name
- project: Returns comprehensive project information including datasets, hypotheses, tests, and findings
- dataset: Provides detailed dataset analysis with variables, descriptive statistics, and correlations
- hypothesis: Retrieves hypothesis tests and their results for a project or specific hypothesis
- variables: Examines relationships between a variable and other variables (correlations, dependencies)
- statistics: Collects statistical test results for a project, optionally filtered by test type
- visualizations: Returns visualization metadata and descriptions for a project or dataset
- model: Provides detailed model performance metrics, parameters, and validation results
- question: Retrieves research question details, related hypotheses, and supporting findings
- distribution: Analyzes the statistical distribution of a variable with descriptive stats and normality tests
- related: Identifies all entities directly connected to a specific entity
- status: Retrieves all entities with a specific status value
- priority: Retrieves all entities with a specific priority value
- sequence: Identifies sequential relationships for a specific entity showing preceding and following entities

Status and Priority Information:
- Status queries return entities organized by their current research stage
- Priority queries help identify critical research tasks and elements
- Status values include: active, completed, pending, abandoned
- Priority values include: high, low
- Status and priority are assigned through has_status and has_priority relations

Sequential Process Information:
- Sequence queries identify entities that come before or after in a research process
- Sequential relationships help visualize the research workflow and methodology
- The sequence operation shows both incoming and outgoing precedes relations
- Process sequences are essential for understanding multi-step analytical procedures

Return information:
- success: Boolean indicating whether the operation succeeded
- Additional fields depend on the operation type:
  * graph: Complete knowledge graph
  * results: For search operations
  * nodes: For specific entity retrieval
  * project/dataset/hypothesis/etc.: For specialized views
  * status/priority: Lists of entities with specified status/priority values
  * sequence: Preceding and following entities in research processes

You should:
- Start with broad queries ("graph", "search") to explore your research corpus
- Use specific entity queries ("nodes", "project", "dataset") for detailed information
- Examine variable relationships and distributions to understand your data
- Review hypothesis tests and statistical results to evaluate evidence
- Explore model performance metrics to assess predictive accuracy
- Use visualization galleries to communicate research findings
- Examine research questions and their supporting evidence
- Use status queries to identify all entities at a particular research stage
- Use priority queries to focus on high-priority research tasks
- Use sequence queries to understand process flows in your research methodology
- Combine multiple operations to build a comprehensive understanding of your research
- Use the related operation to discover connections between entities
- Apply search filters to find specific types of research elements 
```

--------------------------------------------------------------------------------
/quantitativeresearch/quantitativeresearch_advancedcontext.txt:
--------------------------------------------------------------------------------

```
A sophisticated query tool for exploring, analyzing, and retrieving complex information from the quantitative research knowledge graph.

When to use this tool:
- Retrieving a comprehensive view of your entire research knowledge structure
- Searching for specific research entities across your quantitative data projects
- Getting detailed information about particular research projects, datasets, or statistical elements
- Exploring relationships between variables and their statistical properties
- Analyzing hypothesis test results and their implications
- Retrieving statistical model performance metrics
- Accessing visualization galleries for specific projects or datasets
- Examining variable distributions and their statistical properties
- Finding connections between different aspects of your research
- Creating statistical reports or summaries from your data
- Exploring the relationships between research questions and findings
- Identifying entities by status to track research progress
- Filtering tasks by priority to manage research workflow
- Analyzing sequential relationships between research processes

Key features:
- Offers specialized operations for querying different aspects of quantitative research data
- Retrieves complete or filtered views of the research knowledge graph
- Provides flexible search capabilities across all research entities
- Supports detailed exploration of specific entities by name
- Generates specialized views for projects, datasets, hypotheses, and variables
- Retrieves statistical results, visualizations, and model performance metrics
- Provides detailed variable distribution analysis
- Identifies related entities to explore connections within your research
- Returns consistently structured JSON responses for easy processing
- Facilitates depth and breadth exploration of quantitative data
- Supports status-based filtering of research entities
- Enables priority-based task management
- Provides sequential process analysis capabilities

Parameters explained:
1. type: The type of query operation to perform
  - Accepts one of the specialized operations: "graph", "search", "nodes", "project", "dataset", "hypothesis", "variables", "statistics", "visualizations", "model", "question", "distribution", "related", "status", "priority", "sequence"
  - Determines how the params parameter is interpreted
2. params: Operation-specific parameters (structure varies by type):
  - For "graph": No parameters needed (retrieves the full research knowledge graph)
  - For "search": Object containing:
    * query: Search string to find entities (supports entity type filters)
  - For "nodes": Object containing:
    * names: Array of entity names to retrieve
  - For "project": Object containing:
    * projectName: Name of the project to retrieve details for
  - For "dataset": Object containing:
    * datasetName: Name of the dataset to retrieve analysis for
  - For "hypothesis": Object containing:
    * projectName: Project name to filter hypotheses by
    * hypothesisName: (Optional) Specific hypothesis to retrieve tests for
  - For "variables": Object containing:
    * variableName: Name of the variable to retrieve relationship information for
  - For "statistics": Object containing:
    * projectName: Project name to retrieve statistical results for
    * testType: (Optional) Type of statistical test to filter by
  - For "visualizations": Object containing:
    * projectName: Project name to retrieve visualizations for
    * datasetName: (Optional) Dataset name to filter visualizations by
  - For "model": Object containing:
    * modelName: Name of the model to retrieve performance metrics for
  - For "question": Object containing:
    * questionName: Name of the research question to retrieve results for
  - For "distribution": Object containing:
    * variableName: Name of the variable to analyze distribution of
    * datasetName: (Optional) Dataset name to contextualize the variable
  - For "related": Object containing:
    * entityName: Name of the entity to find related entities for
  - For "status": Object containing:
    * statusValue: The status value to filter by (e.g., "active", "completed", "pending", "abandoned")
  - For "priority": Object containing:
    * priorityValue: The priority value to filter by (e.g., "high", "low")
  - For "sequence": Object containing:
    * entityName: Name of the entity to find sequential relationships for

Operation details:
- graph: Returns the complete research knowledge graph with all entities and relationships
- search: Performs text-based search across entity names and observations
- nodes: Retrieves detailed information about specific entities by name
- project: Returns comprehensive project information including datasets, hypotheses, tests, and findings
- dataset: Provides detailed dataset analysis with variables, descriptive statistics, and correlations
- hypothesis: Retrieves hypothesis tests and their results for a project or specific hypothesis
- variables: Examines relationships between a variable and other variables (correlations, dependencies)
- statistics: Collects statistical test results for a project, optionally filtered by test type
- visualizations: Returns visualization metadata and descriptions for a project or dataset
- model: Provides detailed model performance metrics, parameters, and validation results
- question: Retrieves research question details, related hypotheses, and supporting findings
- distribution: Analyzes the statistical distribution of a variable with descriptive stats and normality tests
- related: Identifies all entities directly connected to a specific entity
- status: Retrieves all entities with a specific status value
- priority: Retrieves all entities with a specific priority value
- sequence: Identifies sequential relationships for a specific entity showing preceding and following entities

Status and Priority Information:
- Status queries return entities organized by their current research stage
- Priority queries help identify critical research tasks and elements
- Status values include: active, completed, pending, abandoned
- Priority values include: high, low
- Status and priority are assigned through has_status and has_priority relations

Sequential Process Information:
- Sequence queries identify entities that come before or after in a research process
- Sequential relationships help visualize the research workflow and methodology
- The sequence operation shows both incoming and outgoing precedes relations
- Process sequences are essential for understanding multi-step analytical procedures

Return information:
- success: Boolean indicating whether the operation succeeded
- Additional fields depend on the operation type:
  * graph: Complete knowledge graph
  * results: For search operations
  * nodes: For specific entity retrieval
  * project/dataset/hypothesis/etc.: For specialized views
  * status/priority: Lists of entities with specified status/priority values
  * sequence: Preceding and following entities in research processes

You should:
- Start with broad queries ("graph", "search") to explore your research corpus
- Use specific entity queries ("nodes", "project", "dataset") for detailed information
- Examine variable relationships and distributions to understand your data
- Review hypothesis tests and statistical results to evaluate evidence
- Explore model performance metrics to assess predictive accuracy
- Use visualization galleries to communicate research findings
- Examine research questions and their supporting evidence
- Use status queries to identify all entities at a particular research stage
- Use priority queries to focus on high-priority research tasks
- Use sequence queries to understand process flows in your research methodology
- Combine multiple operations to build a comprehensive understanding of your research
- Use the related operation to discover connections between entities
- Apply search filters to find specific types of research elements 
```

--------------------------------------------------------------------------------
/main/descriptions/common_endsession.txt:
--------------------------------------------------------------------------------

```
A multi-stage tool for documenting domain-specific sessions, recording progress, tracking updates, and creating a structured record of work in the knowledge graph.

When to use this tool:
Only use this tool when the user explicitly requests it or provides explicit approval.

Key features:
- Provides a structured, multi-stage workflow for session documentation
- Records accomplishments/learnings in the knowledge graph
- Updates status of tracked elements based on progress
- Creates connections between related entities
- Updates overall project/course/research status and metadata
- Creates new elements for future work
- Supports revision of previous stages when needed
- Offers a comprehensive assembly stage that consolidates all session information
- Organizes activity into a coherent history

The endsession tool uses a sequential, multi-stage approach with typical stages varying by domain:
- Developer (6 stages): Summary, Achievements, Task Updates, New Tasks, Project Status, Assembly
- Student (6 stages): Summary, Concepts Learned, Assignment Updates, New Concepts, Course Status, Assembly
- Qualitative Research (7 stages): Summary, Interview Data, Memos, Coding Activity, Themes, Project Status, Assembly
- Quantitative Research (8 stages): Summary, Dataset Updates, New Analyses, New Visualizations, Hypothesis Results, Model Updates, Project Status, Assembly
- Project Management (7 stages): Summary, Achievements, Task Updates, New Tasks, Project Status, Risk Updates, Assembly

Parameters explained:
1. sessionId: Required - Unique identifier for the session
  - Obtained from the startsession tool
  - Format varies by domain (dev_timestamp_randomstring, stu_timestamp_randomstring, etc.)
2. stage: Required - Current stage of the endsession workflow
  - Accepts domain-specific stage values
  - Each stage has specific data requirements and processing logic
3. stageNumber: Required - The sequence number of the current stage
  - Starts at 1 and progresses through domain-specific number of stages
  - Used to track progress through the session documentation workflow
4. totalStages: Required - Total number of stages planned for this workflow
  - Varies by domain (typically 6-8 stages)
  - Provides context for the progress within the overall process
5. analysis: Optional - Text analysis or observations for the current stage
  - Descriptive text explaining the work done in this stage
6. stageData: Optional - Stage-specific structured data
  - Structure varies by stage type and domain:
    * Developer:
      - summary: { summary: "Session summary text", duration: "2 hours", focus: "ProjectName" }
      - achievements: { achievements: ["Implemented feature X", "Fixed bug Y", "Refactored component Z"] }
      - taskUpdates: { taskUpdates: [{ name: "Task1", status: "completed" }, { name: "Task2", status: "in_progress" }] }
      - newTasks: { newTasks: [{ name: "NewTask1", description: "Implement feature A", priority: "high" }] }
      - projectStatus: { projectName: "ProjectName", projectStatus: "in_progress", projectObservation: "Making good progress" }
    * Student:
      - summary: { summary: "Session summary text", duration: "2 hours", course: "CourseName" }
      - conceptsLearned: { concepts: ["Concept A", "Concept B", "Concept C"] }
      - assignmentUpdates: { updates: [{ name: "Assignment1", status: "completed" }, { name: "Assignment2", status: "in_progress" }] }
      - newConcepts: { concepts: [{ name: "NewConcept1", description: "Definition of the concept" }] }
      - courseStatus: { courseStatus: "in_progress", courseObservation: "Making good progress" }
    * Qualitative Research:
      - summary: { summary: "Session summary text", duration: "3 hours", project: "ProjectName" }
      - interviewData: { interviews: [{ participant: "P001", notes: "Interview notes", date: "2023-04-15" }] }
      - memos: { memos: [{ topic: "Emerging patterns", content: "Detailed memo text" }] }
      - codingActivity: { codes: [{ code: "coping_strategy", dataItem: "Interview_P001", note: "Applied to discussion of stress management" }] }
      - themes: { themes: [{ name: "Social Support", codes: ["family_support", "peer_networks"], description: "The role of social connections in coping" }] }
      - projectStatus: { projectStatus: "data_analysis", projectObservation: "Making good progress on initial coding" }
    * Quantitative Research:
      - summary: { summary: "Session summary text", duration: "3 hours", project: "ProjectName" }
      - datasetUpdates: { datasets: [{ name: "Dataset1", size: "500 rows", variables: "10", status: "cleaned", description: "Dataset description" }] }
      - newAnalyses: { analyses: [{ name: "Analysis1", type: "regression", result: "p<0.05", pValue: "0.03", variables: ["var1", "var2"] }] }
      - newVisualizations: { visualizations: [{ name: "Viz1", type: "scatter", description: "Correlation visualization", datasetName: "Dataset1" }] }
      - hypothesisResults: { hypotheses: [{ name: "H1", status: "confirmed", evidence: "Statistical significance in regression model", pValue: "0.02" }] }
      - modelUpdates: { models: [{ name: "Model1", type: "regression", performance: "R²=0.85", variables: ["var1", "var2"] }] }
      - projectStatus: { projectStatus: "in_progress", projectObservation: "Data analysis phase complete" }
    * Project Management:
      - summary: { summary: "Session summary text", duration: "3 hours", project: "ProjectName" }
      - achievements: { achievements: ["Decision 1", "Accomplishment 2"] }
      - taskUpdates: { updates: [{ name: "Task1", status: "in_progress", progress: "50%" }] }
      - newTasks: { tasks: [{ name: "New Task", description: "Details", priority: "high" }] }
      - projectStatus: { projectStatus: "in_progress", projectObservation: "Good progress" }
      - riskUpdates: { risks: [{ name: "Risk1", status: "mitigated", impact: "medium", probability: "low" }] }
    * All domains:
      - assembly: No stageData needed - automatically assembled from previous stages
7. nextStageNeeded: Required - Whether additional stages are needed after this one
  - Boolean value (true/false)
  - Set to false on the final stage to complete the session
8. isRevision: Optional - Whether this is revising a previous stage
  - Boolean value (true/false)
  - Default: false
9. revisesStage: Optional - If revising, which stage number is being revised
  - Required when isRevision is true
  - Indicates which previous stage is being updated

When the endsession workflow completes (assembly stage with nextStageNeeded: false), the tool performs domain-specific updates to the knowledge graph:
- Developer: Achievement entities, task status updates, project status updates, new task creation
- Student: Concept entities, assignment status updates, course status updates, new concept creation
- Qualitative Research: Interview records, memo creation, coding and theme organization, project status updates
- Quantitative Research: Dataset updates, statistical analyses, visualizations, hypothesis results, model updates, project status
- Project Management: Achievement entities, task status updates, project status updates, new task creation, risk updates

Return information:
- JSON response with the following structure:
  * success: Boolean indicating whether the operation succeeded
  * stageCompleted: The stage that was just completed
  * nextStageNeeded: Whether more stages are required
  * stageResult: The processed result of the current stage
  * endSessionArgs: (Only in assembly stage) Consolidated arguments for the session
  * sessionRecorded: (Final stage only) Whether the session was recorded
  * summaryMessage: (Final stage only) Formatted summary of all recorded information
  * error: (Only on failure) Error message describing the issue

You should:
- Complete all stages in order for comprehensive session documentation
- Provide specific details in each stage for accurate knowledge graph updates
- Be precise about names of entities to ensure they match existing entities
- Use clear, descriptive names for any new entities
- Include relevant observations for status updates
- If making a revision, specify which stage is being revised
- Only mark nextStageNeeded as false on the final assembly stage
- Review the final summary message to confirm all session details were recorded properly
- Use the unique session ID consistently across all stages 
```