Skip to main content
Glama
NeuroMedia Agent Memory

NeuroMedia Agent Memory

NeuroMedia Agent Memory

NeuroMedia Agent Memory — память для AI-агентов

Русский · English · 中文 · Español · Deutsch · Français

NeuroMedia Agent Memory — русскоязычная продуктовая адаптация open-source memory layer для AI-агентов. Она основана на Memora, сохраняет MIT License и не является официальным продуктом или партнёрством upstream-проекта. См. происхождение и LICENSE.

Долговременная память для AI-агентов, MCP и командных workflow

NeuroMedia Agent Memory помогает агентам не терять рабочий контекст между сессиями. Это слой persistent memory для задач, где одного чата недостаточно: исследования, требования, решения по архитектуре, задачи, риски, подтверждения, ссылки на документы и результаты QA должны оставаться доступными следующему участнику процесса. Вместо того чтобы каждый запуск Claude Code, Codex или другого MCP-совместимого агента заново искал сведения по папкам и перепискам, команда может сохранять проверяемые записи и получать тематическую сводку перед следующим шагом.

Проект ориентирован на инженерные команды, исследовательские workflow, product discovery, документацию и внутреннюю автоматизацию. Он не заменяет владельца данных, каноническую базу знаний, контроль доступа или ответственность человека. Его роль — сделать разрешённый контекст структурированным: различать факт и гипотезу, сохранять источник, связывать новые решения с устаревшими, возвращать релевантную информацию по смыслу и не превращать память в бесконтрольный архив сообщений.

Related MCP server: Engram-Mem

Что умеет слой памяти

  • Persistent AI agent memory — записи сохраняются между сессиями, перезапусками и ролями агентов.

  • MCP memory server — действия с памятью можно подключить к агенту через Model Context Protocol.

  • Semantic search — поиск находит близкие по смыслу факты, а не только буквальные совпадения.

  • Source-backed context — вывод можно связать с документом, задачей, исследованием или другим источником.

  • Knowledge graph — связи между сущностями, рисками, решениями и TODO можно исследовать как граф.

  • Supersession lineage — новая версия знания не стирает предыдущую без следа, а формирует понятную историю замены.

  • Topic digest — перед новой задачей агент может получить сжатую сводку по теме, открытым вопросам и связанным записям.

Как это выглядит в реальной работе

Представьте длинную разработку. Исследовательский агент выявил ограничение внешнего API. Планировщик разложил его на задачи. Разработчик внедрил изменение. QA-агент приложил проверку и оставил риск для следующего релиза. Если эти данные остались только в разных чатах, новый участник легко повторит работу или примет решение без важного контекста. NeuroMedia Agent Memory позволяет сохранить утверждение с источником и статусом, привязать его к задаче, а затем получить digest перед следующей операцией.

Это полезно и вне кода: можно поддерживать согласованный tone of voice, список разрешённых формулировок, verified facts для контента, ограничения интеграций, правила human-in-the-loop и историю решения спорных вопросов. Но память не должна автоматически считаться истиной. Записи, основанные на предположении, должны быть помечены как гипотеза; критические данные должны сверяться с первоисточником; действия с последствиями должны оставаться под человеческим подтверждением.

Рекомендуемый безопасный workflow

  1. Определите workspace: проект, владельца данных, разрешённые источники, пользователей и срок хранения.

  2. Подключите upstream MCP server локально или в контролируемом окружении. Технические инструкции и исходный implementation guide доступны в upstream-документации Memora.

  3. Сохраняйте факты, решения, TODO, риски и ссылки. Не выдавайте догадки за подтверждённые данные.

  4. Перед началом задачи запрашивайте topic digest и проверяйте первоисточник, если ошибка может быть дорогой.

  5. При изменении требований создавайте новую версию и связь с заменённой записью, а не переписывайте историю молча.

  6. Настройте доступ, backup, retention и human review до подключения рабочих данных.

Безопасность и приватность

