Tool reference

Your agent calls these tools for you. You rarely type them yourself, but knowing what exists helps you ask for the right thing (“save this as a decision”, “what did we know about billing in March?”). Parameter tables come straight from the tool schemas the server publishes; the “when to use” notes and examples are written by hand.

Start with memory_save, memory_recall, session_init and session_end. Most people never need more.

Save & recall

Write knowledge and find it again: the tools you and your agent use every day.

• memory_save Stores one piece of knowledge (a decision, solution, lesson, fact or convention) so later sessions can find it.
• memory_save_fast Saves knowledge exactly like memory_save but always skips the quality gate and never calls an LLM.
• memory_recall Searches everything saved in memory across past sessions and returns the best-matching records grouped by type.
• memory_search_fast Runs the standard search with reranking and diversity turned off, so results are deterministic and no LLM is used.
• memory_recall_iterative Answers multi-step questions by splitting them into sub-questions, searching for each, and letting an LLM planner decide when enough evidence has been found.
• memory_get Fetches the full content of specific records by ID, up to 50 at a time.
• memory_search_by_tag Lists all active records whose tags contain the given text.
• memory_answer Writes an answer to a question using only records from one project, cites the exact quotes it relied on, and checks the answer with a second LLM pass.
• memory_context_build Assembles a token-bounded context bundle for a task: related knowledge, recent episodes, applicable skills, rules, and known blind spots.
• memory_explain_search Runs a fast search and shows how each retrieval tier (keyword, semantic, graph, fuzzy, HyDE) scored the records and how they were merged.
• memory_index_passages Builds the passage index for one project in batches, which evidence-mode recall and memory_answer search over.

Edit, history & reports

Correct, delete, link and export records, see how they changed over time, and build activity reports.

• memory_update Replaces a record with a new version, keeping the old one in history. Name the record by id, or let a search query (optionally within one project) find it.
• memory_delete Removes one record from search results by marking it deleted and dropping its embeddings. With hard: true it erases the record for good, with its earlier versions and every derived copy.
• memory_forget Applies the retention policy: archives old records that were never recalled and have low confidence, and purges records that stayed archived too long.
• memory_history Shows the chain of versions for a record, newest first, created by updates and supersedes.
• memory_timeline Browses past sessions with the events and knowledge recorded in each, by position, by date range, or by a text query.
• memory_report Builds an activity report for a project (or all projects) over a day, week, month, all time or custom dates: decisions with their reasons, fixes, errors, lessons, open next steps, files and a daily timeline.
• memory_export Exports active knowledge, sessions and relations as JSON, either to a backup file or directly in the response.
• memory_relate Links two records with a typed relation so graph-based search can pull one in when the other matches.
• memory_extract_session Lists, reads and marks as processed the transcripts of past sessions that were captured automatically, so knowledge can be extracted from them.
• memory_wiki_generate Writes a Markdown digest per project (top decisions, active solutions, conventions, recent changes) to the wikis folder without calling an LLM.

Sessions & episodes

Pick up where the last session stopped and keep a narrative of what happened.

• session_init Loads the most recent unread end-of-session summary for a project so a new session can pick up where the last one stopped.
• session_end Saves a structured end-of-session summary (what was done, pitfalls, next steps) that the next session_init call will return.
• memory_observe Records a cheap, short-lived observation of something that happened (a file edit, a command, a discovery) without deduplication or embeddings.
• memory_episode_save Saves a short narrative of how a piece of work went: what was tried, what failed, what worked, and the key insight.
• memory_episode_recall Finds past episodes filtered by text, project, outcome, impact or concepts.

Knowledge graph & temporal facts

Entities, relations and facts that are true for a period of time.

