# Total Agent Memory (pypi · total-agent-memory)

Persistent local memory for coding agents: temporal knowledge graph, procedural and episodic recall

- Trust score: 48/100 (low)
- Change this week: −9
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- pypi · `total-agent-memory`: 48/100 (this document), [markdown](https://verifymcp.io/servers/vbcherepanov-total-agent-memory/total-agent-memory.md), [page](https://verifymcp.io/servers/vbcherepanov-total-agent-memory/total-agent-memory)

## Channel facts

- Registry: `pypi`
- Package: `total-agent-memory`
- Version: `14.0.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-20.

- **Supply Chain Security**: 24/100
  - Malware scan not yet available for this package.
  - A critical CVE affects chromadb, and no fixed version has been published yet.
  - Runs setuptools.build_meta at install time, a recognised native-build step with no shell scripting around it.
  - 16 of 113 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 35/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: no license is declared.
  - Actively maintained (last published 4 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 69/100
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 7122 tokens (~93/item across 76 items; 76 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 43/100
  - Stability observed for 13 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 80/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 40% of tool parameters carry a description.
- **Tool Safety**: 79/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 1 of 7 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "memory_eval_locomo" implies "eval" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 76 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Total Agent Memory MCP server?

Total Agent Memory runs locally as a PyPI package, launched with uvx total-agent-memory. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add vbcherepanov-total-agent-memory -- uvx total-agent-memory
```

### Cursor

```json
{
  "mcpServers": {
    "vbcherepanov-total-agent-memory": {
      "command": "uvx",
      "args": [
        "total-agent-memory"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "vbcherepanov-total-agent-memory": {
      "command": "uvx",
      "args": [
        "total-agent-memory"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add vbcherepanov-total-agent-memory -- uvx total-agent-memory
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "vbcherepanov-total-agent-memory": {
      "type": "local",
      "command": [
        "uvx",
        "total-agent-memory"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add vbcherepanov-total-agent-memory --command uvx --arg total-agent-memory
```

### Hermes

```yaml
mcp_servers:
  vbcherepanov-total-agent-memory:
    command: "uvx"
    args: ["total-agent-memory"]
```

### Netclaw

```json
{
  "McpServers": {
    "vbcherepanov-total-agent-memory": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "total-agent-memory"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add vbcherepanov-total-agent-memory -t stdio -c uvx -a total-agent-memory
```

### Other

```json
{
  "mcpServers": {
    "vbcherepanov-total-agent-memory": {
      "command": "uvx",
      "args": [
        "total-agent-memory"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-20 (score 48, +1)

No change was recorded against any check on this day. Stability & Change Management went from 40 to 43. That category is still filling its 30-day observation window: 12 days of observed history at the previous scan, 13 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-18 (score 47, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-17 (score 46, −15)

- [security regression] Malware scan: pass → unverified

### 2026-09-16 (score 61, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-15 (score 46, −11)

- [security regression] Malware scan: pass → unverified
- [functional improvement] Stability: unverified → 0.27
- [functional] Package version: 13.0.4 → 14.0.0

### 2026-09-12 (score 57, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-08 (score 42, −15)

- [security regression] Malware scan: pass → unverified

### 2026-09-07 (score 57)

First indexed and scored.

## MCP tools (76)

### `memory_recall` (~643 tokens)

Search ALL memory: decisions, solutions, facts, lessons from ALL past sessions. 6-stage pipeline: FTS5+BM25 → semantic → fuzzy → graph → (optional) CrossEncoder → (optional) MMR. Default: hybrid mode (BM25 + semantic + RRF). Use BEFORE starting any task. v11.0: routes to fast hot path when MEMORY_MODE=fast (default). Use memory_search_fast / memory_explain_search for explicit fast routing.

Input parameters:

- `branch` (string): Filter by git branch (also includes branch-agnostic records)
- `context_max_chars` (integer): Context character budget; evidence mode uses the same value as a stricter UTF-8 byte budget.
- `decisions_only` (boolean): Return only structured decisions (v8.0): type=decision AND tags contain 'structured'. Results include parsed schema payload under 'decision'.
- `detail` (string): Level of detail: 'compact' ~50 tokens/result (id+title+score), 'summary' truncates content to 150 chars, 'full' returns everything, 'auto' picks based on query complexity (paths/urls/code → full, sho…
- `diverse` (boolean): Enable MMR diversity to reduce redundant results (useful for broad queries)
- `entities` (array): Filter by extracted entity names (technology/person/project, case-insensitive)
- `evidence_followup` (boolean): Evidence mode: allow one search for an explicitly supplied missing_relation.
- `expand_budget` (integer): Max number of additional records to include via graph expansion
- `expand_context` (boolean): Add graph-related records (1-hop neighbors via knowledge graph) as 'expansion' results
- `fusion` (string): Score fusion method: 'rrf' = Reciprocal Rank Fusion (better multi-tier ranking), 'legacy' = original additive scoring
- `intent` (string): Filter by classified intent (question|procedural|fact|decision|problem|solution|incident|plan)
- `limit` (integer)
- `missing_relation` (object): Evidence mode: missing relation; subject must occur in the original question.
- `mode` (string): Progressive-disclosure mode: 'search' (default) = normal results, 'index' = ultra-compact metadata only (id+title+score+type+project+created_at, ~40-60 tok/hit, no cognitive expansion, use memory_get…
- `neighbors` (integer): Timeline/context modes: records before/after each hit; context accepts 0–3.
- `project` (string): Filter by project name
- `query` (string, required): What to search for
- `rerank` (boolean): Enable CrossEncoder re-ranking for higher precision (adds ~30ms latency)
- `topics` (array): Filter results to records tagged with any of these topics (from deep enrichment)
- `type` (string)

### `memory_timeline` (~99 tokens)

Browse session history. sessions_ago=N for 'N sessions ago', session_number=1 for first session, date_from/date_to for date ranges.

Input parameters:

- `date_from` (string): YYYY-MM-DD
- `date_to` (string): YYYY-MM-DD
- `limit` (integer)
- `project` (string)
- `query` (string)
- `session_number` (integer)
- `sessions_ago` (integer)

### `memory_index_passages` (~50 tokens)

Build local passage indexes before evidence searches. Repeat using next_after_id until remaining=0.

Input parameters:

- `after_id` (integer)
- `limit` (integer)
- `project` (string, required)

### `memory_answer` (~106 tokens)

Generate and verify a cited answer using the configured reasoning LLM. Up to one missing-relation retrieval and five LLM calls including bounded quote repair. Explicit project required. Citation offsets refer to returned evidence content. Ordinary recall remains local.

Input parameters:

- `branch` (string)
- `followup` (boolean)
- `limit` (integer)
- `max_bytes` (integer)
- `project` (string, required)
- `query` (string, required)
- `type` (string)

### `memory_save` (~413 tokens)

Save knowledge explicitly. Types: decision (MUST include WHY in context), solution, lesson, fact, convention. Auto-dedup via Jaccard + fuzzy similarity. v10: a quality gate scores the record before save; below-threshold records are rejected with a `rejected_by_quality_gate: true` response (override with MEMORY_QUALITY_GATE_ENABLED=false). Use `importance` to surface critical decisions at recall time (boosts the final RRF score). v11.0: routes to fast hot path when MEMORY_MODE=fast (default). Use memory_save_fast for explicit fast routing.

Input parameters:

- `agent_id` (string): Optional Claude Code subagent ID (x-claude-code-agent-id header / OTEL agent_id attribute, v2.1.139+). Lets recall trace which subagent produced this knowledge.
- `branch` (string): Git branch this knowledge relates to
- `content` (string, required): The knowledge to save
- `context` (string): Additional context, WHY for decisions
- `coref` (boolean): Opt into v10 coreference rewrite — expand pronouns ('after this it broke') into self-contained text using recent session history. Costs ~1s LLM round-trip; default off.
- `filter` (string): Optional content filter (pytest|cargo|git_status|docker_ps|generic_logs). Trims noisy CLI output while preserving URLs/paths/code.
- `importance` (string): Recall-time boost: critical x1.5, high x1.2, medium x1.0, low x0.8. Reserve `critical` for migration-blocking decisions and security incidents.
- `parent_agent_id` (string): Optional parent agent ID (the dispatching Agent tool / parent span). Together with agent_id forms the subagent lineage tree.
- `project` (string)
- `source_format` (string): Conversation preserves dialogue structure and bypasses automatic CLI filters.
- `tags` (array)
- `type` (string, required)

### `memory_update` (~62 tokens)

Update existing knowledge. Finds old by search query, supersedes it, creates new version.

Input parameters:

- `find` (string, required): Search query to find the old knowledge
- `new_content` (string, required): New content to replace with
- `reason` (string): Why updating

### `memory_stats` (~40 tokens)

Memory statistics with health metrics: sessions, knowledge by type/project, retention zones (active/archived/consolidated), stale records, storage size, config.

### `memory_consolidate` (~92 tokens)

Find and merge duplicate/similar knowledge records. Keeps the longest version, supersedes shorter duplicates. Reduces noise in recall results.

Input parameters:

- `dry_run` (boolean): If true, only show what would be merged
- `project` (string): Consolidate only this project (optional)
- `threshold` (number): Similarity threshold 0.0-1.0 (default 0.75)

### `memory_export` (~60 tokens)

Export all knowledge as JSON for backup or migration. Includes knowledge, sessions, and relations.

Input parameters:

- `project` (string): Export only this project (optional)
- `save_to_file` (boolean): Save to <memory-dir>/backups/ (default true)

### `memory_forget` (~56 tokens)

Apply retention policy: archive stale records (>180d, never recalled, low confidence), purge very old archived records (>365d). Keeps memory clean.

Input parameters:

- `dry_run` (boolean): If true, only show what would be affected

### `memory_wiki_generate` (~88 tokens)

v10 — Render the per-project wiki digest (top decisions, active solutions, conventions, recent changes) as Markdown. Pass `project` to refresh one wiki, omit it to refresh all active projects. Files land in <MEMORY_DIR>/wikis/<project>.md and are deterministic (no LLM call).

Input parameters:

- `project` (string): Project to refresh (omit for all)

### `memory_get` (~103 tokens)

Batched fetch by ID — complement to memory_recall(mode='index'). Returns full content for ONLY the IDs the caller chose after inspecting an index. Typical 3-layer flow: recall(mode='index') → pick IDs → memory_get(ids=[...]).

Input parameters:

- `detail` (string): 'summary' truncates content to 150 chars, 'full' returns everything
- `ids` (array, required): Knowledge record IDs (max 50 per call; extras are silently dropped)

### `memory_history` (~51 tokens)

View version history for a knowledge record. Shows the chain of superseded versions (newest → oldest), enabling time-travel through knowledge evolution.

Input parameters:

- `id` (integer, required): Knowledge record ID to get history for

### `memory_delete` (~47 tokens)

Delete a knowledge record (soft-delete). Removes from search results and ChromaDB. Use when knowledge is wrong or no longer relevant.

Input parameters:

- `id` (integer, required): Knowledge record ID to delete

### `memory_relate` (~75 tokens)

Create a typed relation between two knowledge records. Enriches graph expansion in Tier 4 search. Types: causal, solution, context, related, contradicts.

Input parameters:

- `from_id` (integer, required): Source knowledge record ID
- `to_id` (integer, required): Target knowledge record ID
- `type` (string, required): Relation type

### `memory_search_by_tag` (~57 tokens)

Search knowledge by tag. Returns all active records with matching tag (partial match). Useful for categorical browsing.

Input parameters:

- `project` (string): Filter by project (optional)
- `tag` (string, required): Tag to search for (partial match)

### `memory_extract_session` (~116 tokens)

Get pending session transcripts for knowledge extraction. Previous sessions are auto-captured on exit. Use action='list' to see pending, 'get' to read transcript, then save knowledge via memory_save, then 'complete' to mark as processed.

Input parameters:

- `action` (string, required): list: show pending sessions. get: return transcript data. complete: mark as done.
- `chunk` (integer): Chunk number for large transcripts (0-based)
- `session_id` (string): Session ID (required for 'get' and 'complete')

### `self_error_log` (~139 tokens)

Log an error/failure for pattern analysis. Call AUTOMATICALLY when: bash command fails, wrong assumption discovered, API returns error, config issue found, loop detected, or any mistake occurs. System detects patterns (3+ same category) and suggests insights.

Input parameters:

- `category` (string, required): Error category for pattern grouping
- `context` (string): What was being done when error occurred
- `description` (string, required): What went wrong: symptom, expectation vs reality
- `fix` (string): How it was fixed (empty if unresolved)
- `project` (string)
- `severity` (string)
- `tags` (array)

### `self_insight` (~172 tokens)

Manage insights from error patterns (ExpeL-style). Actions: add (create, importance=2), upvote (+1), downvote (-1, auto-archive at 0), edit, list, promote (to rule when importance>=5 AND confidence>=0.8). Call 'add' when pattern detected. Call 'upvote' when insight confirmed again.

Input parameters:

- `action` (string, required)
- `category` (string): Error category (for add)
- `content` (string): Insight text (for add/edit)
- `context` (string)
- `id` (integer): Insight ID (for upvote/downvote/edit/promote)
- `project` (string)
- `source_error_ids` (array): Error IDs that spawned this (for add)
- `tags` (array)

### `self_rules` (~174 tokens)

Manage behavioral rules (SOUL). Rules are promoted insights that shape agent behavior. Actions: list, fire (record relevance), rate (success=true/false), suspend, activate, retire, add_manual. Auto-suspend: success_rate < 0.2 after 10+ fires.

Input parameters:

- `action` (string, required)
- `category` (string): Category (for add_manual)
- `content` (string): Rule text (for add_manual)
- `id` (integer): Rule ID (for fire/rate/suspend/activate/retire)
- `priority` (integer): 1-10
- `project` (string)
- `scope` (string): global | project:<name> | category:<name>
- `success` (boolean): For rate: was rule helpful?
- `tags` (array)

### `self_patterns` (~85 tokens)

Analyze error patterns and self-improvement stats. Views: error_patterns (frequency, repeating 3+), insight_candidates (ready for promotion), rule_effectiveness (success rates, stale rules), improvement_trend (weekly errors), full_report (all). Call periodically to track improvement.

Input parameters:

- `days` (integer)
- `project` (string)
- `view` (string)

### `self_reflect` (~107 tokens)

Save a verbal self-reflection (Reflexion pattern). Call after completing a task or encountering difficulty. NOT for errors (use self_error_log). For meta-observations about strategy, approach effectiveness, process improvements.

Input parameters:

- `outcome` (string)
- `project` (string)
- `reflection` (string, required): What went well, what to improve, what to do differently
- `tags` (array)
- `task_summary` (string, required): Brief description of what was done

### `self_rules_context` (~142 tokens)

Get active behavioral rules for current session. Call at SESSION START to load rules. Returns rules filtered by project and scope. v8.0: pass `phase` to lazy-load rules relevant to current task phase — core rules (no phase tag) + rules tagged phase:<X>. Cuts prompt tokens ~70%. After task completion, rate rules: self_rules(action='rate', id=X, success=true/false).

Input parameters:

- `categories` (array): Error categories relevant to current task
- `phase` (string): Optional: lazy-load only rules relevant to this phase (core + phase-specific). Omit to get all rules.
- `project` (string)

### `rule_set_phase` (~95 tokens)

Attach or remove a phase scope on a rule (v8.0 lazy rule loading). Tag-based: manages 'phase:<X>' on the rule's tags. phase=null clears the phase tag (rule becomes core — applies to every phase). Valid phases: van, plan, creative, build, reflect, archive.

Input parameters:

- `phase` (string|null): Phase name or null to clear.
- `rule_id` (integer, required)

### `memory_observe` (~123 tokens)

Save a lightweight observation (auto-capture). No dedup, no ChromaDB — fast and cheap. Use for tracking file changes, tool usage, and session activity. Observations auto-cleanup after 30 days.

Input parameters:

- `files_affected` (array): List of affected file paths
- `observation_type` (string): Type of observation
- `project` (string)
- `summary` (string, required): What happened (e.g. 'Modified auth controller')
- `tool_name` (string, required): Which tool triggered this (Write, Edit, Bash, etc.)

### `memory_associate` (~114 tokens)

Associative recall — brain-like spreading activation through knowledge graph. Finds memories through concept resonance, not keyword search. In 'composition' mode, finds minimum set of memories covering all needed concepts.

Input parameters:

- `max_results` (integer)
- `min_coverage` (number): Min coverage for composition mode (0.0-1.0)
- `mode` (string): recall=find related, composition=build solution from parts
- `project` (string): Filter by project
- `query` (string, required): Natural language query

### `memory_graph` (~77 tokens)

Query the unified knowledge graph. Returns neighborhood of a node: connected rules, skills, memories, concepts, entities.

Input parameters:

- `depth` (integer): Traversal depth (1-3)
- `node` (string, required): Node name or ID to explore
- `types` (array): Filter by node types (rule, skill, concept, etc.)

### `memory_concepts` (~60 tokens)

List or search concepts in the knowledge graph.

Input parameters:

- `include_memories` (boolean): Include linked knowledge records
- `limit` (integer)
- `query` (string): Search concepts by name
- `type` (string): Filter by node type

### `memory_episode_save` (~133 tokens)

Save an episode — narrative of WHAT HAPPENED and HOW. Not just facts, but the journey: what was tried, what failed, what worked.

Input parameters:

- `approaches_tried` (array)
- `concepts` (array): Key concepts involved
- `frustration_signals` (integer)
- `impact_score` (number): 0.0-1.0, how significant
- `key_insight` (string): The aha moment, if any
- `narrative` (string, required): 2-3 sentence narrative of what happened
- `outcome` (string, required)
- `project` (string)

### `memory_episode_recall` (~75 tokens)

Find past episodes (experiences). Search by concepts, outcome, project, or impact.

Input parameters:

- `concepts` (array)
- `limit` (integer)
- `min_impact` (number)
- `outcome` (string)
- `project` (string)
- `query` (string): Search narrative text

### `memory_skill_get` (~57 tokens)

Find skills matching a trigger. Skills are learned procedures — HOW to do things.

Input parameters:

- `list_all` (boolean)
- `name` (string): Get skill by exact name
- `trigger` (string): Natural language trigger to match

### `memory_skill_update` (~79 tokens)

Record skill usage or refine a skill. Updates success rate and metrics.

Input parameters:

- `new_anti_pattern` (string): Anti-pattern learned from failure
- `new_steps` (array): Additional steps to add
- `notes` (string)
- `skill_id` (string, required): Skill ID
- `success` (boolean, required): Was the skill application successful?

### `memory_self_assess` (~57 tokens)

Self-assessment: how competent am I in given domains? Shows level, confidence, blind spots.

Input parameters:

- `concepts` (array): Domains/concepts to assess competency for
- `full_report` (boolean): Return full self-model report

### `memory_context_build` (~66 tokens)

Build optimal context for a query. Combines: spreading activation + knowledge graph + episodes + skills + self-model. The 'brain thinking' tool.

Input parameters:

- `max_tokens` (integer)
- `project` (string)
- `query` (string, required): What you need context for

### `memory_reflect_now` (~57 tokens)

Run reflection (the 'sleep' process). Consolidates knowledge, finds patterns, generates skill proposals, updates self-model.

Input parameters:

- `scope` (string): quick=dedup only, full=digest+synthesize, weekly=deep analysis

### `memory_graph_index` (~42 tokens)

Reindex CLAUDE.md rules and skills into the knowledge graph. Run after modifying CLAUDE.md or adding new skills.

Input parameters:

- `target` (string)

### `memory_graph_stats` (~25 tokens)

Knowledge graph statistics: nodes, edges, communities, top concepts, health metrics.

### `kg_add_fact` (~98 tokens)

Record a temporal fact assertion (subject, predicate, object). Supersedes any prior assertion with same (s,p) and different object — full history is preserved. Use for evolving architectural decisions.

Input parameters:

- `confidence` (number)
- `context` (string)
- `invalidate_previous` (boolean)
- `object` (string, required)
- `predicate` (string, required)
- `project` (string)
- `subject` (string, required)

### `kg_invalidate_fact` (~56 tokens)

Close a currently-valid fact assertion. History is retained.

Input parameters:

- `object` (string, required)
- `predicate` (string, required)
- `project` (string)
- `reason` (string)
- `subject` (string, required)

### `kg_at` (~85 tokens)

Point-in-time query: return fact assertions valid at `timestamp` (ISO 8601). Omit timestamp for currently-valid facts.

Input parameters:

- `limit` (integer)
- `object` (string)
- `predicate` (string)
- `project` (string)
- `subject` (string)
- `timestamp` (string): ISO 8601 or omit for now

### `kg_timeline` (~46 tokens)

Full chronological history of assertions for a subject.

Input parameters:

- `limit` (integer)
- `predicate` (string)
- `project` (string)
- `subject` (string, required)

### `workflow_learn` (~66 tokens)

Record a learned workflow (named sequence of steps) for future reuse.

Input parameters:

- `context` (object)
- `description` (string)
- `name` (string, required)
- `project` (string)
- `steps` (array, required)
- `trigger_pattern` (string)

### `workflow_predict` (~57 tokens)

Predict outcome (success probability, avg duration) for a workflow by id OR by trigger keyword. Uses Laplace-smoothed success rate.

Input parameters:

- `project` (string)
- `trigger` (string)
- `workflow_id` (string)

### `workflow_track` (~70 tokens)

Record a workflow execution outcome. Outcome ∈ {success|failure|partial|aborted}. Aggregates update automatically.

Input parameters:

- `duration_ms` (integer)
- `error_details` (string)
- `notes` (string)
- `outcome` (string, required)
- `workflow_id` (string, required)

### `file_context` (~62 tokens)

BEFORE editing a file, call this to surface past errors, lessons, and related rules for that file path. Returns risk_score ∈ [0, 1].

Input parameters:

- `limit` (integer)
- `path` (string, required)
- `project` (string)

### `learn_error` (~108 tokens)

Structured error capture: file, error, root_cause, fix, pattern. After N (default 3) errors share the same pattern, a prevention rule is auto-synthesized into the rules table.

Input parameters:

- `category` (string)
- `error` (string, required)
- `file` (string, required)
- `fix` (string, required)
- `pattern` (string, required)
- `project` (string)
- `root_cause` (string, required)
- `severity` (string)

### `session_init` (~47 tokens)

At session start: return the most recent unconsumed end-of-session summary with highlights / pitfalls / next_steps.

Input parameters:

- `mark_consumed` (boolean)
- `project` (string)

### `session_end` (~132 tokens)

End-of-session capture: summary + highlights + pitfalls + next_steps so the next session can resume cleanly. Set auto_compress=true to have the LLM generate the missing summary/next_steps/pitfalls from stored session artifacts (or from an optional `transcript`).

Input parameters:

- `auto_compress` (boolean)
- `highlights` (array)
- `next_steps` (array)
- `open_questions` (array)
- `pitfalls` (array)
- `project` (string)
- `session_id` (string, required)
- `summary` (string)
- `transcript` (string)

### `ingest_codebase` (~69 tokens)

Parse a file or directory into semantic AST chunks (functions, classes, methods) across 8 languages. Returns chunk count + sample.

Input parameters:

- `include` (array): Extension allowlist e.g. ['.py','.go']
- `path` (string, required)
- `sample_limit` (integer)

### `analogize` (~70 tokens)

Find past solutions/lessons from OTHER projects whose feature set overlaps with the given problem text (Jaccard similarity).

Input parameters:

- `exclude_project` (string)
- `limit` (integer)
- `min_score` (number)
- `only_types` (array)
- `text` (string, required)

### `benchmark` (~48 tokens)

Run the eval harness: recall_at_k, prevention_rate, latency percentiles. Loads scenarios from evals/scenarios/*.json by default.

Input parameters:

- `scenarios_path` (string): Custom scenarios dir or file

### `memory_save_fast` (~160 tokens)

v11.0: same as memory_save but routes through the fast hot path (skip_quality=True, no LLM, no async-blocking). Use when you want to bypass the v10 quality gate without flipping the env flag.

Input parameters:

- `agent_id` (string): Optional Claude Code subagent ID (v2.1.139+)
- `branch` (string)
- `content` (string, required)
- `context` (string)
- `filter` (string)
- `importance` (string)
- `parent_agent_id` (string): Optional parent agent ID (the dispatching span)
- `project` (string)
- `source_format` (string)
- `tags` (array)
- `type` (string, required)

### `memory_search_fast` (~116 tokens)

v11.0: like memory_recall but with rerank=False, diverse=False forced. Deterministic fast path — zero LLM, FastEmbed-only.

Input parameters:

- `branch` (string)
- `detail` (string)
- `embedding_space` (string|array): Filter to one or more embedding spaces (text|code|log|config).
- `fusion` (string)
- `limit` (integer)
- `project` (string)
- `query` (string, required)
- `type` (string)

### `memory_explain_search` (~108 tokens)

v11.0: same as memory_search_fast but returns a per-tier breakdown (fts/semantic/graph/fuzzy/hyde with raw scores, the merged RRF list, rerank_applied flag, embedding_space). Use to debug why a record did or didn't surface for a query.

Input parameters:

- `embedding_space` (string|array)
- `limit` (integer)
- `project` (string)
- `query` (string, required)
- `type` (string)

### `memory_warmup` (~40 tokens)

v11.0: pre-load FastEmbed model and open the vector store, so the first save/search after process start doesn't pay model-load latency.

### `memory_perf_report` (~57 tokens)

v11.0: dump in-process telemetry counters (search_total_ms, embed_ms, fts_ms, vector_ms, llm_calls, network_calls) plus persistent embedding_cache stats. Use to verify the fast hot path stays clean.

### `memory_rebuild_fts` (~55 tokens)

v11.0: drop and rebuild the SQLite FTS5 virtual table from `knowledge` rows. Useful after migrations or content_type column changes that the FTS triggers didn't see. Returns {rebuilt: int}.

### `memory_rebuild_embeddings` (~114 tokens)

v11.0: re-encode every record (or every record in a given embedding space) and update the binary + float32 vectors. Idempotent. Pass embedding_space='code' to refresh only code rows after switching the code embedder. Returns {rebuilt: int, skipped: int}.

Input parameters:

- `batch_size` (integer)
- `embedding_space` (string|array): Optional: only re-encode rows in these spaces.
- `limit` (integer)
- `project` (string)

### `memory_eval_locomo` (~128 tokens)

v11.0 Phase 8: run the LongMemEval-style recall+prevention scenario suite (loaded from evals/scenarios/) against the live store. Forces MEMORY_MODE=fast by default. Returns {scenarios_total, scenarios_passed, recall_at_5, recall_at_10, latency_ms, mode, llm_calls_during_eval, network_calls_during_eval}.

Input parameters:

- `limit` (integer): Cap how many scenarios to run.
- `mode` (string)
- `scenarios_path` (string): Optional override path.
- `top_k` (integer)

### `memory_eval_recall` (~71 tokens)

v11.0 Phase 8: generic recall benchmark on a dataset path or a small built-in fixture. Same payload shape as memory_eval_locomo.

Input parameters:

- `dataset_path` (string)
- `limit` (integer)
- `mode` (string)
- `top_k` (integer)

### `memory_eval_temporal` (~58 tokens)

v11.0 Phase 8: temporal recall using temporal_kg + temporal_filter. Returns {status: 'not_implemented', ...} when modules are missing.

Input parameters:

- `limit` (integer)
- `mode` (string)

### `memory_eval_entity_consistency` (~44 tokens)

v11.0 Phase 8: verifies entity_dedup canonicalization is stable across repeated saves of variant tag spellings.

Input parameters:

- `mode` (string)

### `memory_eval_contradictions` (~67 tokens)

v11.0 Phase 8: runs contradiction_detector against a labelled fixture. Requires balanced/deep mode (LLM). Returns {status: 'not_implemented', ...} if module is unavailable.

Input parameters:

- `fixture_path` (string)
- `mode` (string)

### `memory_eval_long_context` (~70 tokens)

v11.0 Phase 8: large-context recall scenario. Saves N records and queries them at the tail. Reuses eval_harness scenarios tagged 'long_context' if present.

Input parameters:

- `mode` (string)
- `n_records` (integer)
- `top_k` (integer)

### `classify_task` (~39 tokens)

v8.0: classify task into L1-L4 complexity + suggested phases.

Input parameters:

- `description` (string, required)
- `project` (string)

### `task_create` (~51 tokens)

v8.0: start a task in `van` phase (auto-classifies level if missing).

Input parameters:

- `description` (string, required)
- `level` (integer)
- `task_id` (string, required)

### `phase_transition` (~51 tokens)

v8.0: advance a task to the next phase.

Input parameters:

- `artifacts` (object)
- `new_phase` (string, required)
- `notes` (string)
- `task_id` (string, required)

### `task_phases_list` (~33 tokens)

v8.0: list all phases of a task in chronological order.

Input parameters:

- `task_id` (string, required)

### `save_intent` (~94 tokens)

Persist one user prompt into the `intents` table (same source as the UserPromptSubmit hook). Use when programmatically seeding intents — the hook covers normal interactive usage. Dedupes same prompt within 5 min per session.

Input parameters:

- `project` (string): Project slug
- `prompt` (string, required): User prompt text as submitted
- `session_id` (string): Session id (defaults to current MCP session)

### `list_intents` (~55 tokens)

List recent user prompts from the intents table, newest first. Filter by project and/or session. Max 500 rows.

Input parameters:

- `limit` (integer)
- `project` (string)
- `session_id` (string)

### `search_intents` (~65 tokens)

Substring search over user prompts (LIKE). Returns newest match first. Useful for 'what did I ask about X' without mining transcripts.

Input parameters:

- `limit` (integer)
- `project` (string)
- `query` (string, required): Substring to match in prompt text

### `save_decision` (~166 tokens)

v8.0: save a structured architectural decision (options + criteria matrix + rationale + discarded). Adds `structured` tag and a JSON blob in context. Use for Creative-phase outputs; plain type=decision memory_save still works.

Input parameters:

- `criteria_matrix` (object, required): criterion -> {option_name: rating 0-5}
- `discarded` (array): Option names rejected (subset of options - {selected})
- `options` (array, required): Options considered: [{name, pros[], cons[], unknowns[]}, ...]
- `project` (string)
- `rationale` (string, required): Why this option was chosen
- `selected` (string, required): Chosen option name (must be in options)
- `tags` (array)
- `title` (string, required): Short decision title

### `memory_recall_iterative` (~107 tokens)

v11.0 W1-B: IRCoT-style iterative retrieval. Decomposes the query into sub-questions, retrieves per sub-question, and asks a planner LLM whether more retrieval is needed. Best for multi-hop questions. Returns unified evidence + provenance per iteration.

Input parameters:

- `k_per_iter` (integer)
- `llm_model` (string)
- `max_iters` (integer)
- `project` (string)
- `query` (string, required)

### `memory_temporal_query` (~152 tokens)

v11.0 W1-C: deterministic temporal reasoning — Allen interval relations, duration arithmetic (days/weeks/months/years), and natural-language date normalization (en + ru). Pass op=relation|duration_between|normalize.

Input parameters:

- `a` (string): ISO datetime — duration_between
- `a_end` (string)
- `a_start` (string): ISO datetime — relation only
- `anchor` (string): ISO datetime anchor for relative phrases
- `b` (string)
- `b_end` (string)
- `b_start` (string)
- `lang` (string)
- `op` (string, required)
- `phrase` (string): Natural-language date — normalize

### `memory_entity_resolve` (~118 tokens)

v11.0 W1-F: resolve a mention to its canonical entity within a project+type. Cross-session coreference via name/alias index + embedding cosine. Returns canonical_id, matched_via, and is_new flag. Pronouns return -1.

Input parameters:

- `create_if_missing` (boolean)
- `mention` (string, required)
- `project` (string)
- `threshold` (number): Cosine similarity threshold for embedding match.
- `type` (string): Entity type: person, technology, project, company, ...

### `memory_consolidate_status` (~52 tokens)

v11.0 W2-G: report the consolidation daemon state — per-project last-run, active locks, recent activity. Use to verify the idle-project worker is making progress without interfering with active work.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/vbcherepanov-total-agent-memory/total-agent-memory#diagnostics

## Score history

- 2026-09-20: 48
- 2026-09-19: 47
- 2026-09-18: 47
- 2026-09-17: 46
- 2026-09-16: 61
- 2026-09-15: 46
- 2026-09-14: 57
- 2026-09-13: 57
- 2026-09-12: 57
- 2026-09-11: 42
- 2026-09-10: 42
- 2026-09-09: 42
- 2026-09-08: 42
- 2026-09-07: 57

## Common questions

### What is the Total Agent Memory MCP server?

Total Agent Memory is an MCP server listed in the public MCP registry as io.github.vbcherepanov/total-agent-memory. Persistent local memory for coding agents: temporal knowledge graph, procedural and episodic recall. This page covers its PyPI package (total-agent-memory).

### Is the Total Agent Memory MCP server safe to use?

Total Agent Memory scores 48 out of 100 on VerifyMCP. We recorded 8 known advisories against it as of 20 September 2026. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Total Agent Memory MCP server expose?

Total Agent Memory exposes 76 tools: memory_recall, memory_timeline, memory_index_passages, memory_answer, memory_save, and 71 more. Their descriptions and schemas cost roughly 7,122 tokens of context every time the server is loaded.

### Is the Total Agent Memory MCP server still maintained?

Total Agent Memory is still listed as active in the MCP registry. We last reached this channel on 20 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- PyPI project: https://pypi.org/project/total-agent-memory/
- Socket report: https://socket.dev/pypi/package/total-agent-memory
- Repository: https://github.com/vbcherepanov/total-agent-memory
- Website: https://totalmemory.dev/
- Changelog RSS feed: https://verifymcp.io/servers/vbcherepanov-total-agent-memory/total-agent-memory.xml
- Changelog JSON feed: https://verifymcp.io/servers/vbcherepanov-total-agent-memory/total-agent-memory.json
- HTML version of this page: https://verifymcp.io/servers/vbcherepanov-total-agent-memory/total-agent-memory