Не помещайте в публичные issues, коммиты, README или общую память API-ключи, .env, токены, cookies, пароли, recovery codes, клиентские выгрузки, персональные данные, внутренние URL или production-конфигурации. Перед подключением внешнего LLM, embedding provider, S3/R2/D1 или другого хранилища изучите условия обработки данных и используйте отдельные credentials с минимальными правами. Автоматическое извлечение не делает информацию разрешённой для хранения и распространения.

Поиск и документация

README использует понятную структуру H1/H2, сценарии, ограничения, ссылки на лицензию и полноценные локализованные страницы. Это помогает читателям, GitHub preview, поисковым системам и AI-инструментам понять, что перед ними: persistent AI agent memory, MCP memory server, semantic search, knowledge graph и долгие agent workflow. Ключевые фразы используются по смыслу, без keyword spam и ложных обещаний.

Лицензия и происхождение

NeuroMedia Agent Memory основан на Memora. Исходная MIT License сохранена в LICENSE. Адаптация меняет публичное позиционирование, русскую главную документацию, SEO-структуру и локализованные продуктовые страницы; она не заявляет авторство upstream-кода, эксклюзивность или официальное партнёрство.

Available Tools

43 tools
memory_absorbA

Intelligently absorb facts into memory with dedup and consolidation.

For each fact: searches for similar existing memories, classifies the relationship via LLM (duplicate/update/contradict/related/new), then takes the appropriate action. Related new facts are automatically consolidated into single, richer memories via LLM synthesis.

Args: facts: List of fact strings to absorb (can be granular — related ones get merged) source: Origin of facts — "manual", "session_end", "post_tool", "import" confidence: Caller's certainty about these facts (0.0-1.0, default: 0.8) context: Optional surrounding context to help disambiguate facts metadata: Optional metadata to attach to created memories tags: Optional tags to attach to created memories dry_run: If True, preview what would happen without writing anything

Inputs: facts (required), tags, source, context, +3 more. Returns: result

memory_backfill_tagsA

Re-tag existing memories with project-prefixed tags.

Uses deterministic normalization to prefix generic tags (e.g. "plan" → "memora/plan") when the memory content clearly belongs to a specific project. No LLM calls.

Idempotent: re-running produces the same result.

Args: dry_run: If True, preview changes without writing (default: True)

Returns: Dictionary with processed count, changed count, and list of changes.

Rate limited: 120s cooldown.

Inputs: dry_run. Returns: result

memory_boostA

Boost a memory's importance score.

Manually increase a memory's base importance to make it rank higher in importance-sorted searches. The boost is permanent and cumulative.

Args: memory_id: ID of the memory to boost boost_amount: Amount to add to base importance (default: 0.5) Common values: 0.25 (small), 0.5 (medium), 1.0 (large)

Returns: Updated memory with new importance score, or error if not found

Inputs: memory_id (required), boost_amount. Returns: result

memory_clustersA

Detect clusters of related memories.

Args: min_cluster_size: Minimum memories to form a cluster (default: 2) min_score: Minimum similarity score to consider connected (default: 0.3) algorithm: "connected_components" (default) or "louvain" Louvain uses embedding similarity for content-based clustering.

Returns: List of clusters with member IDs, sizes, and common tags

Inputs: algorithm, min_score, min_cluster_size. Returns: result

memory_createA

Create a new memory entry.

Args: content: The memory content text metadata: Optional metadata dictionary tags: Optional list of tags suggest_similar: If True, find similar memories and suggest consolidation (default: True) similarity_threshold: Minimum similarity score for suggestions (default: 0.2) response_mode: "full" (default) or "minimal" response payload size

Inputs: content (required), tags, metadata, response_mode, +2 more. Returns: result

memory_create_batchC

Create multiple memories in one call.

Inputs: entries (required). Returns: result

memory_create_issueA

Create a new issue/bug memory.

