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

A flexible tool for constructing and enhancing your educational knowledge graph. This tool allows you to add new academic entities, create relationships between educational components, or add observations to existing study materials. Each operation type serves a specific purpose in building a comprehensive representation of your academic journey.

When to use this tool:

• Creating new educational entities like courses, assignments, and exams

• Establishing relationships between academic entities (e.g., assignment is part of a course)

• Documenting observations about your academic materials

• Building a connected graph of your educational experience

• Organizing your study resources and materials

• Tracking relationships between concepts and learning materials

• Recording course-specific details like schedules and due dates

• Creating structured representations of your academic knowledge

• Setting status values for educational entities

• Assigning priority to assignments and tasks

Key features:

• Three distinct operation types (entities, relations, observations)

• Type validation against academic domain standards

• Automatic rejection of invalid entity or relation types

• Safe addition of new observations to existing academic entities

• Status and priority assignment through entity-relation model

• JSON-formatted response with operation results

• Clear error messages when operations fail

• Handles both single and batch operations

Parameters explained:

• type: The operation type to perform, which must be one of:

  • "entities" - Create new academic entities

  • "relations" - Create relationships between existing entities

  • "observations" - Add observations to existing entities

• data: Operation-specific data structure:

  • For "entities": Array of objects with { name, entityType, observations[] }

  • For "relations": Array of objects with { from, to, relationType }

  • For "observations": Array of objects with { entityName, contents[] }

Entity Types:

• course - Academic courses you're taking

• assignment - Homework, projects, and other submitted work

• exam - Tests, quizzes, and other assessments

• concept - Knowledge topics and learning objectives

• resource - Textbooks, articles, videos, and other learning materials

• note - Personal study notes and observations

• lecture - Individual class sessions

• project - Larger educational projects

• question - Specific questions for study or review

• term - Academic terms or semesters

• goal - Learning objectives and targets

• professor - Course instructors and teachers

• status - Entity status (not_started, in_progress, complete)

• priority - Entity priority (low, high)

Relation Types include:

• enrolled_in - Student is taking a course

• assigned_in - Assignment is part of a course

• due_on - Assignment/exam has specific due date

• covers - Lecture/resource covers concept

• references - Note references concept

• prerequisite_for - Concept is foundation for another

• taught_by - Course taught by professor

• scheduled_for - Lecture/exam scheduled for specific time

• contains - Course contains lectures/assignments

• has_status - Links entity to its status (not_started, in_progress, complete)

• has_priority - Links entity to its priority (low, high)

• follows - Entity follows another in a sequence

Status Values:

• not_started - Work on the entity has not begun

• in_progress - Work is actively underway

• complete - Work has been finished

Priority Values:

• low - Lower priority item

• high - Higher priority item

You should:

1. Specify the operation type based on what you need to create (entities, relations, or observations)

2. Structure your data according to the operation type's requirements

3. Use valid entity types and relation types from the academic domain

4. Ensure entities exist before creating relations between them

5. Provide meaningful names and descriptions for new entities

6. Use observations to add general metadata about entities

7. Use has_status relations to track progress (not_started, in_progress, complete)

8. Use has_priority relations to indicate importance (low, high)

9. Use follows relations to establish sequences between related entities

10. Create complete structures rather than adding entities/relations piecemeal

11. Check the operation result to confirm successful creation

A precise tool for removing elements from your educational knowledge graph. This tool enables targeted deletion of academic entities, relationships between educational components, or specific observations about study materials. It helps maintain an accurate and current representation of your academic landscape as your learning journey evolves.

When to use this tool:

• Removing completed or dropped courses

• Deleting obsolete relationships between academic entities

• Pruning outdated notes or observations that are no longer relevant

• Correcting errors in your academic knowledge graph

• Cleaning up test or practice entities

• Maintaining graph accuracy as your educational focus changes

• Removing duplicate learning materials or resources

• Archiving completed assignments or exams

• Updating status or priority relations when they change

• Modifying entity sequences

Key features:

• Three distinct deletion operation types (entities, relations, observations)

• Cascading deletion for entities (automatically removes related relations)

• Precise deletion of specific observations without removing entire entities

• Targeted relation removal with exact matching on from/to/type

• Batch operations for efficient cleanup

• JSON-formatted response with operation results

• Secure validation before deletion

• Clear error messages when operations fail

Parameters explained:

• type: The deletion operation type to perform, which must be one of:

  • "entities" - Remove academic entities and their relations

  • "relations" - Remove specific relationships between entities

  • "observations" - Remove specific observations from entities