• memory_graph Returns the neighbourhood of one node in the knowledge graph: the connected rules, skills, concepts, memories and entities.
• memory_graph_index Re-reads your CLAUDE.md, skills and rules files and rebuilds their nodes and edges in the knowledge graph.
• memory_graph_stats Reports the size and health of the knowledge graph: node and edge counts by type, orphans, communities and the most important nodes.
• memory_concepts Lists or searches nodes in the knowledge graph by name, optionally with the memories linked to each one.
• memory_associate Finds memories by spreading activation through the knowledge graph from the concepts in your query, rather than by keyword match.
• kg_add_fact Records a dated fact as subject, predicate, object, and by default closes any earlier fact with the same subject and predicate.
• kg_invalidate_fact Marks a currently valid fact as no longer true from now on, keeping it in the history.
• kg_at Returns the facts that were valid at a given moment, or the facts valid now when no timestamp is passed.
• kg_timeline Returns every fact ever recorded for a subject in chronological order, including ones that were later replaced or closed.
• memory_temporal_query Does exact date calculations: the relation between two time intervals, the duration between two dates, or turning a phrase like "last Friday" into a date.
• memory_entity_resolve Maps a mention such as "Postgres" or "pg" to one canonical entity id within a project and type, creating the entity if it is new.
• analogize Finds solutions, lessons and decisions from other projects that share words and features with the problem you describe.

Errors, rules & self-improvement

Log mistakes, turn repeated ones into rules, and load the rules that apply now.

• self_error_log Logs a mistake or failure with a category so the memory can spot repeating error patterns.
• self_insight Creates, votes on, edits, lists and promotes insights, which are lessons drawn from repeated errors.
• self_rules Manages behavioural rules: list them, record when one was used, rate whether it helped, and suspend, reactivate, retire or add rules by hand.
• self_patterns Summarises logged errors, insights and rules: repeating error categories, insights ready for promotion, rule success rates and the weekly error trend.
• self_reflect Saves a written reflection on how a task went and what to do differently, stored as a reflection record.
• self_rules_context Returns the active rules that apply to the current project, optionally narrowed to rules for the current task phase.
• rule_set_phase Tags a rule with one task phase so it is only loaded during that phase, or clears the tag so it applies to every phase.
• learn_error Records an error with its file, root cause, fix and a pattern name, and creates a prevention rule automatically once the same pattern repeats.
• memory_reflect_now Runs the background maintenance pass on demand: deduplication and decay, and in full or weekly scope also pattern synthesis, triple extraction, fact merging and enrichment.
• memory_self_assess Reports how experienced the memory thinks the agent is in given topics, with a confidence value and any known blind spots.
• memory_skill_get Finds stored skills (step-by-step procedures) by a trigger phrase or exact name, or lists them all.
• memory_skill_update Records whether applying a skill worked, and can add new steps or an anti-pattern to it.

Tasks, workflows & decisions

Structured decisions, task phases, learned workflows and code-aware context.

• workflow_learn Stores a named, ordered list of steps as a reusable workflow so it can be predicted and tracked later.
• workflow_predict Estimates how likely a stored workflow is to succeed and how long it usually takes, based on its past runs.
• workflow_track Records the outcome of one run of a stored workflow and updates its success rate and average duration.
• classify_task Rates a task description from L1 (quick fix) to L4 (architecture change) and suggests which work phases it needs.
• task_create Starts tracking a task in its first phase (van) and fixes which phases it is allowed to go through.
• phase_transition Closes the current phase of a task and opens the next one, optionally attaching artifacts and notes.
• task_phases_list Returns every phase a task has been through, in order, with entry and exit times.
• save_decision Saves an architectural decision with the options considered, a scoring matrix, the choice and the reasoning.
• save_intent Stores one user prompt in the intents log, the same log the prompt hook writes to.
• list_intents Lists recent user prompts, newest first, optionally filtered by project or session.
• search_intents Finds past user prompts that contain a given piece of text, newest first.
• file_context Before you edit a file, shows past errors, lessons and rules that mention it, plus a risk score from 0 to 1.
• ingest_codebase Splits a file or directory into functions, classes and methods using a syntax tree and reports what it found.

Maintenance & performance

Statistics, consolidation, index rebuilds and latency reports.