Args: content: Description of the issue status: Issue status - "open" (default) or "closed" closed_reason: If closed, the reason - "complete" or "not_planned" severity: Issue severity - "critical", "major", "minor" (default) component: Component/area affected (e.g., "graph", "storage", "api") category: Issue category (e.g., "bug", "enhancement", "performance")

Returns: Created issue memory with auto-assigned tag "memora/issues"

Inputs: content (required), status, category, severity, +2 more. Returns: result

memory_create_sectionA

Create a new section/subsection header memory.

Section memories are organizational placeholders that:

  • Are NOT visible in the graph visualization

  • Are NOT included in duplicate detection

  • Do NOT compute embeddings or cross-references

Args: content: Title/description of the section section: Parent section name (e.g., "Architecture", "API") subsection: Subsection path (e.g., "endpoints/auth")

Returns: Created section memory with auto-assigned tag "memora/sections"

Inputs: content (required), section, subsection. Returns: result

memory_create_todoA

Create a new TODO/task memory.

Args: content: Description of the task status: Task status - "open" (default) or "closed" closed_reason: If closed, the reason - "complete" or "not_planned" priority: Task priority - "high", "medium" (default), "low" category: Task category (e.g., "cloud-backend", "graph-visualization", "docs")

Returns: Created TODO memory with auto-assigned tag "memora/todos"

Inputs: content (required), status, category, priority, +1 more. Returns: result

memory_deleteA

Delete a memory by id.

Args: memory_id: Memory ID to delete force: If True, allow deleting document fragments/roots. Use memory_delete_document() instead for clean document removal. reason: Optional tombstone reason (default "deleted")

Inputs: memory_id (required), force, reason. Returns: result

memory_delete_batchC

Delete multiple memories by id.

Args: ids: Memory IDs to delete reason: Optional tombstone reason (default "deleted")

Inputs: ids (required), reason. Returns: result

memory_delete_documentA

Delete a stored document and all its fragments.

Args: document_key: The document identifier version: Optional — delete only this version. If omitted, deletes all versions.

Returns: {deleted_roots: count, deleted_fragments: count, deleted_ids: [...]}

Inputs: document_key (required), version. Returns: result

memory_detect_supersessionsA

Detect memories that supersede (update/replace) other memories.

Scans existing memories for pairs where one is an evolved/updated version of another, then creates 'supersedes' edges between them. Complements memory_absorb which only catches supersessions at write time.

Uses neutral LLM classification (not biased by timestamps) to determine both the relationship type and direction.

Args: min_similarity: Minimum embedding similarity to consider (default: 0.55) limit: Maximum pairs to analyze with LLM (default: 20) dry_run: If True, preview detections without creating edges (default: True) tags_any: Only consider memories with any of these tags min_confidence: Minimum LLM confidence to accept (default: 0.75)

Returns: Dictionary with candidates found, analyzed count, detected supersessions, and detailed results for each pair.

Rate limited: 120s cooldown.

Inputs: limit, dry_run, tags_any, min_confidence, +1 more. Returns: result

memory_digestA

Return a deterministic digest of memories related to a topic.

The digest is an aggregation surface for agents that need current context, not a narrative generator. It combines active hybrid-search hits, optional supersession lineage, related memory ids, and matching TODO/issue memories. Raw source ids are always returned so callers can inspect primitives if the digest is too broad or too narrow.

Args: topic: Subject to digest. k: Maximum active search hits and TODO/issue matches to include. include_lineage: Include supersession history for active hits. include_todos: Include matching memora/todos and memora/issues entries. include_related_hops: Number of cross-reference hops to collect, capped at 3. synthesize: Reserved for future LLM synthesis. False by default. preview_chars: Preview length per returned memory. tags_any: Restrict hybrid search and discovered TODO/issue matches to memories with any of these tags. tags_all: Restrict hybrid search and discovered TODO/issue matches to memories with all of these tags. metadata_filters: Optional metadata filters. date_from: Optional created_at lower bound (ISO or relative like "7d"). date_to: Optional created_at upper bound (ISO or relative like "7d"). seed_ids: Explicit memory ids to include as source memories and expand lineage/related from. debug: Include ranked candidates, applied filters, and seed/filter notes.

