{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"npm-agent-recall-core","slug":"agent-recall-core","name":"agent-recall-core","type":"agent","url":"https://github.com/Goldentrii/AgentRecall#readme","page_url":"https://unfragile.ai/agent-recall-core","categories":["ai-agents"],"tags":["agent-recall","ai-memory","memory-palace","agent-memory","mcp","langchain","crewai","knowledge-graph","obsidian"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"npm-agent-recall-core__cap_0","uri":"capability://memory.knowledge.memory.palace.structured.storage","name":"memory-palace-structured-storage","description":"Implements a hierarchical memory palace architecture that organizes agent interactions and knowledge into spatially-indexed semantic rooms. Uses a graph-based storage model where each 'room' represents a conceptual domain, with memories encoded as nodes connected by semantic relationships. The system maps abstract information to spatial locations, enabling agents to retrieve contextually relevant memories through spatial navigation rather than keyword search.","intents":["Store agent conversation history in a way that mimics human memory palace techniques for better recall","Organize multi-turn agent interactions by semantic domain rather than chronological order","Enable agents to navigate memory through spatial/conceptual metaphors instead of traditional database queries"],"best_for":["AI agents requiring persistent, semantically-organized memory across sessions","Multi-agent systems needing shared knowledge bases with spatial organization","Developers building long-running agents that need to avoid context window exhaustion"],"limitations":["No built-in persistence layer — requires external database integration (e.g., PostgreSQL, MongoDB) for durability","Spatial indexing overhead adds ~50-150ms per memory insertion depending on graph complexity","Scaling to millions of memories requires careful graph pruning; no automatic memory eviction policy included"],"requires":["Node.js 16+","MCP server runtime (Claude Desktop or compatible MCP host)","Optional: LangChain or CrewAI for agent integration"],"input_types":["text (conversation turns, observations)","structured JSON (agent state, metadata)","semantic embeddings (optional, for similarity-based retrieval)"],"output_types":["structured memory objects (room, memory nodes, relationships)","ranked memory lists (by relevance/recency)","spatial navigation paths (traversal through memory palace)"],"categories":["memory-knowledge","agent-memory-systems"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_1","uri":"capability://tool.use.integration.mcp.protocol.memory.interface","name":"mcp-protocol-memory-interface","description":"Exposes memory palace functionality as MCP (Model Context Protocol) tools, allowing Claude and other MCP-compatible agents to interact with the memory system through standardized tool calling. Implements MCP resource handlers for memory read/write operations, with schema-based function definitions for memory operations like store, retrieve, navigate, and update. Enables seamless integration with Claude's native tool-use capabilities without custom client code.","intents":["Connect Claude directly to agent memory without building custom API clients","Use Claude as a memory curator, deciding what to store and how to organize it","Enable Claude to navigate and query agent memory using natural language through MCP tools"],"best_for":["Developers integrating AgentRecall with Claude via MCP","Teams using Claude Desktop with MCP server plugins","Builders creating multi-agent systems where Claude orchestrates memory access"],"limitations":["MCP protocol adds ~100-200ms round-trip latency per tool call vs direct library calls","Tool schema complexity limits to ~50 concurrent memory operations per session before performance degradation","No built-in rate limiting or quota management — relies on host MCP server for throttling"],"requires":["Claude API access (or Claude Desktop with MCP support)","MCP server runtime (e.g., Claude Desktop, Cline, or custom MCP host)","Node.js 16+ for running MCP server"],"input_types":["natural language queries (via Claude)","MCP tool call payloads (JSON schema-based)","structured memory operations (store, retrieve, navigate)"],"output_types":["MCP tool results (JSON-formatted memory responses)","memory navigation paths","ranked retrieval results with metadata"],"categories":["tool-use-integration","mcp-protocol"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_10","uri":"capability://data.processing.analysis.memory.conflict.resolution.and.merging","name":"memory-conflict-resolution-and-merging","description":"Handles conflicts when multiple agents or processes write to the same memory simultaneously, using configurable merge strategies (last-write-wins, semantic merging, manual conflict resolution). Detects conflicting updates to memory nodes and applies merge logic to reconcile differences while preserving important information. Supports both automatic merging (for non-conflicting updates) and manual conflict resolution (for semantic conflicts).","intents":["Enable multiple agents to safely write to shared memory without data loss","Merge conflicting memory updates intelligently rather than overwriting","Detect and flag semantic conflicts that require human review"],"best_for":["Multi-agent systems with shared memory","Distributed agent deployments where agents may update memory concurrently","Systems requiring data consistency guarantees across concurrent writes"],"limitations":["Semantic merging requires embedding-based similarity, adding ~100-200ms per conflict resolution","Manual conflict resolution requires human intervention — blocks agent execution until resolved","Merge strategy selection is heuristic-based; some conflicts may be resolved incorrectly"],"requires":["Conflict detection mechanism (version tracking, timestamps, or checksums)","Merge strategy implementation (last-write-wins, semantic merging, etc.)","Optional: embedding model for semantic conflict detection"],"input_types":["conflicting memory updates (from multiple agents/processes)","merge strategy (last-write-wins, semantic, manual)","conflict metadata (timestamps, agent IDs, update content)"],"output_types":["merged memory node (reconciled from conflicting updates)","conflict resolution report (which updates were merged, which required manual review)","unresolved conflicts (flagged for human review)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_2","uri":"capability://search.retrieval.semantic.memory.retrieval.with.ranking","name":"semantic-memory-retrieval-with-ranking","description":"Implements multi-criteria memory retrieval that ranks results by semantic similarity, temporal relevance, and access frequency. Uses embedding-based similarity matching combined with recency weighting and usage statistics to surface the most contextually relevant memories. Supports both exact keyword matching and fuzzy semantic search, with configurable ranking algorithms to balance freshness vs. relevance.","intents":["Retrieve the most relevant memories for an agent's current task without overwhelming it with all stored memories","Balance between recent memories and historically important ones based on task context","Find memories by semantic meaning rather than exact keyword match"],"best_for":["Long-running agents that accumulate thousands of memories and need intelligent filtering","Multi-turn conversations where context relevance changes between turns","Systems requiring both semantic and temporal memory prioritization"],"limitations":["Embedding generation requires external model (OpenAI, Anthropic, or local) — adds 50-500ms per retrieval depending on batch size","Ranking algorithm is O(n) over all memories; retrieval time grows linearly with memory count (mitigated by graph pruning but not eliminated)","No built-in caching of embeddings — recalculates on each retrieval unless external cache layer added"],"requires":["Embedding model API (OpenAI, Anthropic, Ollama, or local model)","Memory palace graph already populated with semantic relationships","Optional: vector database for embedding caching (Pinecone, Weaviate, Milvus)"],"input_types":["text query (natural language or structured)","semantic embeddings (optional, for pre-computed similarity)","context metadata (current task, agent state)"],"output_types":["ranked memory list (with similarity scores, recency weights, frequency metrics)","filtered memory subset (top-k results)","memory relevance explanations (which criteria ranked each memory)"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_3","uri":"capability://tool.use.integration.langchain.crewai.agent.binding","name":"langchain-crewai-agent-binding","description":"Provides native integration adapters for LangChain and CrewAI agents, allowing them to use AgentRecall as a drop-in memory backend. Implements callback hooks that automatically capture agent actions, observations, and tool results into the memory palace without requiring manual instrumentation. Supports both LangChain's memory interface and CrewAI's agent state management, enabling agents to access memories through their native memory APIs.","intents":["Add persistent memory to existing LangChain agents without rewriting agent code","Automatically capture CrewAI task outputs and agent interactions into memory palace","Use AgentRecall as a replacement for LangChain's default memory backends (ConversationBufferMemory, etc.)"],"best_for":["Teams with existing LangChain or CrewAI agents wanting to add memory palace capabilities","Developers avoiding custom memory integration code","Multi-agent systems using LangChain or CrewAI where agents need shared memory"],"limitations":["Callback overhead adds ~20-50ms per agent step for memory capture and indexing","Limited to LangChain 0.1+ and CrewAI 0.1+ — older versions require manual adapter code","Automatic capture may miss custom agent implementations that don't use standard callback hooks"],"requires":["LangChain 0.1+ or CrewAI 0.1+","Node.js 16+","AgentRecall core library installed"],"input_types":["LangChain agent callbacks (action, observation, tool results)","CrewAI task execution events","agent state snapshots"],"output_types":["memory palace entries (automatically indexed)","agent memory retrieval results (compatible with LangChain/CrewAI memory interface)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_4","uri":"capability://tool.use.integration.obsidian.knowledge.graph.sync","name":"obsidian-knowledge-graph-sync","description":"Bidirectional sync between AgentRecall memory palace and Obsidian vault, treating Obsidian as a persistent knowledge graph backend. Exports memory palace rooms and relationships as Obsidian notes with wiki-link relationships, enabling human review and curation of agent memories. Supports importing Obsidian vault structure back into memory palace, allowing humans to seed agent memory with curated knowledge.","intents":["Export agent memories to Obsidian for human review and annotation","Use Obsidian as a persistent backup and audit trail for agent memories","Seed agent memory with human-curated knowledge from Obsidian vault"],"best_for":["Teams wanting human-in-the-loop memory curation and oversight","Knowledge workers using Obsidian who want to augment agents with their vault","Organizations requiring audit trails and human review of agent memories"],"limitations":["Sync is not real-time — requires explicit sync operations (pull/push) which can take seconds for large vaults","Obsidian vault structure must follow specific naming conventions for reliable bidirectional sync","Circular references in Obsidian graph can cause infinite loops during import — requires manual conflict resolution"],"requires":["Obsidian vault (local or cloud-synced)","Obsidian API access (via Obsidian plugin or file system access)","Node.js 16+"],"input_types":["Obsidian vault files (markdown with wiki-links)","memory palace graph structure","sync direction flag (push to Obsidian or pull from Obsidian)"],"output_types":["Obsidian markdown files (one per memory room/node)","wiki-link relationships (Obsidian graph format)","updated memory palace graph (after import from Obsidian)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_5","uri":"capability://data.processing.analysis.memory.room.semantic.organization","name":"memory-room-semantic-organization","description":"Automatically organizes memories into semantic rooms (conceptual domains) based on content analysis and user-defined room schemas. Uses clustering algorithms to group related memories and assign them to appropriate rooms, with support for hierarchical room structures (rooms within rooms). Enables agents to navigate memory by domain (e.g., 'user preferences', 'technical decisions', 'conversation history') rather than flat lists.","intents":["Automatically categorize agent memories into logical domains without manual tagging","Create hierarchical memory organization that mirrors how humans organize knowledge","Enable agents to scope memory queries to specific domains (e.g., 'find memories in the user preferences room')"],"best_for":["Agents accumulating diverse memories across multiple domains","Systems where memory organization structure is not known in advance","Teams wanting automatic memory categorization without manual schema definition"],"limitations":["Clustering algorithm is O(n²) for n memories — becomes slow with >10k memories without optimization","Room assignment is probabilistic; edge-case memories may be misclassified and require manual correction","Hierarchical room depth is limited to ~5 levels before navigation becomes inefficient"],"requires":["Clustering library (e.g., scikit-learn via Python subprocess, or JavaScript clustering library)","Embedding model for semantic similarity (same as retrieval capability)","Optional: user-defined room schema for guided organization"],"input_types":["raw memories (text, structured data)","optional room schema (JSON defining room hierarchy and keywords)","clustering parameters (number of rooms, similarity threshold)"],"output_types":["organized memory palace (memories assigned to rooms)","room hierarchy (tree structure)","room metadata (name, description, keywords)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_6","uri":"capability://data.processing.analysis.memory.persistence.abstraction","name":"memory-persistence-abstraction","description":"Provides a pluggable persistence layer abstraction that allows swapping storage backends (in-memory, file system, SQL database, vector database) without changing agent code. Implements a standard interface for memory read/write/delete operations with support for transactions and consistency guarantees. Includes reference implementations for common backends (JSON file, SQLite, PostgreSQL) and enables custom backend implementations.","intents":["Choose different storage backends for different deployment scenarios (local dev vs. production)","Migrate memories between storage systems without rewriting agent code","Implement custom persistence logic (e.g., encrypted storage, distributed replication)"],"best_for":["Teams deploying agents across multiple environments with different storage requirements","Systems requiring custom persistence logic (encryption, replication, backup)","Developers wanting to avoid vendor lock-in to specific storage systems"],"limitations":["Abstraction adds ~10-30ms overhead per operation due to interface indirection","Consistency guarantees vary by backend — some backends (in-memory) offer strong consistency, others (distributed) offer eventual consistency","Custom backend implementations require careful handling of concurrent access and data corruption"],"requires":["Node.js 16+","Optional: database client libraries (sqlite3, pg, etc.) depending on chosen backend"],"input_types":["memory objects (rooms, nodes, relationships)","backend configuration (connection strings, credentials)","transaction specifications (read/write sets)"],"output_types":["persistence operation results (success/failure)","transaction confirmations","backend-specific metadata (row IDs, timestamps)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_7","uri":"capability://data.processing.analysis.memory.graph.pruning.and.consolidation","name":"memory-graph-pruning-and-consolidation","description":"Implements automatic memory pruning strategies to prevent unbounded growth of the memory graph. Uses configurable policies (LRU, semantic similarity deduplication, importance scoring) to identify and remove or consolidate redundant/stale memories. Supports manual pruning triggers and automatic background pruning based on memory size thresholds or age.","intents":["Prevent memory graph from growing unboundedly and consuming storage/compute resources","Consolidate similar memories to reduce redundancy and improve retrieval speed","Remove stale memories while preserving important historical context"],"best_for":["Long-running agents that accumulate memories over weeks/months","Systems with strict storage or compute budgets","Applications where memory quality matters more than quantity"],"limitations":["Pruning decisions are heuristic-based; important memories may be incorrectly marked for deletion","Consolidation requires re-embedding similar memories, adding computational overhead","No undo mechanism for pruned memories — requires external backup for recovery"],"requires":["Pruning policy configuration (LRU window, similarity threshold, importance model)","Optional: embedding model for similarity-based deduplication","Background task scheduler (Node.js timer, cron, or external scheduler)"],"input_types":["memory graph (rooms, nodes, relationships)","pruning policy (LRU window, thresholds, importance weights)","trigger condition (size threshold, age threshold, manual trigger)"],"output_types":["pruned memory graph","pruning report (memories removed, consolidations performed)","consolidated memory nodes (merged from similar originals)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_8","uri":"capability://planning.reasoning.memory.context.window.optimization","name":"memory-context-window-optimization","description":"Intelligently selects and formats memories for inclusion in agent context windows, respecting token limits while maximizing relevance. Uses a multi-stage selection process: semantic filtering (retrieve top-k relevant memories), importance ranking (score by frequency/recency), and token-aware formatting (compress memories to fit within budget). Supports different formatting strategies (summarization, bullet points, full text) optimized for different context window sizes.","intents":["Include the most relevant memories in agent context without exceeding token limits","Automatically summarize memories when full text would exceed token budget","Adapt memory formatting based on available context window space"],"best_for":["Agents with limited context windows (e.g., Claude 100k vs. GPT-4 8k)","Systems where memory relevance varies significantly between tasks","Applications requiring careful token budgeting across multiple memory sources"],"limitations":["Token counting is approximate — actual token usage may vary by 5-10% depending on tokenizer","Summarization reduces memory fidelity; important details may be lost in compression","Multi-stage selection adds ~100-300ms latency per context window construction"],"requires":["Token counter for target model (OpenAI, Anthropic, or compatible)","Summarization model (optional, for compression-based formatting)","Memory retrieval system (from semantic-memory-retrieval-with-ranking capability)"],"input_types":["retrieved memories (ranked list)","token budget (available tokens for memories)","formatting strategy (summarization, bullet points, full text)","model tokenizer (for accurate token counting)"],"output_types":["formatted memory context (text ready for agent context)","token usage report (actual tokens used, budget remaining)","memory selection metadata (which memories included, why others excluded)"],"categories":["planning-reasoning","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-agent-recall-core__cap_9","uri":"capability://safety.moderation.memory.access.audit.and.logging","name":"memory-access-audit-and-logging","description":"Logs all memory access operations (read, write, delete) with timestamps, agent identifiers, and access context. Enables audit trails for compliance and debugging, with support for filtering logs by agent, time range, or operation type. Provides analytics on memory access patterns (hot memories, access frequency, temporal trends) to identify which memories are most valuable.","intents":["Maintain audit trail of agent memory access for compliance and debugging","Identify which memories are most frequently accessed and valuable","Detect anomalous memory access patterns (e.g., agent accessing memories it shouldn't)"],"best_for":["Organizations with compliance requirements (HIPAA, SOC2, etc.)","Teams debugging agent behavior and needing to trace memory interactions","Systems where memory access patterns reveal agent behavior insights"],"limitations":["Logging adds ~5-20ms overhead per memory operation","Log storage grows linearly with memory access volume — requires log rotation/archival","Analytics computation is O(n) over log entries; large logs require external analytics database"],"requires":["Logging backend (file system, database, or external logging service)","Optional: analytics database (Elasticsearch, BigQuery, etc.) for pattern analysis"],"input_types":["memory access operations (read, write, delete)","agent context (agent ID, task, timestamp)","access metadata (memory ID, operation type, result)"],"output_types":["audit logs (structured entries with timestamps and context)","access analytics (frequency, temporal patterns, hot memories)","compliance reports (filtered logs for specific time ranges or agents)"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":33,"verified":false,"data_access_risk":"high","permissions":["Node.js 16+","MCP server runtime (Claude Desktop or compatible MCP host)","Optional: LangChain or CrewAI for agent integration","Claude API access (or Claude Desktop with MCP support)","MCP server runtime (e.g., Claude Desktop, Cline, or custom MCP host)","Node.js 16+ for running MCP server","Conflict detection mechanism (version tracking, timestamps, or checksums)","Merge strategy implementation (last-write-wins, semantic merging, etc.)","Optional: embedding model for semantic conflict detection","Embedding model API (OpenAI, Anthropic, Ollama, or local model)"],"failure_modes":["No built-in persistence layer — requires external database integration (e.g., PostgreSQL, MongoDB) for durability","Spatial indexing overhead adds ~50-150ms per memory insertion depending on graph complexity","Scaling to millions of memories requires careful graph pruning; no automatic memory eviction policy included","MCP protocol adds ~100-200ms round-trip latency per tool call vs direct library calls","Tool schema complexity limits to ~50 concurrent memory operations per session before performance degradation","No built-in rate limiting or quota management — relies on host MCP server for throttling","Semantic merging requires embedding-based similarity, adding ~100-200ms per conflict resolution","Manual conflict resolution requires human intervention — blocks agent execution until resolved","Merge strategy selection is heuristic-based; some conflicts may be resolved incorrectly","Embedding generation requires external model (OpenAI, Anthropic, or local) — adds 50-500ms per retrieval depending on batch size","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.1391993072259713,"quality":0.32,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:23.328Z","last_scraped_at":"2026-04-22T08:08:13.653Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":1233,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=agent-recall-core","compare_url":"https://unfragile.ai/compare?artifact=agent-recall-core"}},"signature":"GQ0qYcmdygWcSOoHTR9NDHu0I+C8e78clKxhjNxaBrsuSw/kUmAMjhPG+eF9vMVXxBOsr6hx8UzPjwhtopiSCw==","signedAt":"2026-06-20T23:51:01.209Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/agent-recall-core","artifact":"https://unfragile.ai/agent-recall-core","verify":"https://unfragile.ai/api/v1/verify?slug=agent-recall-core","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}