• memory_stats Reports how much is stored in memory and how healthy it is: record counts, projects, stale items, storage size and configuration.
• memory_consolidate Finds groups of near-duplicate records and, when asked, keeps the longest one in each group and marks the others as consolidated.
• memory_consolidate_status Shows what the background consolidation worker has done per project: last run, result, errors and active locks.
• memory_warmup Loads the embedding model and opens the vector store now, so the first real save or search is not slow.
• memory_perf_report Returns the server’s internal timing and call counters and embedding-cache statistics.
• memory_rebuild_fts Drops and rebuilds the full-text search index from the stored records.
• memory_rebuild_embeddings Recomputes the vectors used for semantic search for all active records, or only for one project or embedding space.
• benchmark Runs the built-in test scenarios against your memory and reports recall at k, how often past mistakes are flagged, and latency.

Evaluation

Built-in recall and consistency checks for people tuning or developing TAM.

• memory_eval_locomo Runs the LongMemEval-style scenario suite against the live store in a chosen mode and reports recall@5/10, latency and any LLM or network calls made.
• memory_eval_recall Measures recall on your own scenario dataset, or on a tiny built-in check that saves two records and searches for them.
• memory_eval_temporal Checks time-aware facts: writes that a test project used one database and later another, then checks both "as of then" and "now" answers.
• memory_eval_entity_consistency Checks that the same entity name is mapped to one canonical tag every time it is saved.
• memory_eval_contradictions Checks that the contradiction detector marks a newer conflicting record as superseding an old one and leaves unrelated records alone.
• memory_eval_long_context Saves many filler records plus one unique "needle" record and checks whether search still finds the needle.

Team server (remote)

The memory and report tools a team server exposes at /mcp. Access comes from your personal token and the scope you pick.

• memory_scopes Shows who the server thinks you are and which workspaces you can use: your personal one, each team you belong to, and the shared one.
• memory_save Saves a record into one workspace, personal by default, with you recorded as the author from your token.
• memory_recall Searches every workspace you can read, or just one scope, and returns ranked records labelled with the scope they came from.
• memory_get Reads one record by id from one workspace, including who created it, who last changed it, and its current revision.
• memory_update Replaces a record’s content with a new version, but only if nobody changed it since the revision you read.
• memory_delete Soft-deletes a record after checking its revision, keeping it and its history available for audit.
• memory_history Lists the change events for a record and all earlier versions it replaced, oldest first, with author, time, reason and before/after state.
• memory_export Pages through every record in one workspace, in id order, with authorship and revision.
• memory_report Builds an activity report on the team server for your own memory, one department, or the whole company, with a contributors table.

Team onboarding

New in 14.6.0

Department onboarding on the team server: curricula, lessons from team memory, quizzes, grading and progress reports.

• onboarding_overview Lists the departments you belong to with their onboarding status, plus the departments whose people you may view or manage.
• onboarding_start Enrols you in a department's onboarding (or resumes it) and returns the plan with your progress and the next step.
• onboarding_next Opens your next unfinished lesson (or a given lesson) with the department's memory records it is based on, inline.
• onboarding_complete Marks a lesson as studied, records the time spent, and adds a short note to the employee's own personal memory.
• onboarding_quiz Returns a module's quiz questions without answer keys, once every lesson of the module is completed.
• onboarding_submit Grades a quiz attempt: choice questions automatically, open answers by the server LLM if configured, otherwise queued for the department head.
• onboarding_progress Shows onboarding progress and the learning log: your own by default, or another employee's for their department head, company viewers and superadmins.
• onboarding_team_report Department report: every member against every module with status, lessons done, quiz results and dates, the learning log, and (for heads) the grading queue.
• onboarding_curriculum_get Reads a department's curriculum with its modules, lessons, quizzes and the revision needed for editing.
• onboarding_curriculum_set Creates or replaces a department's curriculum: ordered modules of ordered lessons with text and/or team memory record IDs.
• onboarding_curriculum_draft Builds a draft curriculum from the department's memory, grouped by project and record type; the server LLM, if configured, only polishes the wording.
• onboarding_quiz_set Creates or replaces a module's quiz with single-choice, multiple-choice and open questions, answer keys and rubrics.
• onboarding_quiz_draft Generates draft quiz questions from a module's lessons with the server LLM, keeping only questions that quote a lesson verbatim.
• onboarding_grade Grades or regrades an open answer from the grading queue, with points and an optional comment for the employee.