Inputs: topic (required), k, debug, date_to, +10 more. Returns: result

memory_events_clearB

Mark events as consumed.

Args: event_ids: List of event IDs to mark as consumed

Returns: Dictionary with count of cleared events

Inputs: event_ids (required). Returns: result

memory_events_pollA

Poll for memory events (e.g., shared-cache notifications).

Args: since_timestamp: Only return events after this timestamp (ISO format) tags_filter: Only return events with these tags (e.g., ["shared-cache"]) unconsumed_only: Only return unconsumed events (default: True)

Returns: Dictionary with count and list of events

Inputs: tags_filter, since_timestamp, unconsumed_only. Returns: result

memory_exportA

Export all memories to JSON format for backup or transfer. Rate limited: 60s cooldown.

Inputs: no named parameters. Returns: result

memory_export_graphA

Export memories as interactive HTML knowledge graph.

Args: output_path: Path to save HTML file (default: ~/memories_graph.html) min_score: Minimum similarity score for edges (default: 0.25)

Returns: Dictionary with path, node count, edge count, and tags

Inputs: min_score, output_path. Returns: result

memory_find_duplicatesA

Find potential duplicate memory pairs with optional LLM-powered comparison.

Scans cross-references to find memory pairs with similarity >= threshold, then optionally uses LLM to semantically compare them. Uses the same threshold (0.85) as the graph UI duplicate detection.

Args: min_similarity: Minimum similarity score to consider (default: 0.85) max_similarity: Maximum similarity score (default: 1.0, kept for backward compatibility) limit: Maximum pairs to analyze (default: 10) use_llm: Whether to use LLM for semantic comparison (default: True)

Returns: Dictionary with: - pairs: List of potential duplicate pairs with analysis - total_candidates: Total pairs found - analyzed: Number of pairs analyzed with LLM - llm_available: Whether LLM comparison was available

Rate limited: 120s cooldown.

Inputs: limit, use_llm, max_similarity, min_similarity. Returns: result

memory_getA

Retrieve a single memory by id (full content by default).

Args: memory_id: ID of the memory to retrieve include_images: If False, strip image data from metadata to reduce response size fields: Optional list of fields to return (e.g. ["id","content","tags"]). None returns all fields. follow: Lineage mode. Default latest (resolve superseded id to the current leaf). full_history adds a history key with all versions root-to-leaf; all returns the exact requested id with no chain walk (forensic). Omitting follow is NOT unfiltered — it means resolve to latest.

Inputs: memory_id (required), fields, follow, include_images. Returns: result

memory_get_documentA

Retrieve a stored document and its fragments by document key.

Args: document_key: The document identifier used during storage content_mode: "preview" (default) or "full" for fragment content preview_chars: Max chars for preview mode (default: 120) node_kinds: Optional filter — e.g. ["claim", "plan_item"] for specific fragment types version: Optional version filter. If omitted, returns the latest version.

Returns: {root: {...}, fragments: [...] ordered by ordinal, document_key, version}

Inputs: document_key (required), version, node_kinds, content_mode, +1 more. Returns: result

memory_hierarchyC

Return memories organised into a hierarchy derived from their metadata.

Args: compact: If True (default), return only id, preview (first 80 chars), and tags per memory to reduce response size. Set to False for full memory data.

Inputs: query, compact, date_to, tags_all, +5 more. Returns: result

memory_importA

Import memories from JSON format. Rate limited: 60s cooldown.

Args: data: List of memory dictionaries with content, metadata, tags, created_at strategy: "replace" (clear all first), "merge" (skip duplicates), or "append" (add all)

Inputs: data (required), strategy. Returns: result

memory_insightsB

Analyze stored memories and produce actionable insights.

