SmartMemory

List active decisions with optional filtering.

Get full provenance chain for a decision.

Record supporting evidence for a decision.

Mark a requirement on a pending decision resolved by a memory item.

Retract a decision, marking it as no longer valid.

Search for active decisions related to a topic.

Replace a decision with a new one, marking the old as superseded.

Activate a pending decision if all requirements are resolved (no-op otherwise).

Load recent session context and related decisions for a work topic.

Log a friction event encountered during development.

Search past development decisions by keyword, feature, or time range.

Record an architectural or design decision as a decision memory.

Record a code pattern or convention as procedural memory.

Save a development session summary as an episodic memory.

**Deprecated:** CORE-MEMORY-DYNAMICS-1 M1b moved routing to at-ingest via the ConsolidationRouter. This tool is a no-op kept for caller compatibility.

Run opinion reinforcement — update confidence scores based on new evidence.

Get status of memory evolution processes.

Run observation synthesis — create entity summaries from scattered facts.

Run opinion synthesis — detect patterns in episodic memories and form opinions.

Trigger a memory evolution cycle — runs clustering, deduplication, and consolidation.

Retrieve a structured surfacing response (CORE-MEMORY-DYNAMICS-1 M1a). Returns JSON matching ``smart-memory-docs/docs/features/CORE-MEMORY-DYNAMICS-1/context-api-contract.json``. Cross-type retrieval, ``strategy_used="fast:recency"``. Standalone MCP does not currently compose anchors.

Update memory system based on user feedback.

Ground a memory item to an external source URL for provenance.

Get memory health summary — item counts, health score, and detected issues.

Get maintenance status — orphaned, stale, and low-confidence memory counts.

Apply personalization settings — traits and preferences for memory retrieval.

List available extractors and enrichers.

Reflect on memory patterns — identify key concepts, top entities, and dominant topics.

Authenticate with a SmartMemory API key. Restart MCP server to unlock PRO tools.

Add a memory item directly without the NLP pipeline.

Check if recent outputs have drifted from anchored requirements.

Clear (deactivate) anchors for a session.

Graduate active anchors to persistent decisions.

List active anchors for a session.

Set a spec anchor to pin a requirement or constraint for the session.

Enable or disable automatic memory lifecycle. When enabled, SmartMemory automatically recalls context at session start, observes tool calls, distills conversation turns, learns from errors, and persists session summaries. Zero manual tool calls needed. Session-scoped overrides — settings apply to the current session only, not persisted to config.toml. Args: enabled: Activate (True) or deactivate (False) automatic lifecycle. recall_strategy: "session_only" | "topic_change" | "every_prompt". orient_budget: Max tokens for session-start context injection. recall_budget: Max toke…

Check for matching past failures before retrying.

Clear all memories permanently (requires confirm=True).

Delete a memory item by ID.

Ingest a conversation turn pair into pending memory for later recall.

Explain a memory's full provenance: origin, every belief the system held for it over time, what replaced it, what it derives from, and whether its history is cryptographically intact. The single-call audit answer (PLAT-AUDITABLE-MEMORY-1). FREE tier by design: agents should always be able to answer "how do you know that?". chain_verified null means nothing to verify (legacy or unversioned) — it is NOT a tamper warning.

Export all memories as an OKF bundle directory or tar.gz archive.

Report which search results you used from a previous memory_search call. Call this after using results from memory_search to help SmartMemory learn which memories are actually useful. Pass the search_session_id from the memory_search response and the item_ids you incorporated into your response. Args: search_session_id: The session ID returned at the bottom of the memory_search output (e.g. "search:ws123:abc456def789"). result_used: List of item_ids from the search results that you used. Pass an empty list if none of the results were useful.

Retrieve a memory item by ID with full content and metadata.

Return the ``## Detection patterns`` catalog from local rule files. Distinct from ``pattern_query``/``pattern_get``/``pattern_list`` (which read the graph-backed Pattern *catalog*): this reads the per-rule ``## Detection patterns`` markdown blocks from ``{rule_type}_*.md`` files on the local filesystem. Harnesses (Compose's ``COMP-POLICY-CHECK``, raw Claude Code, Cursor) fetch this once per session and run their own pre-response check — scan a candidate response against ``patterns``, suppress when a recent user turn matches a ``suppression_signal``. Args: rule_id: if given, return only t…

Losslessly import an OKF bundle through the direct add path.

Ingest content through the full NLP pipeline with entity extraction.

Ingest a conversation as session chunks with full pipeline processing (RLM-1g). Groups turns into sessions (by explicit boundaries or auto-chunking), runs each chunk through the full extraction pipeline, and creates a conversation container node with PART_OF edges. Args: turns: List of dicts with "role"/"speaker" and "content" keys. session_boundaries: Turn indices where sessions start (e.g. [0, 50, 120]). conversation_id: User-supplied ID (auto-generated if None). session_dates: ISO date per session for metadata. turns_per_chunk: Max turns per auto-chunk (default 15). …

Ingest a document from a URL or file path. Creates a parent document node (INDEXED) and chunk nodes (FULL, embedded) linked via PART_OF edges. Deduplicates by source URL and content hash. Args: source: Public URL (http/https), or a file path in local mode only (.txt, .md, .pdf, .docx). source_type: "html" | "pdf" | "docx" | "txt" | "markdown" | "auto". chunk_size: Max characters per chunk (default 2000). chunk_strategy: "paragraph" | "sentence" | "markdown" | "recursive". reference: Mark nodes as reference material.

Ingest structured data via a registered handler, bypassing NLP pipeline.