• data: Operation-specific data structure:

  • For "entities": Array of entity names to delete

  • For "relations": Array of objects with { from, to, relationType }

  • For "observations": Array of objects with { entityName, observations[] }

Deletion behavior by type:

• "entities": Completely removes the specified entities and any relations where they appear

• "relations": Removes only the exact relations specified, matching on all three attributes

• "observations": Removes specific observations from entities while preserving the entities themselves

Status and Priority Management:

• To change an entity's status, delete the old has_status relation and create a new one

• To change priority, delete the old has_priority relation and create a new one

• Status values (not_started, in_progress, complete) are managed through relations, not direct properties

• Priority values (low, high) are managed through relations, not direct properties

Safety considerations:

• Entity deletion cascades to relations, so be careful when deleting key entities

• There is no "undo" operation, so confirm deletions carefully

• Partial graph information can lead to inconsistent views of your academic knowledge

• Relations require entities on both ends to exist

• Deleting status or priority relations without replacing them can lead to inconsistent state

• Consider creating new status/priority relations before deleting old ones

You should:

1. Identify the specific elements in your academic graph that need to be removed

2. Choose the appropriate deletion type (entities, relations, or observations)

3. Structure your data according to the deletion type's requirements

4. Start with more specific deletions (observations) before broader ones

5. Verify the entities or relations exist before attempting deletion

6. When updating status, create a new has_status relation before deleting the old one

7. When updating priority, create a new has_priority relation before deleting the old one

8. Consider the impact on entity sequences when deleting follows relations

9. Check the operation result to confirm successful deletion

10. Consider documenting major deletions as observations on related entities

11. When removing an entire course, first delete its components for cleaner removal

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

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

A powerful tool for initializing a new academic study session. This tool starts a new study session and provides a comprehensive overview of your current educational landscape. It retrieves recent study sessions, active courses, upcoming deadlines, and recently studied concepts to help focus your learning effectively.

When to use this tool:

• Beginning a new study session or learning period

• Getting oriented in your current academic state

• Planning which courses or assignments to focus on

• Reviewing recent study activity and progress

• Checking upcoming deadlines for assignments and exams

• Deciding which concepts need attention

• Establishing context before diving into specific study work

• Creating a structured record of your study activity

• Identifying high-priority assignments that need attention

• Tracking progress through status information

Key features:

• Generates a unique study session identifier for tracking activity

• Retrieves and displays your most recent study sessions

• Shows active courses (based on has_status relations)

• Highlights high-priority assignments (based on has_priority relations)

• Identifies assignment status (not_started, in_progress, complete)

• Highlights upcoming assignment and exam deadlines

• Lists recently studied concepts for review

• Formats information in a structured, easy-to-read format

• Provides seamless integration with loadcontext tool

• Stores study session data for historical record keeping

Parameters explained:

• No parameters required - the tool automatically retrieves all relevant context

Return information:

• Session ID: A unique identifier for this study session (format: stud_timestamp_randomstring)

• Recent Study Sessions: Up to 3 most recent sessions with:

  • Date

  • Course focus

  • Study session summary (truncated for readability)

• Active Courses: List of courses with active status (via has_status relation), including:

  • Course name

  • Course code or description

  • Status via has_status relation

  • Priority if assigned via has_priority relation

• High-Priority Assignments: Assignments with high priority status (via has_priority relation), including:

  • Assignment name

  • Current status (not_started, in_progress, complete)

  • Course it belongs to

  • Due date if available

• Upcoming Deadlines: Assignment and exam deadlines in the next 14 days, including:

  • Assignment/exam name

  • Course it belongs to

  • Due date

  • Days remaining until due

  • Status (not_started, in_progress, complete)

• Recently Studied Concepts: List of concepts you've recently studied

Session workflow:

1. Starting a session creates a session identifier in the student domain

2. This session can be referenced when loading course context with loadcontext

3. Session activities are tracked for later recording

4. Sessions should be ended with endsession to record learning progress

5. Session history becomes available for future startsession calls

Status and Priority:

• Course status is retrieved through has_status relations (not_started, in_progress, complete)

• Assignment priority is retrieved through has_priority relations (low, high)

• This information helps you prioritize your study activities

You should:

1. Begin each focused study period with startsession

2. Review the provided context to determine your study focus

3. Prioritize high-priority assignments with upcoming deadlines

4. Focus on incomplete assignments (not_started or in_progress status)

5. Choose a specific course, assignment, or concept to work on

6. Use the generated session ID with the loadcontext tool to load specific entities

7. Complete your study work on your selected focus area

8. End the session with endsession when work is complete

9. Record concepts learned, assignment status updates, and study accomplishments

10. Use the session history to maintain continuity between study periods