Returns activity summary, open items, consolidation suggestions, and optional LLM-powered pattern detection.

Args: period: Time period to analyze (e.g., "7d", "1m", "1y") include_llm_analysis: If True, use LLM to detect patterns and themes

Returns: Dictionary with: - activity_summary: Created counts by type and tag - open_items: Open TODOs and issues with stale detection - consolidation_candidates: Similar memory pairs that could be merged - llm_analysis: Themes, focus areas, gaps, and summary (or null) Rate limited: 120s cooldown.

Inputs: period, include_llm_analysis. Returns: result

memory_listA

List memories, optionally filtering by substring query or metadata.

Returns compact previews by default to reduce context usage. Use content_mode="full" when you need the complete content. Use memory_get to fetch full content for specific IDs.

Args: query: Optional text search query metadata_filters: Optional metadata filters limit: Maximum results (default: 20). Pass -1 for unlimited. offset: Number of filtered results to skip (default: 0) date_from: Optional date filter (ISO format or relative like "7d", "1m", "1y") date_to: Optional date filter (ISO format or relative like "7d", "1m", "1y") tags_any: Match memories with ANY of these tags (OR logic) tags_all: Match memories with ALL of these tags (AND logic) tags_none: Exclude memories with ANY of these tags (NOT logic) sort_by_importance: Sort results by importance score (default: False, sorts by date) content_mode: "preview" (default) returns truncated content_preview; "full" returns complete content preview_chars: Max chars for preview (default: 120, ignored when content_mode="full") fields: Optional list of fields to return (e.g. ["id","content_preview","tags"]). None returns all fields. follow: Lineage mode. Default active (excludes superseded memories). latest resolves each hit to its current version; full_history expands supersession chains; all is the explicit unfiltered forensic escape hatch (includes superseded). Omitting follow is NOT unfiltered — it means the safe default.

Inputs: limit, query, fields, follow, +10 more. Returns: result

memory_list_compactA

[Deprecated] List memories in compact format (id, preview, tags only).

Prefer memory_list which now defaults to compact previews with richer fields and configurable content_mode/preview_chars.

Returns minimal fields: id, content preview (first 80 chars), tags, and created_at.

Args: query: Optional text search query metadata_filters: Optional metadata filters limit: Maximum number of results to return (default: unlimited) offset: Number of results to skip (default: 0) date_from: Optional date filter (ISO format or relative like "7d", "1m", "1y") date_to: Optional date filter (ISO format or relative like "7d", "1m", "1y") tags_any: Match memories with ANY of these tags (OR logic) tags_all: Match memories with ALL of these tags (AND logic) tags_none: Exclude memories with ANY of these tags (NOT logic)

Inputs: limit, query, offset, date_to, +5 more. Returns: result

memory_mergeA

Merge source memory into target, then delete source.

Combines two memories into one, preserving content and metadata.

Args: source_id: Memory ID to merge from (will be deleted) target_id: Memory ID to merge into (will be updated) merge_strategy: How to combine content: - "append": Append source content to target (default) - "prepend": Prepend source content to target - "replace": Replace target content with source

Returns: Updated target memory and deletion confirmation

Inputs: source_id (required), target_id (required), merge_strategy. Returns: result

memory_migrate_imagesA

Migrate existing base64 images to R2 storage.

Scans all memories and uploads any base64-encoded images to R2, replacing the data URIs with R2 URLs.

Args: dry_run: If True, only report what would be migrated without making changes

Returns: Dictionary with migration results including count of migrated images

Rate limited: 300s cooldown.

Inputs: dry_run. Returns: result

memory_rebuild_crossrefsA

Recompute cross-reference links for all memories. Rate limited: 300s cooldown.

Use this periodically (or after bulk imports) to close the eventual-consistency gap in the related graph — see memory_related for the consistency model.

Inputs: no named parameters. Returns: result

memory_rebuild_embeddingsA

Recompute embeddings for all memories. Rate limited: 300s cooldown.