List memories with pagination, optionally filtered by exact metadata match. metadata_key/metadata_value must be given together. Nested keys use dot syntax (e.g. `profile.tier`). This is the supported replacement for memory_search_by_metadata, whose endpoint is deprecated (GRAPH-API-1l).

Log an agent failure for cross-session error recovery.

Migrate all memories to a different backend via a temporary OKF bundle.

Get all active plans.

Create a plan with optional task nodes.

Get a plan with all its tasks.

Update a task's status within a plan (pending, in_progress, complete, blocked).

Compile active workspace decisions into a Stratum policy bundle. ``workflow`` is echoed in the selector for the runner. ``domain`` narrows the source decisions. The returned JSON is the policy-exchange contract bundle and is identical for local and hosted backends.

Recall recent and relevant memories for the current context. Hosted note: this always takes the remote recall path. The alternative branch builds a working context through the `smartmemory` core activation scorer (round 4, note 2), which the hosted server does not ship — so `session_id` and `cite=True` are refused rather than silently downgraded.

Assemble the most useful context that fits in a token budget. Returns one priority-ordered block (active plan, anchors, latest snapshot, tier-1 user content, tier-2 graduated content, notes) packed to fit ``budget_tokens``, plus a manifest accounting every token spent and every item truncated or dropped (CORE-RECALL-BUDGET-1). ``query`` ranks each section by relevance; omit it to rank by recency. ``sections`` overrides the default list/order/caps as ``{name, cap_tokens}`` entries. ``preset`` selects a named section set instead: pass ``"wakeup"`` with a small budget (~300 tokens) at session s…

Consolidate fragmented entity aliases over the workspace graph. Merges each unambiguous single-token alias node (e.g. "Hudson") into its multi-token canonical ("Rock Hudson") over the COMPLETE graph, redirecting the alias's edges onto the canonical and abstaining on collisions ("Hudson" with both "Rock Hudson" and "Rochelle Hudson" present). Run after a bulk ingest, when the full ambiguity picture is present. Args: dry_run: If True, report the resolve/abstain plan without mutating the graph. disambiguate: Opt-in (CORE-GRAPH-ALIAS-DISAMBIG-1, default False). Additionally recover …

Search memories using semantic similarity with optional hybrid mode. Hosted note: `cite=True` is not available — citation formatting runs in the `smartmemory` core package, which the hosted server does not ship.

Advanced search using Similarity Graph Traversal (SSG) algorithms.

Search memories by exact metadata key-value match.

Get memory count statistics grouped by type.

Update a memory item's properties (CORE-CRUD-UPDATE-1). - ``content``/``metadata``: convenience — folded into the properties dict. - ``properties``: advanced — direct node-property update. Takes precedence. - ``write_mode``: "merge" (default) or "replace".

Fetch one pattern by id, or null if not found.

Return every active pattern (no filters).

Query the adherence pattern catalog. Filters are conjunctive. ``scope`` does case-insensitive substring matching against each pattern's declared scope list (so ``".py"`` matches ``"**/*.py"`` and vice-versa). ``severity`` is one of ``info | warn | error``. ``free_text`` matches title, content, and rationale (case-insensitive substring).

Ask a question about a peer and get an answer synthesized from their memory. The zero-schema front door: no schema, no memory type, no ontology. Gathers the peer's expertise records, their recent messages (optionally scoped to one session), and one graph hop out of the top hits, then synthesizes a single answer over that context. Returns ``{answer, peer_id, reasoning_level, model, sources}`` matching ``peer-chat-contract.json``; ``sources`` entries carry ``item_id``, ``memory_type``, ``content_preview`` and ``channel``. Local-backend only in Phase 1: the hosted REST route is not built yet.

Auto-centered conversation read (CORE-RECALL-CENTERED-1 Phase 2). Given a matched conversation-chunk ``item_id`` (from a recall hit's ``conversation_handle``), return a char-budgeted ASYMMETRIC window of the surrounding conversation chunks (~``before_ratio`` back / ``after_ratio`` forward; leftover spills to the other side) plus a continue-cursor — so a caller pulls just the relevant slice of a long conversation into context instead of the whole transcript. "Centered" is over neighbour 15-turn chunks, not individual turns. Returns ``{window_items, window_text, handle, continue_cursor:{prev_p…

Challenge an assertion against existing knowledge to detect contradictions.

Extract reasoning traces from content — detects chain-of-thought patterns.

Get multi-dimensional confidence score for a decision (evidence, recency, consensus, directness).

Build an auditable proof tree for a decision, tracing evidence back to sources.

Route a query to the cheapest effective retrieval method (symbolic, semantic, or hybrid).

Query stored reasoning traces — ask 'why' questions about past decisions.

Resolve a conflict between assertions via Wikipedia, LLM, grounding, or recency.

Switch to a different workspace/team.

Search your own past Claude Code and Codex sessions by meaning (DIST-CC-INGEST-1 Phase 4). Use it to recover prior context — "have I hit this error before?", "why did we choose X?", "what did I try last time?" — instead of re-deriving it. Searches only sessions already imported by `transcripts index`; it reports when nothing has been imported rather than returning an empty result. Local-only. Args: query: What to look for, in natural language. top_k: Number of sessions to return (default 5). source: "claude-code", "codex", or "all" (default). project: Optional repo path — kee…

Report how much of your Claude Code / Codex history is actually searchable (DIST-CC-INGEST-1 Phase 4), and whether an import is running right now. Call this when `transcript_search` finds nothing you expected: the usual cause is that the long-running import has not finished, not that the memory is absent.

Show current session: user, team, tier, and backend mode.

Get notes that link TO this note (backlinks).

Detect knowledge clusters in your Zettelkasten.

Get all connections (backlinks + forward links) for a note.

Find unexpected connections (serendipitous discovery) for a note.