{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"mem0","slug":"mem0","name":"Mem0","type":"repo","url":"https://github.com/mem0ai/mem0","page_url":"https://unfragile.ai/mem0","categories":["ai-agents","rag-knowledge"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"mem0__cap_0","uri":"capability://memory.knowledge.llm.powered.fact.extraction.with.single.pass.memory.ingestion","name":"llm-powered fact extraction with single-pass memory ingestion","description":"Automatically extracts structured facts from unstructured conversational input using LLM-based parsing, deduplicating and normalizing information in a single forward pass rather than multi-stage processing. The system uses configurable LLM providers (OpenAI, Anthropic, Ollama) to identify entities, relationships, and user preferences, then stores them in a unified memory graph. This approach achieves 91.6 accuracy on LoCoMo benchmark while reducing token consumption by 3-4x compared to multi-pass extraction pipelines.","intents":["I want to automatically capture user preferences and facts from conversations without manual tagging","I need to extract structured information from free-form text while minimizing API calls and latency","I want to deduplicate similar facts across multiple conversations to build a unified user profile"],"best_for":["AI agent builders creating personalized assistants","Teams building conversational AI with persistent user context","Developers optimizing token efficiency in memory-heavy applications"],"limitations":["Extraction quality depends on LLM provider capability; smaller models may miss nuanced facts","Single-pass approach requires careful prompt engineering to avoid hallucinated facts","No built-in validation layer — requires external fact-checking for high-stakes domains"],"requires":["LLM API key (OpenAI, Anthropic, or self-hosted Ollama)","Python 3.9+ or Node.js 16+","Vector store backend (Pinecone, Weaviate, Qdrant, or local Chroma)"],"input_types":["conversational text","user messages","structured JSON metadata"],"output_types":["extracted facts (structured JSON)","entity-relationship pairs","vector embeddings"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_1","uri":"capability://memory.knowledge.multi.scope.memory.isolation.with.session.and.user.level.filtering","name":"multi-scope memory isolation with session and user-level filtering","description":"Provides hierarchical memory scoping across user, agent, and session boundaries, allowing developers to isolate and retrieve memories at different granularity levels. The Memory class and MemoryClient implement scope-aware filtering through query parameters and session context, enabling selective memory retrieval based on conversation context, user identity, or agent role. Supports advanced filtering with metadata predicates and temporal constraints to retrieve only relevant memories for a given interaction.","intents":["I need to keep memories separate for different users while allowing cross-user insights in multi-tenant systems","I want to retrieve only session-specific memories to avoid context pollution from unrelated conversations","I need to filter memories by metadata (e.g., topic, timestamp, source) to surface only relevant context"],"best_for":["Multi-tenant SaaS platforms with strict data isolation requirements","Conversational agents handling multiple concurrent sessions","Applications requiring fine-grained access control over memory retrieval"],"limitations":["Filtering adds query latency (~50-100ms per filter predicate depending on backend)","Complex nested filters may require custom query logic not exposed in standard API","Session-level isolation requires explicit session management; no automatic cleanup of stale sessions"],"requires":["Memory instance initialized with scope configuration","Vector store or graph store backend supporting metadata filtering","Session management layer (Mem0 provides session context but not persistence)"],"input_types":["session ID","user ID","agent ID","metadata filters (JSON)"],"output_types":["filtered memory list","scoped context window","metadata-enriched memories"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_10","uri":"capability://automation.workflow.cli.tool.with.agent.mode.for.autonomous.memory.management","name":"cli tool with agent mode for autonomous memory management","description":"Provides a command-line interface for memory operations (add, search, update, delete, export) with an 'agent mode' that enables autonomous memory management through natural language commands. In agent mode, the CLI accepts free-form instructions (e.g., 'remember that I prefer decaf coffee') and automatically routes them to appropriate memory operations, making memory management accessible without API knowledge.","intents":["I want to manage memories from the command line without writing code","I need to quickly add or search memories during development and testing","I want to use natural language to instruct the system to manage memories autonomously"],"best_for":["Developers prototyping and testing memory features","Non-technical users managing memories through CLI","DevOps teams automating memory operations in scripts"],"limitations":["CLI is less efficient than programmatic API for high-volume operations","Agent mode relies on LLM interpretation; ambiguous commands may be misrouted","No built-in output formatting for complex queries; requires piping to external tools","Agent mode adds latency due to LLM call for command interpretation"],"requires":["Python 3.9+ or Node.js 16+","Mem0 API key or self-hosted instance URL","CLI tool installed (pip install mem0 or npm install @mem0/cli)"],"input_types":["command-line arguments","natural language instructions (agent mode)","JSON input files"],"output_types":["formatted text output","JSON responses","operation status"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_11","uri":"capability://tool.use.integration.mcp.server.integration.for.ai.coding.agents.and.tool.use","name":"mcp server integration for ai coding agents and tool use","description":"Exposes Mem0 as a Model Context Protocol (MCP) server, enabling AI coding agents (e.g., Devin, Claude with tools) to use memory operations as native tools. The MCP server implements standard tool schemas for add, search, update, and delete operations, allowing agents to autonomously manage memories as part of their reasoning and planning. This enables agents to build and maintain context across multiple coding tasks.","intents":["I want my AI coding agent to remember project context and user preferences across sessions","I need to enable Claude or other AI agents to autonomously manage memory as part of their tool use","I want agents to retrieve relevant context from memory during code generation and analysis"],"best_for":["AI coding agents and autonomous development tools","Teams using Claude with tool use for development tasks","Applications requiring agents to maintain persistent context"],"limitations":["MCP server adds network latency for each tool call (~100-300ms)","Agents may misuse memory tools (e.g., storing irrelevant context); requires guardrails","Tool schema is fixed; custom memory operations require MCP server modifications","No built-in rate limiting per agent; requires external quota management"],"requires":["MCP-compatible AI agent (Claude, Devin, etc.)","Mem0 MCP server running (Docker or self-hosted)","Network connectivity between agent and MCP server"],"input_types":["tool call requests (JSON)","memory operation parameters"],"output_types":["tool results (JSON)","memory operation responses"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_12","uri":"capability://automation.workflow.telemetry.and.performance.analytics.with.token.usage.tracking","name":"telemetry and performance analytics with token usage tracking","description":"Provides built-in telemetry collection for memory operations, tracking metrics like token usage, latency, cache hit rates, and operation success rates. The system exposes these metrics through a dashboard and API, enabling developers to monitor memory system performance and optimize configurations. Token usage tracking helps teams understand and control costs associated with LLM calls for fact extraction and comparison.","intents":["I want to track how many tokens my memory operations are consuming to estimate costs","I need to monitor memory operation latency and identify performance bottlenecks","I want to see cache hit rates and optimize my memory retrieval strategy"],"best_for":["Cost-conscious teams optimizing LLM token usage","Performance-sensitive applications requiring latency monitoring","Teams debugging memory system issues and bottlenecks"],"limitations":["Telemetry collection adds ~5-10% overhead to memory operations","Token counting is provider-specific; estimates may vary by LLM provider","Dashboard analytics are limited; advanced analysis requires exporting raw metrics","Telemetry data retention is limited (typically 30 days); requires external storage for long-term analysis"],"requires":["Telemetry collection enabled in configuration","Access to dashboard or metrics API","Optional: external analytics platform for advanced analysis"],"input_types":["memory operation logs","performance metrics"],"output_types":["dashboard visualizations","metrics API responses","cost reports"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_13","uri":"capability://memory.knowledge.custom.prompt.templates.for.memory.extraction.and.comparison","name":"custom prompt templates for memory extraction and comparison","description":"Allows developers to customize the LLM prompts used for fact extraction, semantic comparison, and memory updates through a template system. Developers can define domain-specific extraction rules (e.g., for healthcare, finance) to improve extraction accuracy and relevance. The system supports prompt versioning and A/B testing to evaluate different extraction strategies.","intents":["I want to customize fact extraction for my domain (e.g., healthcare, finance) to improve accuracy","I need to define domain-specific rules for what constitutes a 'memory' in my application","I want to A/B test different extraction prompts to optimize quality"],"best_for":["Domain-specific applications with specialized memory requirements","Teams optimizing extraction accuracy for their use case","Applications requiring custom memory semantics"],"limitations":["Prompt engineering is non-trivial; poor prompts degrade extraction quality","Custom prompts may not generalize across different LLM providers","A/B testing requires significant data volume to achieve statistical significance","Prompt changes require reprocessing existing memories for consistency"],"requires":["Understanding of prompt engineering best practices","Access to custom prompt configuration","Optional: evaluation framework for measuring extraction quality"],"input_types":["prompt template (Jinja2 or similar)","extraction rules (JSON)","test data"],"output_types":["customized extraction results","quality metrics","A/B test results"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_2","uri":"capability://memory.knowledge.hybrid.vector.graph.memory.retrieval.with.semantic.and.structural.search","name":"hybrid vector-graph memory retrieval with semantic and structural search","description":"Combines vector similarity search with graph-based entity-relationship retrieval to surface memories through both semantic relevance and structural connections. The system stores facts as nodes in a knowledge graph (using Neo4j, Kuzu, or other graph stores) while maintaining vector embeddings for semantic search, then performs hybrid retrieval by querying both backends and reranking results. This dual-index approach enables finding memories that are semantically similar OR structurally related to the query, improving recall for complex user intents.","intents":["I want to find memories that are semantically similar to a query AND structurally connected through entity relationships","I need to retrieve context about a user's preferences and their related entities (e.g., favorite restaurants and their cuisines)","I want to surface memories based on both keyword similarity and knowledge graph traversal"],"best_for":["Knowledge-intensive applications (healthcare, finance, customer support)","Systems requiring both semantic understanding and structured reasoning","Applications where entity relationships matter as much as semantic similarity"],"limitations":["Maintaining dual indexes (vector + graph) increases storage overhead by 2-3x","Hybrid retrieval requires two separate queries and reranking, adding ~100-200ms latency","Graph store configuration is complex; requires careful entity extraction and relationship definition","Similarity threshold tuning is non-trivial; threshold too low causes noise, too high causes missed results"],"requires":["Vector store (Pinecone, Weaviate, Qdrant, Chroma)","Graph store (Neo4j, Kuzu, or compatible backend)","Embedding model (OpenAI, Hugging Face, or custom)","Reranking model (optional but recommended for quality)"],"input_types":["natural language query","entity names","relationship predicates"],"output_types":["ranked memory list","entity-relationship subgraphs","relevance scores"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_3","uri":"capability://automation.workflow.asynchronous.memory.operations.with.batch.processing.and.proxy.integration","name":"asynchronous memory operations with batch processing and proxy integration","description":"Provides async/await patterns for memory operations (add, search, update, delete) with built-in batching to reduce API calls and improve throughput. The system queues memory operations and processes them in configurable batch sizes, with optional proxy integration for request routing and rate limiting. Supports both synchronous and asynchronous APIs, allowing developers to choose blocking or non-blocking semantics based on application requirements.","intents":["I want to add multiple memories in a single batch operation without blocking the conversation loop","I need to rate-limit memory operations to avoid hitting API quotas","I want to queue memory updates and process them asynchronously in the background"],"best_for":["High-throughput conversational systems with many concurrent users","Applications with strict latency budgets (e.g., real-time chat)","Systems integrating with rate-limited external APIs"],"limitations":["Batch processing introduces variable latency; individual operation latency depends on batch fill time","Async operations require careful error handling; failed batch operations may lose individual operation context","Proxy integration adds network hop and potential single point of failure","No built-in retry logic for failed batch operations; requires external orchestration"],"requires":["Python 3.9+ with asyncio or Node.js 16+ with Promise support","Event loop or async runtime","Optional: proxy server for request routing (e.g., nginx, custom middleware)"],"input_types":["memory operation list","batch size configuration","timeout settings"],"output_types":["batch operation results","error logs","performance metrics"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_4","uri":"capability://memory.knowledge.intelligent.memory.update.and.deduplication.with.semantic.similarity.matching","name":"intelligent memory update and deduplication with semantic similarity matching","description":"Automatically detects and merges semantically similar memories using configurable similarity thresholds and LLM-based fact comparison. When new information is added, the system searches for existing memories with similar semantic content, compares them using an LLM, and either merges them (updating the existing memory) or creates a new one. This prevents memory bloat and ensures the memory store remains concise and non-redundant, even as new information is continuously ingested.","intents":["I want to update existing memories when new information contradicts or refines previous facts","I need to automatically merge duplicate memories to keep the memory store lean","I want to track how user preferences evolve over time without creating redundant memory entries"],"best_for":["Long-running conversational agents with continuous memory ingestion","Applications requiring memory compaction and deduplication","Systems where memory size directly impacts retrieval latency"],"limitations":["Similarity matching requires LLM calls for each new memory; adds ~500ms-1s latency per add operation","Threshold tuning is domain-specific; generic thresholds may over-merge or under-merge","Merge logic is lossy; combining memories may lose nuanced details from either original","No built-in conflict resolution for contradictory facts; requires custom logic"],"requires":["LLM provider for similarity comparison","Vector store for semantic search of candidate memories","Similarity threshold configuration (typically 0.7-0.9)"],"input_types":["new memory fact","similarity threshold","merge strategy configuration"],"output_types":["updated memory","merge decision (merged/new)","merge audit trail"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_5","uri":"capability://tool.use.integration.multi.provider.llm.and.embedding.abstraction.with.pluggable.model.selection","name":"multi-provider llm and embedding abstraction with pluggable model selection","description":"Abstracts away LLM and embedding provider differences through a factory pattern that supports OpenAI, Anthropic, Ollama, Hugging Face, and other providers. Developers configure providers via a unified config interface and can swap providers without code changes. The system handles provider-specific API differences (e.g., function calling formats, token counting, rate limits) internally, exposing a consistent interface for fact extraction, similarity comparison, and reranking.","intents":["I want to switch between OpenAI and Anthropic without rewriting my memory integration code","I need to use a self-hosted Ollama model for privacy-sensitive memory operations","I want to use different embedding models for different memory types (e.g., dense for semantic, sparse for keyword)"],"best_for":["Teams evaluating multiple LLM providers","Applications with privacy requirements (self-hosted models)","Cost-sensitive systems needing provider flexibility for optimization"],"limitations":["Provider abstraction adds ~50-100ms overhead per LLM call due to adapter logic","Not all providers support all features (e.g., some lack function calling); fallback behavior must be defined","Token counting varies by provider; cost estimation may be inaccurate across providers","Rate limits and quota management are provider-specific; no unified rate limiting across providers"],"requires":["API keys for selected providers (OpenAI, Anthropic, etc.)","Configuration file specifying provider and model names","Python 3.9+ or Node.js 16+"],"input_types":["provider configuration (JSON)","model name","API credentials"],"output_types":["LLM response","embedding vector","token usage metrics"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_6","uri":"capability://memory.knowledge.memory.export.and.audit.trail.tracking.with.versioning","name":"memory export and audit trail tracking with versioning","description":"Provides comprehensive memory export capabilities (JSON, CSV, structured formats) with full audit trails tracking all memory modifications (add, update, delete) including timestamps, user IDs, and change deltas. The system maintains immutable history records for compliance and debugging, allowing developers to reconstruct memory state at any point in time. Supports selective export by scope, date range, or metadata filters.","intents":["I need to export all memories for a user for GDPR/privacy compliance","I want to audit who modified which memories and when for security and debugging","I need to reconstruct the memory state at a specific point in time for troubleshooting"],"best_for":["Regulated industries (healthcare, finance) with audit requirements","Multi-user systems requiring accountability and transparency","Applications needing data portability and user data export"],"limitations":["Maintaining full audit trails increases storage overhead by 2-5x","Export operations on large memory stores (>100k memories) may take minutes","Selective export with complex filters requires full table scans on some backends","No built-in encryption for exported data; requires external encryption for sensitive exports"],"requires":["Access to memory backend with audit trail support","Storage for exported files (local filesystem or cloud storage)","Sufficient disk space for full memory exports"],"input_types":["export format (JSON, CSV)","scope filters (user ID, date range, metadata)","output destination"],"output_types":["exported memory file","audit trail report","versioned snapshots"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_7","uri":"capability://tool.use.integration.rest.api.with.multi.tenant.organization.and.project.scoping","name":"rest api with multi-tenant organization and project scoping","description":"Exposes memory operations through a REST API with built-in multi-tenant support via organizations and projects. The API implements role-based access control (RBAC) with API key authentication, allowing teams to manage multiple projects and users within organizations. Supports webhooks for event-driven integrations, enabling external systems to react to memory changes (e.g., trigger workflows on memory updates).","intents":["I want to expose memory operations to external services via REST API","I need to manage multiple projects and teams within a single organization","I want to trigger workflows when memories are added or updated"],"best_for":["SaaS platforms offering memory as a service","Teams integrating Mem0 with external systems via REST","Applications requiring webhook-driven event processing"],"limitations":["REST API adds network latency (~50-200ms per request) compared to in-process library calls","Webhook delivery is asynchronous and not guaranteed; requires idempotency handling","API rate limiting is per-organization; high-volume users may hit quotas","No built-in request signing for webhook verification; requires custom HMAC validation"],"requires":["Hosted Mem0 platform account or self-hosted server deployment","API key for authentication","HTTP client library","Webhook endpoint for event delivery (optional)"],"input_types":["JSON request body","query parameters","API key header"],"output_types":["JSON response","HTTP status codes","webhook events"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_8","uri":"capability://tool.use.integration.client.sdk.integration.with.framework.adapters.vercel.ai.langchain.openclaw","name":"client sdk integration with framework adapters (vercel ai, langchain, openclaw)","description":"Provides native SDKs for Python and TypeScript/JavaScript with framework-specific adapters for Vercel AI, LangChain, and OpenClaw. These adapters integrate Mem0 as a drop-in memory layer for existing agent frameworks, automatically handling memory ingestion, retrieval, and context injection. The Vercel AI adapter, for example, integrates with the useChat hook, automatically capturing conversation history and user context.","intents":["I want to add persistent memory to my existing Vercel AI or LangChain application without major refactoring","I need to automatically capture and retrieve context in my agent framework","I want to use Mem0 as a memory backend for my OpenClaw agent"],"best_for":["Developers already using Vercel AI, LangChain, or OpenClaw","Teams wanting to add memory without rewriting agent logic","Applications requiring minimal integration effort"],"limitations":["Framework adapters may lag behind core Mem0 feature releases","Adapter behavior is framework-specific; not all Mem0 features are exposed in all adapters","Integration adds dependency on both Mem0 and the framework; version mismatches can cause issues","Custom memory logic may require bypassing adapters and using core API directly"],"requires":["Vercel AI SDK, LangChain, or OpenClaw installed","Python 3.9+ or Node.js 16+","Mem0 API key or self-hosted instance"],"input_types":["framework-specific message objects","conversation history","user context"],"output_types":["augmented context","memory-enriched responses","framework-compatible objects"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__cap_9","uri":"capability://automation.workflow.self.hosted.server.deployment.with.authentication.and.dashboard","name":"self-hosted server deployment with authentication and dashboard","description":"Provides a self-hosted server option for on-premise or private cloud deployment, with built-in authentication (API key, OAuth), a web dashboard for memory management, and CLI tools for administration. The server exposes the same REST API as the hosted platform, enabling organizations to run Mem0 in their own infrastructure while maintaining feature parity with the cloud version.","intents":["I need to run Mem0 on-premise for data residency or compliance requirements","I want to manage memories through a web dashboard without API calls","I need to deploy Mem0 in a private cloud or air-gapped environment"],"best_for":["Enterprise organizations with data residency requirements","Teams with strict security or compliance policies","Applications requiring complete control over infrastructure"],"limitations":["Self-hosted deployment requires infrastructure management (scaling, backups, monitoring)","No automatic updates; requires manual deployment of new versions","Dashboard is basic; lacks advanced analytics and monitoring features of hosted platform","Self-hosted instances don't benefit from platform-level optimizations and scaling"],"requires":["Docker or Kubernetes for containerized deployment","PostgreSQL or compatible database for metadata storage","Vector store backend (Pinecone, Weaviate, Qdrant, or local Chroma)","Optional: graph store for graph memory features","Reverse proxy (nginx) for TLS termination and load balancing"],"input_types":["Docker image","configuration files","environment variables"],"output_types":["running server instance","REST API endpoint","dashboard UI"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"mem0__headline","uri":"capability://memory.knowledge.persistent.memory.layer.for.ai.agents","name":"persistent memory layer for ai agents","description":"Mem0 is a universal memory layer designed for AI applications that provides persistent, contextual memory across conversations, enabling personalized interactions and intelligent retrieval of user information.","intents":["best memory layer for AI","persistent memory for AI agents","contextual memory solutions","AI memory frameworks for personalized interactions","how to implement memory in AI applications"],"best_for":["AI agents","personalized user experiences"],"limitations":[],"requires":[],"input_types":[],"output_types":[],"categories":["memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":57,"verified":false,"data_access_risk":"high","permissions":["LLM API key (OpenAI, Anthropic, or self-hosted Ollama)","Python 3.9+ or Node.js 16+","Vector store backend (Pinecone, Weaviate, Qdrant, or local Chroma)","Memory instance initialized with scope configuration","Vector store or graph store backend supporting metadata filtering","Session management layer (Mem0 provides session context but not persistence)","Mem0 API key or self-hosted instance URL","CLI tool installed (pip install mem0 or npm install @mem0/cli)","MCP-compatible AI agent (Claude, Devin, etc.)","Mem0 MCP server running (Docker or self-hosted)"],"failure_modes":["Extraction quality depends on LLM provider capability; smaller models may miss nuanced facts","Single-pass approach requires careful prompt engineering to avoid hallucinated facts","No built-in validation layer — requires external fact-checking for high-stakes domains","Filtering adds query latency (~50-100ms per filter predicate depending on backend)","Complex nested filters may require custom query logic not exposed in standard API","Session-level isolation requires explicit session management; no automatic cleanup of stale sessions","CLI is less efficient than programmatic API for high-volume operations","Agent mode relies on LLM interpretation; ambiguous commands may be misrouted","No built-in output formatting for complex queries; requires piping to external tools","Agent mode adds latency due to LLM call for command interpretation","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.49999999999999994,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:04.693Z","last_scraped_at":null,"last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mem0","compare_url":"https://unfragile.ai/compare?artifact=mem0"}},"signature":"roz04kuN6dJ7PJko1r52GAay9+CmZAqiCebMeMJ0jKqsenmI8Oh23YLZEcTggp2n+v5RkGMve9G99I4CnLGSCQ==","signedAt":"2026-06-20T18:42:59.174Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mem0","artifact":"https://unfragile.ai/mem0","verify":"https://unfragile.ai/api/v1/verify?slug=mem0","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"}}