Store a memory (episodic or semantic).

Save one conversation turn in a single call: splits the text into sentences and stores each with automatic cues. Call this after every user/assistant exchange to keep memory automatic.

Recall memories matching a query.

Run several recall queries in one call; returns one result group per query in input order (single MCP round trip for a whole question list).

Run sleep consolidation (promote, prune, reflect, conflicts).

Metacognitive check: confidence, contradictions, gaps, blocked.

Revise a memory (reconsolidation).

Move a memory to the recycle bin.

Restore a memory from the recycle bin.

Memory statistics.

Calibrate the forgetting rate from real retrieval history (median survival span -> decay rate).

Re-embed active memories missing from the vector index (repairs a failed batch embedding).

Recently used memories for prompt injection.

List memories due for spaced review; optionally prefer desirable-difficulty items (hard but likely to succeed).

Record a spaced-repetition outcome (success/fail).

Agent planning: turn a goal into an ordered step plan, reusing the person's own past steps or a referenced person's steps as an analogical template.

Reasoning recall: assemble the full premise pack for a math / compare / transitive question.

Record an execution outcome (success/fail + note) for an agent project step (evidence accumulation).

Re-plan after a failed step: move the failing person's step to the end (avoided), keep successful alternatives, and store the re-planning decision.

Predict a step's success probability from its outcome history (prediction-error updated records).

Sleep replay: strengthen surprising outcome records and consolidate each step's experience into a '历史成功率' summary.

Retrieve memories for a query: returns the top-k matches with content, score, confidence flag and reasons (context-dependent recall and all retrieval mechanisms apply).

Return active memory conflicts: same cue, both confident, different content. Agents can use this to spot contradictions before answering.

For each memory conflict, score both sides (evidence, confidence, recency, source trust) and recommend which to keep or ask the user to clarify.

Return a memory-health snapshot: active counts by kind, average strength/importance, how many memories are due right now, and how many conflicts exist.

Apply a batch of spaced-repetition outcomes: each answer is {id, success}; returns the adaptive scheduler state (streak, next review) for every card.

Export all active memories as a portable JSON payload (versioned, includes retrieval stats).

Import memories from an export payload; returns the number imported.

Run one complete practice session: returns the coming session plan plus the scored report for the answers (difficulty and next-review suggestions).

Run the full sleep cycle, then return the consolidation summary, weak-important replay count, and refreshed practice plan/forecast.

Deep lifecycle audit: active/recycled counts, revised and emotional traces, conflicts, due now, average retrievability and importance.

Merge near-duplicate traces on demand; returns how many duplicates were merged.

Resolve memory conflicts on demand: lopsided-evidence conflicts retire the stale trace, balanced ones lose confidence (accommodation + REM-style resolution).

Estimate upcoming review pressure: due now, overdue, due within N days, weak traces, and a weighted load index.

Add or remove tags (cues) on memories in bulk; tags are first-class retrieval cues.

Return the most recent recall entries (query, top result, confidence, timestamp) as a bounded audit log.

Preview which episodic traces the sleep prune pass would recycle (unimportant, never accessed, old) - without deleting anything.

Find confusable memory pairs by content-token overlap (near-duplicates or pairs needing better separation).

Summarize the memory association network: total links, connected/isolated memories, average links and the most-connected memories (spreading activation).

Register a future intention (prospective memory): content, deadline and optional context cue.

List active intentions whose deadline has arrived.

Mark an intention as completed.

Cancel an intention without completing it.

Summarize the intention register: active, overdue, next upcoming, completed and cancelled counts.

Group memories into topic schemas by their primary cue: cluster size, average importance, kind mix and samples (schema theory, Bartlett 1932).

Temporarily block memories from retrieval (directed forgetting): traces stay in the store but stop surfacing in recall until unsuppressed.

Restore suppressed memories to retrieval.

List currently suppressed memories with previews.

Autobiographical timeline: episodic memories in chronological order grouped by day, optionally within a start/end window.

Report cue-crowded clusters (too many memories on one cue) that cause interference, with a suggestion to add differentiating cues (Wickens 1972).

Summarize the store as lifetime periods: group episodic traces into time buckets with event counts, top themes, average importance and highlights (Conway & Pleydell-Pearce 2000).

Detect intention clashes: two active intentions due within a short window, or sharing the same context cue.

One overall memory-health score (0-100) with itemized penalties: linked ratio, crowded cues, conflicts, overdue/clashing intentions and suppressed memories (metacognitive monitoring).

Summarize what the memory holds: topics with counts and average retrievability, plus a weak/ok/strong strength histogram. Powers the human-readable memory map chart.

Export the memory network as a knowledge-graph edge list (nodes + deduplicated undirected edges) for external visualization (semantic networks, Collins & Quillian 1969).

Pack the best matching memories for several queries into one bounded context: deduplicated, score-ranked, character-budgeted (cognitive load, Sweller 1988).

Explain one memory's full state: content, cues, retrievability, importance, strength, confidence, evidence, links, suppression, access and review state.

Compare two memories: token overlap, shared cues and a verdict (duplicate / conflict / distinct) for source monitoring and schema integration (Johnson et al. 1993).

Order active intentions as an action queue: overdue first, then upcoming by deadline, with clashing intentions flagged (goal-directed priority, ACT-R; Anderson 1983).

Summarize a cluster of related memories as one gist: shared cues, frequent terms, evidence and previews (fuzzy-trace theory, Brainerd & Reyna 1990).

