Atlas / MCP servers / aiconnai / engram

engramBLOCK

Name: engram
Author: aiconnai

mcp/aiconnai/engram

MCP server by aiconnai · ai memory · claude code · context engineering · Audited 2026-10-11

MCP memory server for Claude Code, Cursor and AI agents - Rust local-first AI memory with hybrid search, SQLite, knowledge graph and Python/TypeScript SDKs

Verdict

BLOCK

Grade

Trust score

41 /100

Exposed tools

200 203r · 80w · 23d

Transport

—

License

MIT

Stars

Overview

From the repository's own README, as read at the audited commit. Badges and raw HTML are left out.

Persistent, local-first memory engine for AI agents across Frontier LLMs.

[](https://github.com/aiconnai/engram/actions/workflows/ci.yml) [](https://github.com/aiconnai/engram/releases) [](https://aiconnai.github.io/engram/) [](LICENSE) [](https://crates.io/crates/engram-core) [](https://docs.rs/engram-core) [](sdks/python) [](sdks/typescript) [](docs/MCP_TOOLS.md)

Website & Interactive Playground
MCP Tools Catalog
System Architecture
Quickstart Guide
Using Engram in a Repo
Comparison Guide
Contributing
Security Policy

Engram is an offline, high-performance Rust memory engine for teams shipping autonomous AI agents across the modern AI stack. Native adapters and first-class Model Context Protocol (MCP) support cover Claude Code, Cursor & Cursor Rules, Google Antigravity, OpenAI Agents SDK, Gemini 3.7 Flash, DeepSeek-V4-Pro, Grok 4.6, GPT-5.6 Sol, LangGraph, CrewAI, LlamaIndex, and FastMCP.

It organizes decisions, transcripts, architecture notes, and repos into SQLite with sub-millisecond retrieval, 3-way hybrid search (BM

Read from source at commit c1795008aa52OBSERVED · 2026-10-11

Connect

Built from this server's own package name, version and transport as found in its source — not copied from anyone's documentation, so it cannot drift against a page we do not control. Replace the environment placeholders with a token scoped to the least it needs.

claude-code

claude mcp add engram-client --env ENGRAM_HTTP_API_KEY=${ENGRAM_HTTP_API_KEY} --env ENGRAM_LIVE_API_KEY=${ENGRAM_LIVE_API_KEY} --env ENGRAM_LIVE_CLIENT_KEY=${ENGRAM_LIVE_CLIENT_KEY} -- npx -y [email protected]

claude-desktop

{
  "mcpServers": {
    "engram-client": {
      "command": "npx",
      "args": [
        "-y",
        "[email protected]"
      ],
      "env": {
        "ENGRAM_HTTP_API_KEY": "${ENGRAM_HTTP_API_KEY}",
        "ENGRAM_LIVE_API_KEY": "${ENGRAM_LIVE_API_KEY}",
        "ENGRAM_LIVE_CLIENT_KEY": "${ENGRAM_LIVE_CLIENT_KEY}"
      }
    }
  }
}

Exposed tools (200)

203 read · 80 write · 23 destructive. Blast radius: 23 tools can delete or overwrite — an agent that can be talked into calling a tool can be talked into calling this one.

Tool	Risk	Description
`agent_capabilities`	write	Update the capabilities list of a registered agent.
`agent_deregister`	destructive	Deregister an AI agent (soft delete — sets status to
`agent_get`	read	Get details of a specific registered agent by ID.
`agent_heartbeat`	write	Update an agent
`agent_list`	read	List registered agents, optionally filtered by status or namespace.
`agent_register`	read	Register an AI agent with capabilities and namespace isolation. Upserts if agent_id already exists.
`alpha`	read	Read alpha
`attestation_chain_verify`	read	Verify the integrity of the entire attestation chain. Returns valid, broken (with location), or empty.
`attestation_list`	read	List attestation records with optional filters. Supports JSON, CSV, and Merkle proof export formats.
`attestation_log`	read	Log a document ingestion with cryptographic attestation. Creates a chained record proving the document was processed.
`attestation_verify`	read	Verify whether a document has been attested (ingested and recorded).
`beta`	destructive	Delete beta
`context_budget_check`	read	Check token usage of memories against a budget. Returns token counts and suggestions if over budget.
`context_get_artifact`	read	Explicitly retrieve retained Operational Context artifact content after access, retention, staleness, and redaction checks. Search and bundle tools return artifact pointers only; this tool requires an artifact_id and reason.
`context_record`	read	Record a scoped Operational Context event and optional derived summary. Redacts text before storage, requires provenance scope, keeps raw payload storage off, and supports RTK-compatible external summary metadata without dereferencing external pointers.
`context_record_artifact`	read	Record an Operational Context artifact pointer or explicitly retained redacted raw artifact. Pointer-only is the default; raw_content requires retain_raw=true and policy approval.
`context_search`	read	Search scoped Operational Context events and derived summaries. Searches event metadata, command/tool names, summaries, structured facts, failure signals, decisions, inspected/touched file metadata, and artifact pointers without returning raw artifact content.
`context_seed`	read	Injects initial context (premises, persona assumptions, or structured facts) about an entity to avoid cold start. Seeded memories are tagged as origin:seed and status:unverified, and should be treated as revisable assumptions.
`delta`	read	Delta first
`discover_tools`	read	List Engram tools by tier, group, or search query. Includes feature-disabled tools with enablement hints so agents can progressively discover capabilities beyond the small default tools/list surface.
`drawer_open`	read	Open a specific memory drawer by ID to read its full verbatim content and metadata.
`dream_archive`	read	Archive a terminal dream snapshot job.
`dream_cancel`	read	Cancel a pending or running dream snapshot job idempotently.
`dream_candidate_apply`	write	Apply an accepted or edited dream candidate to canonical memory. Requires confirm=true unless dry_run=true; repeated apply is idempotent.
`dream_candidate_get`	read	Inspect one dream candidate and its evidence sources.
`dream_candidate_review`	read	Review a dream candidate by accepting, editing, rejecting, or archiving it. This does not mutate canonical memory.
`dream_candidates_list`	read	List review candidates emitted by dream snapshot jobs. Results are proposals and are not canonical memory facts.
`dream_consolidation_status`	read	Retrieve memory consolidation status, counts of distilled procedural rules, archived duplicates, and tokens saved.
`dream_create`	write	Create a reviewable dream snapshot job and optionally run deterministic candidate generation. Generated candidates are proposals, not canonical memories.
`dream_eval_run`	write	Run deterministic local dream snapshot evaluation fixtures and return parseable CI-safe metrics. Does not require network, credentials, or model access.
`dream_get`	read	Inspect one dream snapshot job.
`dream_insights`	read	Retrieve actionable distilled insights, procedural rules, and thematic summaries generated during consolidation passes.
`dream_list`	read	List dream snapshot jobs by workspace and status.
`dream_run_now`	write	Manually trigger the Dream Phase (background consolidation) across all workspaces or a specific workspace. Distills procedural rules, merges semantic duplicates, and emits thematic digests.
`embedding_cache_clear`	destructive	Clear all entries from the embedding cache
`embedding_cache_stats`	read	Get statistics about the embedding cache (hits, misses, entries, bytes used, hit rate)
`gamma`	read	Gamma tool
`graph_mutate`	destructive	Unified facade for mutating the knowledge graph: create cross-references, remove cross-references, or extract and link named entities.
`graph_query`	read	Unified facade for querying the knowledge graph: retrieve related memories/neighborhood, find path between memories, traverse multi-hop graph relations, list linked entities, search entities, or export graph visualization.
`harness_handoff`	read	Generate a structured handoff packet for next-agent continuity: current goal, files touched, decisions, tests run/not run, risks, blockers, and next steps. Optionally persists as a harness record. Does NOT claim completion unless verification_evidence is provided.
`harness_record`	read	Record a durable harness event (decision, handoff, failed_attempt, verification_result, risk, assumption, bug_reproduction, issue_update) with structured metadata for cross-session continuity. Use instead of memory_create when capturing work-state evidence rather than facts.
`harness_status`	read	Assemble current project state from harness memory records and optional git state. Returns current objective, active issues, recent decisions, known blockers, last verification, last handoff, and a suggested next action. Token-budget aware; degrades gracefully when git is unavailable.
`harness_verify`	read	Record a verification command outcome with exit code, output summary, and optional evidence path/hash. Supports negative evidence (failures, skips with reason). Surfaces in harness_status as last_verification and feeds harness_handoff completion gating.
`identity_add_alias`	write	Add an alias to an identity. Aliases are normalized (lowercase, trimmed). Conflicts with existing aliases are rejected.
`identity_create`	write	Create a new identity with canonical ID, display name, and optional aliases
`identity_delete`	destructive	Delete an identity and all its aliases
`identity_get`	read	Get an identity by its canonical ID
`identity_link`	read	Link an identity to a memory (mark that the identity is mentioned in the memory)
`identity_list`	read	List all identities with optional type filter
`identity_remove_alias`	destructive	Remove an alias from any identity
`identity_resolve`	read	Resolve an alias to its canonical identity. Returns the identity if found, null otherwise.
`identity_search`	read	Search identities by alias or display name
`identity_unlink`	destructive	Remove the link between an identity and a memory
`identity_update`	write	Update an identity
`langfuse_connect`	read	Configure Langfuse connection for observability integration. Stores config in metadata.
`langfuse_extract_patterns`	read	Extract patterns from Langfuse traces without saving. Preview mode for pattern discovery.
`langfuse_sync`	write	Start background sync from Langfuse traces to memories. Returns task_id for status checking.
`langfuse_sync_status`	write	Check the status of a Langfuse sync task.
`lifecycle_config`	read	Get lifecycle predicate configuration defaults and optional overrides.
`lifecycle_run`	write	Run the canonical lifecycle predicate to mark stale and archive idle memories. Dry run by default; this is the only decay-derived lifecycle writer.
`lifecycle_status`	read	Get lifecycle statistics (active/stale/archived counts by workspace).
`meilisearch_config`	write	Show current Meilisearch configuration (URL, sync interval, enabled status).
`meilisearch_reindex`	write	Trigger a full re-sync from SQLite to Meilisearch. Use after bulk imports or if the index is out of sync.
`meilisearch_search`	read	Search memories using Meilisearch (typo-tolerant, fast full-text). Requires Meilisearch to be configured. Falls back to hybrid search if unavailable.
`meilisearch_status`	read	Get Meilisearch index status including document count, indexing state, and health.
`memory_agent_contract`	read	Return the read-only Agent Memory Contract: governed recall paths, safe writeback rules, provenance requirements, tool tier defaults, and future pending-review boundaries for agent-generated memory.
`memory_agent_metrics`	write	Run one full agent cycle (prune/merge/archive) and return the actions taken and aggregate metrics. Mutates the database.
`memory_agent_start`	write	Configure a tick-based memory agent for a workspace and return its initial configuration.
`memory_agent_status`	read	Return current status and memory statistics for a workspace agent.
`memory_agent_stop`	write	Stop a tick-based memory agent (no-op for stateless agents; resets client-side tracking).
`memory_agent_writeback`	write	Create a pending agent-generated memory proposal as an agent_writeback dream candidate. Defaults to dry_run=true and never mutates canonical memory; review/apply still happens through dream_candidate_get/review/apply.
`memory_archive_old`	write	Compress already-Archived memories by creating summary rows. Does not move originals to archived state; use lifecycle_run for lifecycle transitions.
`memory_archive_tool_output`	read	Archives a tool
`memory_auto_consolidate`	write	Enable, disable, configure, or inspect the automatic consolidation scheduler. Use action=
`memory_auto_link`	write	Run semantic and temporal auto-linker on a workspace, creating crossref edges in the database. Mutates the database.
`memory_auto_link_stats`	read	Return aggregate statistics about auto-generated semantic and temporal links.
`memory_auto_tag`	write	Automatically suggest and optionally apply tags to a memory. Analyzes content using AI heuristics and can merge suggested tags with existing ones.
`memory_block_archive`	destructive	Permanently delete a memory block and return its final content before deletion. Destructive and irreversible.
`memory_block_create`	write	Create a named, token-bounded memory block (Letta/MemGPT-style self-editing context slot).
`memory_block_edit`	write	Update the content of an existing memory block, incrementing its version and recording the reason.
`memory_block_get`	read	Retrieve a memory block by name.
`memory_block_history`	write	Return the edit history for a named memory block.
`memory_block_list`	read	List all memory blocks with their names, versions, and token usage.
`memory_boost`	read	Temporarily boost a memory
`memory_build_context`	read	Build a structured prompt context from relevant memories using hybrid search, with optional graph traversal depth, timeframe filtering, type filtering, and relationship graph inclusion. Inspired by Basic Memory
`memory_cache_clear`	destructive	Evict all entries from the semantic search cache. Mutates in-memory cache state.
`memory_cache_stats`	read	Return hit/miss statistics and entry count for the in-memory semantic search cache.
`memory_capture_screenshot`	read	Capture a screenshot of the full screen or a specific application window and save it to a local file.
`memory_check_access`	read	Check whether an agent has a required permission level on a scope path (including ancestor grants).
`memory_checkpoint`	write	Create a checkpoint memory marking a significant point in a session. Useful for session resumption and context restoration.
`memory_cleanup_expired`	destructive	Delete all expired memories. Typically called by a background job, but can be invoked manually.
`memory_cluster`	write	Run Louvain community detection on the memory graph and return detected clusters with modularity score.
`memory_cluster_concepts`	read	Cluster knowledge graph memories into high-level semantic concepts with auto-synthesized labels, key tags, and cohesion metrics.
`memory_coactivation_report`	read	Return coactivation graph statistics including edge count, average strength, and strongest co-occurring memory pairs.
`memory_compress`	write	Apply rule-based semantic compression to a single memory and return the structured result with key entities and facts.
`memory_compress_aaak`	read	Compress text or a memory drawer into AAAK (Agent Abbreviation Knowledge) ultra-dense format, achieving up to 20x-30x token savings for LLM prompts.
`memory_compress_for_context`	write	Pack a set of memories into a token budget for LLM context, returning compressed entries and diagnostics about skipped memories.
`memory_consolidate`	write	Run offline consolidation over a workspace, merging and archiving similar memories; use dry_run to preview without writing.
`memory_consolidate_batch`	write	Run one auto-consolidation pass over a workspace: detect duplicates, conflicts, and archive-eligible memories. Defaults to dry-run; returns a structured report of actions taken (or that would be taken).
`memory_consolidation_history`	read	List recent auto-consolidation runs for a workspace (or all workspaces). Newest-first.
`memory_content_stats`	read	Get content statistics for a memory (character count, word count, line count, sentence count, paragraph count)
`memory_council`	write	Run a question through an llm-council instance (Karpathy council orchestration) and return consolidated stage outputs and final answer. Optionally persist a checkpoint memory.
`memory_create`	write	Store an explicit durable memory with inspectable provenance. Use for stable preferences, decisions, insights, and project context when the fact is intentional and worth preserving.
`memory_create_batch`	write	Create multiple memories in a single operation. More efficient than individual creates for bulk imports.
`memory_create_custom`	write	Create memory but wrongly annotated read only
`memory_create_daily`	write	Create a daily (ephemeral) memory that auto-expires after the specified TTL. Useful for session context and scratch notes.
`memory_create_episodic`	write	Create an episodic memory representing an event with temporal context. Use for tracking when things happened and their duration.
`memory_create_issue`	write	Create an ISSUE memory for tracking problems
`memory_create_procedural`	write	Create a procedural memory representing a learned pattern or workflow. Tracks success/failure to measure effectiveness.
`memory_create_section`	write	Create a section memory for organizing content hierarchically. Sections can have parent sections for nested organization.
`memory_create_todo`	write	Create a TODO memory with priority
`memory_decay`	write	Compute or apply conservative memory policy decay for a workspace. Dry-run is the default; apply updates memory_policy scores only. Use lifecycle_run for lifecycle_state transitions.
`memory_decompress`	read	Retrieve the original (uncompressed) content of a memory by ID.
`memory_decompress_aaak`	read	Decompress an AAAK-encoded text back into standard natural language prose.
`memory_delete`	destructive	Delete a memory (soft delete)
`memory_delete_batch`	destructive	Delete multiple memories in a single operation.
`memory_describe_image`	read	Describe the contents of an image file using the configured vision provider (requires VISION_PROVIDER env).
`memory_detect_conflicts`	read	Detect contradictory or conflicting facts in the knowledge graph; optionally persist detected conflicts for later resolution.
`memory_detect_updates`	read	Given new content, identify existing memories in a workspace that may be stale or in need of an update.
`memory_digest`	read	Build an actionable, source-linked digest for a topic by orchestrating existing read-only retrieval, graph, and operational-context tools. Returns summaries, source memory IDs, relationships, next actions, provenance, and warnings without mutating memory or invoking an LLM.
`memory_embedding_migrate`	read	Re-embed all memories using the active embedding model; use dry_run to count affected memories without writing.
`memory_embedding_providers`	read	List the active embedding provider including model name and vector dimensions.
`memory_enrichment_audit`	read	Query enrichment events globally with filters (status, event_type, agent_id, operation_id, workspace, time range). Use for compliance audit and batch tracing.
`memory_enrichment_timeline`	read	List all enrichment events for a specific memory (lifecycle transitions, consolidation, compression, etc.). Shows what automated operations affected this memory and why.
`memory_entity_stats`	read	Get statistics about extracted entities
`memory_events_clear`	destructive	Clear old events from the event log. Helps manage storage for long-running systems.
`memory_events_poll`	destructive	Poll for memory events (create, update, delete, etc.) since a given point. Useful for syncing and monitoring.
`memory_expand`	read	Fetch full memory content for specific IDs. Used after memory_search_compact to get full content only for memories you need.
`memory_explain`	read	Explain a memory
`memory_explain_search`	read	Explain how each result in a scored search batch was ranked, breaking down bm25, vector, fuzzy, recency, importance, and optional rerank contributions.
`memory_explain_utility`	read	Explain why a memory has its current utility score. Returns the full feedback history summary (useful vs. not-useful retrievals), how much temporal decay has been applied, and a plain-English narrative. Useful for debugging or auditing memory quality.
`memory_export`	read	Export all memories to a JSON-serializable format for backup or migration.
`memory_export_graph`	read	Export knowledge graph visualization
`memory_export_markdown`	read	Export a workspace as human-readable Markdown files with YAML frontmatter and wiki-style [[links]]. Creates one .md file per memory, organized by type in subdirectories, with an index.md overview.
`memory_extract_entities`	read	Extract named entities (people, organizations, projects, concepts) from a memory and store them
`memory_extract_facts`	read	Extract subject-predicate-object facts from a memory
`memory_fact_graph`	read	Return all stored subject-predicate-object facts for a given subject entity.
`memory_feedback`	write	Record relevance feedback for a search result and update the memory
`memory_feedback_stats`	read	Return aggregated search-feedback statistics (thumbs-up/down counts, top-rated queries) for a workspace.
`memory_find_duplicates`	read	Find potential duplicate memories
`memory_find_path`	read	Find the shortest path between two memories in the knowledge graph
`memory_find_semantic_duplicates`	read	Find semantically similar memories using embedding cosine similarity (LLM-powered dedup). Goes beyond hash/n-gram to detect paraphrased content.
`memory_from_trace`	write	Create a memory from a specific Langfuse trace ID.
`memory_garden`	write	Run full autonomous garden maintenance on a workspace: prunes stale memories, merges duplicates, archives cold entries, and compresses verbose content.
`memory_garden_preview`	write	Dry-run garden maintenance: reports what would be pruned, merged, archived, or compressed without making any changes.
`memory_get`	read	Retrieve a memory by its ID
`memory_get_archived_output`	read	Retrieves the full raw output for an archived tool observation by its archive ID. Use when you need the complete output that was previously compressed for context efficiency.
`memory_get_cluster`	read	Return the Louvain community cluster that contains a specific memory, including its cluster ID, size, and member IDs.
`memory_get_entities`	read	Get all entities linked to a memory
`memory_get_full`	read	Get the full/original content of a memory. If the memory is a Summary, returns the original content from summary_of_id.
`memory_get_identities`	read	Get all identities (persons, organizations, projects, etc.) linked to a memory. Returns identity details including display name, type, aliases, and mention information.
`memory_get_injection_prompt`	read	Assembles the most relevant memories into a ready-to-inject system prompt block. Uses hybrid search to find relevant memories and formats them as markdown, respecting a token budget.
`memory_get_procedures`	read	List procedural memories (learned patterns/workflows). Optionally filter by trigger pattern.
`memory_get_project_context`	read	Get all project context memories for the current working directory. Returns instruction files and their sections.
`memory_get_public`	read	Get a memory with all <private>...</private> tagged sections removed. Safe for sharing in multi-agent contexts.
`memory_get_timeline`	read	Query episodic memories by time range. Returns events ordered by event_time.
`memory_get_working_memory`	read	Assembles all compressed tool observations for a session into a token-budgeted working memory block. Includes archive references for retrieving full outputs on demand. This is the core of the Endless Mode context management system.
`memory_grant_access`	write	Grant an agent access to a scope path. Supports read, write, and admin permissions. Access also applies to all descendant scopes.
`memory_graph_path`	read	Finds how two entities are connected in the knowledge graph via DuckDB OLAP engine. Discovers hidden relationships across multiple hops using recursive path-finding.
`memory_import`	write	Import memories from a previously exported JSON format.
`memory_import_markdown`	write	Import memories from Markdown files with engram_ frontmatter (RFC 0004). Review mode by default (confirm: false) — returns a staged list without writing. Detects drift via content_hash and version conflicts via engram_version. Ignores non-engram_ frontmatter keys (Obsidian-safe).
`memory_ingest_document`	read	Ingest a document (PDF or Markdown) into memory. Extracts text, splits into chunks with overlap, and creates memories with deduplication.
`memory_ingest_fact`	read	Append-only fact ingest for high-frequency sources (sessions, file watchers). Always inserts a new memory with memory_type=
`memory_ingest_fact_batch`	read	Batch append-only fact ingest. Inserts all facts in a single transaction. Returns count and ids.
`memory_ingest_media`	write	Ingest a local media asset (image, audio, or video) and create a durable memory with associated metadata in media_assets. Retrying with the same file bytes in the same workspace is idempotent: it returns the existing live memory with deduplicated=true and ignores the retry
`memory_knowledge_stats`	read	Return aggregate statistics over the knowledge-graph facts table: total facts, unique subjects/predicates/objects, and top entities.
`memory_lifecycle_update`	write	Unified facade for memory lifecycle mutations: promote a memory or reinforce its policy, promote to permanent canonical tier, decay policy scores, set expiration TTL, or score policy components.
`memory_link`	write	Create a cross-reference between two memories
`memory_list_auto_links`	read	List auto-generated graph links (semantic or temporal) between memories, optionally filtered by link type.
`memory_list_clusters`	read	List all detected memory clusters from the persistent cluster table, optionally selecting the detection algorithm.
`memory_list_compact`	read	List memories with compact preview instead of full content. More efficient for browsing/listing UIs. Returns only essential fields and a truncated content preview with metadata about original content length.
`memory_list_facts`	read	List extracted subject-predicate-object facts, optionally scoped to a single source memory.
`memory_list_grants`	read	List all scope access grants for a given agent.
`memory_list_instruction_files`	read	List AI instruction files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) in a directory without ingesting them. Returns file paths, types, and sizes for discovery purposes.
`memory_list_media`	read	List media assets stored in the media_assets table, optionally filtered by type (image, audio, video).
`memory_migrate_images`	read	Migrate existing base64-encoded images in memories to file storage. Scans all memories and uploads any embedded data URIs to storage, replacing them with file references.
`memory_observe_tool_use`	read	Store a tool observation as an episodic memory for session continuity. Automatically compresses large inputs/outputs.
`memory_predict_links`	read	Predict implicit or missing relationships between memories using graph topology, transitive paths, and semantic embeddings.
`memory_prepare_context`	read	Prepare optimized context for LLM using RTK-inspired pipeline (filter, group, truncate). Reduces token usage by 70-95% through intelligent context preparation.
`memory_process_video`	read	Process a video file: extract metadata and keyframe descriptions via the configured vision provider, and create a memory record for the result.
`memory_promote`	read	Reinforce a memory
`memory_promote_to_permanent`	read	Promote a daily memory to permanent tier. Clears the expiration and makes the memory permanent.
`memory_query_triplets`	read	SPARQL-like pattern query over the knowledge-graph facts table: match any combination of subject, predicate, and object (all optional, acts as wildcard when omitted).
`memory_rebuild_crossrefs`	read	Rebuild cross-reference links between memories. Re-analyzes all memories to find and create links.
`memory_rebuild_embeddings`	read	Rebuild embeddings for all memories that are missing them. Useful after model changes or data recovery.
`memory_reconcile_conflict`	read	Record a conflict reconciliation signal for a memory policy without deleting or mutating memory content.
`memory_record_procedure_outcome`	read	Record a success or failure for a procedural memory. Increments the corresponding counter.
`memory_reflect`	write	Generate a reflective synthesis over a set of memories at a configurable analytical depth (surface, analytical, or meta).
`memory_related`	read	Get memories related to a given memory (depth>1 or include_entities returns traversal result)
`memory_replay_at_time`	read	Replay one memory as it existed at a given RFC3339 timestamp and optionally return enrichment events affecting it up to that time.
`memory_resolve_conflict`	read	Resolve a saved knowledge-graph conflict by ID using a chosen strategy, removing or retaining the conflicting edges accordingly.
`memory_revoke_access`	destructive	Revoke an agent
`memory_scan_project`	read	Scan current directory for AI instruction files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) and ingest them as memories. Creates parent memory for each file and child memories for sections.
`memory_scope_snapshot`	read	Compares the knowledge graph between two timestamps, showing what relationships were added, removed, or changed. Uses DuckDB OLAP engine for efficient temporal diff.
`memory_score`	read	Compute deterministic memory policy scores for a memory. When persist=true, upserts the memory_policy row and emits a best-effort policy audit event.
`memory_search`	read	Search memories using hybrid search (keyword + semantic). Automatically selects optimal strategy with optional reranking. Supports workspace isolation, tier filtering, and advanced filters.
`memory_search_by_identity`	read	Search memories by identity (person, entity, or alias). Finds all mentions of a specific identity across memories.
`memory_search_by_image`	read	Search memories using an image as the query. Uses multimodal embeddings (CLIP-style) or falls back to describing the image via vision model and searching by description. Returns semantically similar memories — text or media — ranked by relevance.
`memory_search_compact`	read	Token-efficient search returning only id, title (first line, max 80 chars), created_at, and tags. Use memory_expand to get full content for specific IDs.
`memory_search_entities`	read	Search for entities by name prefix

Trust audit

BLOCKgrade F · trust 41/100 Do not install this without reading the findings. The audit found something that could harm you or your machine.

Layer	What it checks	Result
L0	Provenance & inventory	WARN
L1	Static analysis of the code	FAIL
L2	Instruction surface (what it tells the agent)	PASS
L3	Class-specific surface	WARN
L4	Behavioural (sandbox)	SKIPPED

What the source does

Filesystem: declared (1 observation(s))
Network: declared (4 observation(s))
Shell: none-observed
Dependencies: not all pinned
Secrets in source: found

Findings (25)

CRITICALHard-coded secrets · secret.private_key · CWE-798, CWE-321

src/context/policy.rs:614

"-----BEGIN PRIVATE KEY-----\nabc123\n-----END PRIVATE KEY-----" // gitleaks:allow

HIGHNetwork egress · net.metadata_ip · CWE-200, CWE-319

src/integrations/langfuse.rs:544

let result = validate_base_url("https://169.254.169.254/latest/meta-data");

Why it matters. cloud metadata endpoint: the classic SSRF credential grab

HIGHObfuscation / stealth · obf.rtl_override · CWE-506, CWE-94

fuzz/seeds/entity_extraction/c3-bidi-0f:1

devil x

MEDIUMInventory / provenance · inv.binary · CWE-1104

fuzz/seeds/entity_extraction/c3-bounded-max-0

c3-bounded-max-0