Inputs: no named parameters. Returns: result

memory_statsA

Get statistics and analytics about stored memories.

Also reports WHICH DATABASE this session is bound to (memora #997). A valid-but-wrong database name in a workspace's .mcp.json is otherwise undetectable: every tool works, reads succeed, and writes land silently in another project's store. Reporting the bound identity is what makes that drift visible to an agent or an operator at all.

Inputs: no named parameters. Returns: result

memory_store_documentA

Store a structured document as a root memory + searchable fragments.

Parses markdown into typed fragments (claims, plan items, references, risks, section chunks) that are individually searchable while the full document remains retrievable as a unit.

Args: content: Full markdown document content document_key: Stable identifier (e.g. "research/memora-enhancements-2026-04-08") version: Document version (default: 1). If >1, supersedes previous version. tags: Tags applied to root and fragments metadata: Additional metadata merged into root and fragments skip_fragment_crossrefs: If True, fragments skip crossref computation (default: True)

Returns: {document_key, root_id, fragment_count, node_map: {node_kind: [ids]}}

Inputs: content (required), document_key (required), tags, version, +2 more. Returns: result

memory_tag_hierarchyB

Return stored tags organised as a namespace hierarchy.

Inputs: include_root. Returns: result

memory_tagsB

Return the allowlisted tags.

Inputs: no named parameters. Returns: result

memory_updateB

Update an existing memory.

Metadata updates merge into existing metadata by default. Set a metadata key to null/None to delete that key. Pass replace_metadata=True only when intentionally replacing the whole metadata object.

Inputs: memory_id (required), tags, content, metadata, +1 more. Returns: result

memory_upload_imageA

Upload an image file directly to R2 storage.

Uploads a local image file to R2 and returns the r2:// reference URL that can be used in memory metadata.

Args: file_path: Absolute path to the image file to upload memory_id: Memory ID this image belongs to (used for organizing in R2) image_index: Index of image within the memory (default: 0) caption: Optional caption for the image

Returns: Dictionary with r2_url (the r2:// reference) and image object ready for metadata

Inputs: file_path (required), memory_id (required), caption, image_index. Returns: result

memory_validate_tagsC

Validate stored tags against the allowlist and report invalid entries.

Inputs: include_memories. Returns: result

memory_verify_integrityA

Read-only embedding integrity doctor with bounded offending ids.

Inputs: no named parameters. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 43 tools

    Disambiguation3/5

    Several tool families overlap: memory_list vs deprecated memory_list_compact, memory_list query vs memory_semantic_search vs memory_hybrid_search, and memory_create vs memory_absorb vs memory_create_batch. Descriptions are detailed enough to guide an expert agent, but an agent could still misselect among these similar read/write/search paths.

    Naming Consistency4/5

    All tools use a memory_ prefix and snake_case, making the surface highly predictable. However, the pattern is not strictly verb_noun throughout; noun-first tools like memory_stats, memory_insights, and memory_clusters are common, which is a minor deviation from the strongest convention.

    Tool Count2/5

    43 tools is too many for a coherent memory server surface, especially with maintenance, diagnostics, rate-limited rebuilds, and a deprecated alias. While the domain is broad, the count feels heavy and increases selection cost for agents.

    Completeness5/5

    The surface covers create/read/update/delete, batch operations, semantic and hybrid search, tags, documents, issues/todos/sections, linking, merging, deduplication, import/export, image migration, events, and analytics. No major lifecycle gap is apparent for an agent memory system.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to maintain persistent memory across sessions by capturing conversations, extracting durable knowledge, and injecting relevant context, supporting various MCP-compatible platforms.
      12
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to have persistent, self-managing memory with bi-temporal supersession, timely forgetting, and recall under a limited context window, using MCP protocol.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Provides AI agents with persistent, human-like memory infrastructure via MCP, enabling them to store, search, summarize, and forget episodic, semantic, procedural, and working memories across sessions.
      658 npm
      MIT