Walk the association network hop by hop from a start memory: which memories are 1 hop, 2 hops etc. away (spreading activation, Collins & Loftus 1975).

Summarize one work session's memories: semantic facts, episodic events, plus conflict and duplicate pairs for post-session consolidation.

Compare topic distribution between the two most recent periods: which themes grew, shrank, appeared or disappeared (schema reconstruction, Bartlett 1932).

Report review coverage per topic schema: memory count, reviewed count, coverage ratio, average retrievability/importance and status.

Rank memories by forgetting risk (importance x forgetting): the riskiest ones should be reviewed first.

Score a Chinese agent plan's quality: step count, explicit verbs, dependency ordering, duplicates and alignment with project memories (cognitive control, Miller & Cohen 2001; means-ends analysis, Newell & Simon 1972).

Assemble a project brief from related memories and intentions: background, known requirements, known risks and pending actions (schema activation, Bartlett 1932).

Sanity-check numbers and units in a Chinese math or physics problem: unit mixes, division by zero, and consistency with known facts in memory (number sense, Dehaene 1997; mental models, Johnson-Laird 1983).

Retrieve supporting memories for each plan step so the agent executes with context (working memory pulls from long-term memory; Baddeley & Hitch 1974).

Build a plan's dependency graph and critical path (hierarchical planning, Miller & Cohen 2001; critical-path method): levels, predecessors, parallel groups and the gating chain.

Score project risk from memories and intention state: known problem traces, conflicts, overdue intentions and clashing schedules (memory-driven risk management).

Track execution status of each plan step (pending / in_progress / done / blocked) with a completion ratio (goal monitoring, Miller & Cohen 2001).

Rewrite a weak Chinese plan into an executable one: normalize steps to action verbs, remove duplicates and order along the standard build flow (executive planning, Miller & Cohen 2001).

Extract lessons learned from project memories: successes, failures and lessons as reusable schemas (schema reuse, Bartlett 1932).

Estimate per-step and total effort for a plan, including critical-path hours and a 20% buffer for the planning fallacy (Buehler et al. 1994).

Review a finished plan against its results: success rate, score, verdict, patterns and distilled lessons (post-task metacognitive monitoring, Koriat & Goldsmith 1996).

Measure retrieval quality across queries: average top score, retrievability, hit rate and weak rate (metacognitive monitoring of retrieval, Koriat & Goldsmith 1996).

Explain why a query recalls what it recalls: candidates scanned, top results with scores and reasons (metacognitive explanation).

Build a replay-friendly reasoning trace from stored memories: recall evidence, extract quantities, build per-step trace and optionally store the derived conclusion as an inference memory (math reasoning circuits; Menon, 2016; Watanabe et al., 2023).

Replay goal-related memories to plan the next move: recall evidence, extract past lessons, reactivate overdue intentions and score replay readiness (prefrontal-hippocampal replay; Jensen et al., 2024; Watanabe et al., 2023).

Check whether the working set fits working-memory capacity and recommend topic chunking when overloaded (7±2 chunks, Miller 1956; 4±1 focus, Cowan 2001; cognitive load, Sweller 1988).

Build a spaced review schedule: fading memories early, strong ones later, topics interleaved (distributed practice; Cepeda et al., 2006).

Find cross-topic memory pairs with shared structure for analogical transfer (structure-mapping; Gentner, 1983; Holyoak & Thagard, 1995).

Recommend each memory's next review interval from retrieval history (adaptive spacing; Karpicke & Bauernschmidt, 2011).

Personalize each memory's forgetting forecast from retrieval history and predict days until retrievability crosses a threshold (individual forgetting rates; Murre & Chessa, 2011).

Mentally rehearse a plan before executing: predict each step's success probability from outcome history, flag the weakest step and offer a remembered fallback (constructive episodic simulation; Schacter & Addis, 2007).

Climb the math abstraction ladder (concrete -> symbolic -> general rule), using formulas already stored in memory (Amalric & Dehaene, 2019; concreteness fading).

Run a mental physics simulation: detect scene type, extract quantities, recall the applicable law from memory (or built-in rules) and play the scene forward in ordered phases (intuitive physics engine; Battaglia et al., 2013; Fischer et al., 2016).

Monitor adherence to the spaced-review schedule: flag overdue reviews, report an adherence ratio and plain advice (Cepeda et al., 2006; self-regulated learning monitoring).

Build a ready-to-run learning loop: what to review first, one self-test question for the weakest topic, and the snapshot to take afterwards (spacing + testing effect + knowledge tracing).

Run one end-to-end learning session: score practice attempts, diff a second snapshot against the baseline and plan the next loop (testing effect + knowledge tracing).

Show how a multi-concept Chinese question is split into chunks, which memories cover each chunk and the final top-k (working-memory chunking; Miller, 1956).

Show which memory the time-anchor pass inserted for a '上次/下次/最近/什么时候' style question, so agents can verify last-vs-next retrieval picks the record with the right date (ordinal time processing; Gauthier et al., 2020). Read-only.

Active retrieval practice: list due memories as cues only (no answer), for testing-effect self-quizzing.

Score a retrieval attempt, apply testing-effect reinforcement, and return the correct content as feedback.

Score a whole practice round (list of id/attempt) and return one session report with per-card feedback.

Return the next practice session as a review plan: each card with its scheduled next review time, current retrievability, and historical success rate.

Forecast which memories are due within the next N days, with due times, so the agent can plan a week of reviews ahead of time.