mem0ai/mem0

Mem0 is a polyglot memory infrastructure system that enables AI agents and applications to store, retrieve, and manage long-term user and agent memories. It provides Python and TypeScript SDKs, command-line interfaces, and a self-hosted server to support a v3 memory architecture featuring hybrid search, entity extraction, and modular integrations with various LLMs, vector stores, and agent frameworks.

48 changes.

The project rebranded from embedchain to Mem0, introducing a comprehensive v3 memory architecture with hybrid retrieval, entity linking, and modular provider systems for LLMs, embeddings, and vector stores. This period saw the launch of a TypeScript SDK alongside the existing Python SDK, enabling a polyglot monorepo structure with self-hosted server capabilities and extensive integration plugins. Development focused on stabilizing the new memory pipeline through structured configurations, robust error handling, and broad ecosystem examples.

31 changes.

This period focused on launching official Node.js and Python CLIs with agent-mode support, while establishing the foundational database schema, authentication, and Docker deployment capabilities for the self-hosted server dashboard. Concurrently, the team expanded the TypeScript SDK with new reranking providers, vector store integrations, and comprehensive test coverage across clients and utilities.

Users can now use Mem0 memory within LangChain applications via the new \Mem0Memory\ class in the \mem0-ts/src/community\ package. This integration allows developers to pass an API key and session ID to automatically load, save, and format chat history as system or human messages, enabling persistent context in LangChain conversational chains.

mem0-ts/src/community · high confidence

The \examples/mem0-demo\ directory now contains a complete Next.js application that demonstrates Mem0's memory capabilities. The demo features a chat interface powered by the \@mem0/vercel-ai-provider\ and \@ai-sdk/openai\, which retrieves user-specific memories to personalize responses and highlights deduced information using \\<highlight\>\ tags. It includes an API route (\/api/chat\) that streams text and annotations for memory updates, a React UI with dark mode support and thread management, and standard configuration files (Tailwind, TypeScript, ESLint) to run the example locally.

examples/mem0-demo · high confidence

An example script has been added to demonstrate how to use the Mistral LLM provider. The script initializes the MistralLLM client, performs a simple chat completion, and tests tool calling functionality, requiring the MISTRAL\_API\_KEY environment variable.

mem0-ts/src/oss/examples/llms · high confidence

Provides a new example setup in the \examples/nemoclaw\ directory that enables users to install the \@mem0/openclaw-mem0\ plugin for long-term memory in NemoClaw. The entry includes a comprehensive \quickstart.md\ guide and two executable shell scripts: \setup-mem0-nemoclaw.sh\ for a full end-to-end installation (NemoClaw + Mem0) and \install-mem0-plugin.sh\ for adding the plugin to an existing NemoClaw sandbox. These scripts handle platform detection (macOS via Docker, Linux native, WSL 2), prerequisite checks, and plugin configuration.

examples/nemoclaw · high confidence

Introduces a new Vercel AI SDK chat application example that integrates with Mem0 for memory management. The app provides a React-based UI for chatting with AI models (OpenAI, Anthropic, Cohere, Groq) while maintaining user-specific context. Key features include an API settings dialog for configuring Mem0 and provider keys, a user ID selector for session management, and a side panel for displaying relevant memories. The implementation uses shadcn/ui components, Tailwind CSS, and the @mem0/vercel-ai-provider for AI interactions.

examples/vercel-ai-sdk-chat-app · high confidence

This change introduces a new Chrome extension example located in \examples/yt-assistant-chrome\ that integrates an AI chat interface directly into YouTube pages. The extension uses the Manifest V3 format and injects a content script to display a chat panel alongside video content. It leverages OpenAI's API for chat completions and integrates with Mem0 for personalized memory capabilities, allowing users to store and retrieve context about their learning journey. The extension includes a popup for API key configuration and a dedicated options page for managing model settings (such as model selection, max tokens, and temperature) and managing stored memories. It requires OpenAI and Mem0 API keys to function and operates on YouTube video pages.

examples/yt-assistant-chrome · high confidence

The examples/multimodal-demo directory now contains a complete React-based chat application that supports multimodal input (text and images) and integrates with the Mem0 memory system. Users can configure API keys for Mem0 and various LLM providers (OpenAI, Anthropic, Cohere, Groq) via a settings dialog, select a user identity, and view relevant memories in a collapsible sidebar. The demo includes full UI components for chat history, file attachment handling, and provider selection, wired together through React context and custom hooks.

examples/multimodal-demo · high confidence

The examples directory now includes runnable demo scripts for integrating the TypeScript SDK with Azure AI Search, Supabase, PGVector, Qdrant, and Redis vector stores. These new examples, alongside existing in-memory and Supabase demos, allow users to quickly test and configure their preferred vector storage backend by setting the corresponding environment variables and running the specific demo script.

mem0-ts/src/oss/examples/vector-stores · high confidence

The server dashboard now includes a Dockerfile, entrypoint script, and configuration files to enable containerized deployment. The setup uses a multi-stage build with Node 20 Alpine, outputs a standalone Next.js application, and exposes port 3000. The entrypoint script dynamically replaces build-time environment variable placeholders (NEXT\_PUBLIC\_API\_URL, NEXT\_PUBLIC\_INSTANCE\_NAME) with runtime values. Security headers (X-Frame-Options, CSP, etc.) are configured in next.config.mjs, and pnpm overrides are applied to enforce minimum versions for several dependencies.

server/dashboard · high confidence

This change introduces the foundational database schema and Alembic migration infrastructure required for the self-hosted dashboard and admin authentication system. It establishes the initial database structure through a series of migrations: creating core tables for users (with admin role constraints), API keys, request logs, and application settings; adding a table to track refresh token usage for single-session security; and optimizing the request logs index for performance. The \env.py\ configuration ensures these migrations correctly integrate with the application's runtime database URL.

server/alembic · high confidence

The \mem0-ts\ directory introduces the initial version of the Mem0 TypeScript SDK, providing both a hosted \MemoryClient\ for the Mem0 Platform and a self-hosted \Memory\ class for open-source usage. The SDK includes a structured exception system (\MemoryError\ and subclasses) that maps HTTP status codes to actionable errors with suggestions and debug info. It supports dual CJS/ESM builds via \tsup\, uses \better-sqlite3\ for local storage, and integrates with a wide range of vector stores (e.g., Pinecone, Chroma, Milvus, Weaviate) and LLM/embedding providers. The release also includes comprehensive Jest unit and integration test configurations, pnpm workspace overrides to remediate known vulnerabilities in dependencies (like \form-data\ and \undici\), and standard project scaffolding (\.gitignore\, \tsconfig\, documentation).

mem0-ts, mem0-ts/src/client, mem0-ts/src/oss/src · high confidence

This change introduces the core \Memory\ class and its associated type definitions for the TypeScript OSS SDK. It provides the foundational API for adding, searching, updating, and deleting memories, including support for entity isolation (user/agent/run IDs), metadata handling, and search filtering. The implementation includes validation for entity IDs and search parameters, stripping of identity keys from caller metadata to prevent scope injection, and integration with vector stores, LLMs, and rerankers via factory patterns.

mem0-ts/src/oss/src/memory · high confidence

This change introduces the foundational vector store layer for Mem0, adding a \VectorStoreBase\ abstract class and concrete implementations for multiple backends including Azure AI Search, Azure MySQL, Baidu, Cassandra, Chroma, Databricks, and Elasticsearch. It also includes a centralized configuration system (\VectorStoreConfig\) to manage provider-specific settings, enabling users to persist memories across a wide variety of supported databases.

_mem0/vector\stores · high confidence

The integrations/deepseek-plugin directory now contains the native DeepSeek Harness (Cordis) plugin for Mem0, providing two agent-callable tools: search\_memory to recall relevant facts and add\_memory to store new ones. The plugin supports configuration for API keys, user IDs, and optional host overrides, and can automatically recall memory context before model requests and capture completed conversation turns. It includes built-in telemetry to track usage events and manages session state to partition memories by user, agent, or run.

integrations/deepseek-plugin · high confidence

The memory module now includes a new OSS notice system (notices.py, oss\_notices\_config.json) that displays user-facing alerts for features like first-run, temporal/decay usage, scale thresholds, and slow queries, replacing the previous PostHog flag evaluation with a static config fallback. Additionally, telemetry sampling has been implemented to reduce PostHog volume by sampling hot-path events at 10% (configurable via MEM0\_TELEMETRY\_SAMPLE\_RATE) while ensuring lifecycle events always fire, and the telemetry singleton is now properly shut down at process exit to prevent thread leaks.

mem0/memory · high confidence

The mem0/proxy module now provides a new \Mem0\ client that exposes an OpenAI-compatible \chat.completions.create\ interface. This proxy automatically enriches user queries with relevant memories and entities by fetching context from the underlying Mem0 storage before sending the request to the specified LLM model. It supports standard LLM parameters (such as temperature, tools, and streaming) while requiring a user, agent, or run ID to associate interactions with specific memory contexts. The implementation uses the \litellm\ library to route completions and asynchronously updates memory in the background to avoid blocking the response.

mem0/proxy · high confidence

Users can now connect Mem0 to Zapier to automate memory workflows. This integration adds authentication via API key, and provides actions to add memories (with optional polling for completion), delete memories, and search or retrieve memories by user ID or semantic query.

integrations/zapier-mem0 · high confidence

The new mem0-strands integration provides a Strands MemoryStore backed by Mem0, enabling agents to persist and recall long-term memories across sessions. It supports both the hosted Mem0 platform and self-hosted OSS backends, offering two write modes: direct fact storage and server-side extraction from conversation messages. The integration also includes anonymous usage telemetry (opt-out via MEM0\_TELEMETRY=false) that reports event counts and failure types to Mem0's PostHog client without sending sensitive data like queries or memory content.

integrations/mem0-strands/python · high confidence

The \mem0/llms\ package has been restructured into a modular provider system, introducing dedicated implementation classes for Anthropic, AWS Bedrock, Azure OpenAI (standard and structured), DeepSeek, Gemini, Groq, LangChain, LiteLLM, and LM Studio. This change adds support for these specific LLM backends while centralizing common logic like reasoning-model detection and parameter handling in a new \LLMBase\ class. Users can now configure and utilize these diverse providers through the \LlmConfig\ class, which validates the expanded list of supported providers.

mem0/llms · high confidence

The mem0 search functionality now includes a dedicated reranker module that allows users to re-rank retrieved documents for higher relevance. This update introduces five distinct reranking strategies: Cohere, HuggingFace (Transformers), LLM-based (via LLMFactory), Sentence Transformers, and Zero Entropy. The HuggingFace reranker now uses sigmoid normalization for cross-encoder scores to provide more accurate relevance metrics, while the LLM reranker supports nested LLM configurations for non-OpenAI providers and clamps out-of-range scores to prevent parsing errors. All rerankers are exported from the package root for easy import and include fallback mechanisms to preserve original document order if reranking fails.

mem0/reranker · high confidence

This release adds the official mem0 CLI for Node.js, providing a full-featured command-line interface for managing memories and agent configurations. The CLI includes commands for memory operations (add, search, get, list, update, delete), management tasks (init, status, version, import, config), and agent-specific workflows (agent-rush). It features a rich, branded user interface with color-coded output, spinner animations, and structured help text. The tool supports JSON output for programmatic use, automatic API key validation, and persistent configuration stored in \~/.mem0/config.json. It also includes agent mode detection for seamless integration with AI coding assistants like Claude Code, Cursor, and Codex, along with anonymous telemetry reporting via PostHog.

cli/node/src · high confidence

Adds the \@mem0/cli\ package for Node.js, providing commands to initialize authentication, add, search, list, get, update, delete, and import memories. The CLI supports structured JSON output for programmatic consumption and includes a standalone telemetry sender that captures anonymous usage data via PostHog, resolving user identity through the API while ensuring errors are silently swallowed to avoid impacting the user experience.

cli/node · high confidence

The OSS storage layer now supports multiple history persistence strategies via a new \HistoryManager\ interface. Users can choose between an in-memory store (\MemoryHistoryManager\) for ephemeral sessions, a local file-based store using \better-sqlite3\ (\SQLiteManager\) for persistent local history and message management, or a cloud-backed store via Supabase (\SupabaseHistoryManager\). A \DummyHistoryManager\ is also provided for environments where history tracking is not required. This change enables flexible deployment options for memory history, including serverless-compatible cloud storage.

mem0-ts/src/oss/src/storage · high confidence

This change adds a new self-hosted FastAPI server and local dashboard to the \server/\ directory, enabling users to run Mem0 locally via Docker Compose. The server includes JWT-based dashboard login and API key authentication (enabled by default), a setup wizard for initial admin configuration, and a dashboard for managing memories, entities, and API keys. It uses PostgreSQL with pgvector for storage and supports configurable LLM/embedder models via environment variables. The release also introduces anonymous telemetry (opt-out via \MEM0\_TELEMETRY=false\), request log retention, and a migration path from the archived \ankane/pgvector\ image to the official \pgvector/pgvector:pg17\ image.

server · high confidence

This change introduces a new, structured configuration system for rerankers in \mem0/configs/rerankers\. It adds a base configuration class (\BaseRerankerConfig\) and specific configuration classes for supported providers including Cohere, HuggingFace, Sentence Transformer, Zero Entropy, and LLM-based rerankers. The \LLMRerankerConfig\ specifically supports nested LLM configurations via an \llm\ field, allowing users to pass provider-specific settings (like \provider\ and \config\ keys) that override top-level settings. A main \RerankerConfig\ class is also added to manage the provider selection and pass provider-specific configurations. This provides a more robust and type-safe way to configure reranking behavior across different providers.

mem0/configs/rerankers · high confidence

The Python CLI is now available as a first-class tool, providing commands for memory CRUD (add, search, list, delete), entity management, and configuration. It introduces an Agent Mode bootstrap flow that allows AI agents to automatically provision API keys and claim accounts via OTP, along with a dedicated \agent-rush\ command for a gamified memory-sharing event. Users can also track background processing via event commands, identify their agent identity, and import memories from JSON files.

_cli/python/src/mem0\cli/commands · high confidence

The OSS TypeScript library now includes structured Zod schemas (\FactRetrievalSchema\ and \MemoryUpdateSchema\) and corresponding prompt generation functions (\getFactRetrievalMessages\, \getUpdateMemoryMessages\) in the prompts module. This change formalizes the expected JSON output for extracting facts from conversations and managing memory states (ADD, UPDATE, DELETE, NONE), ensuring that LLM responses are validated against these schemas before further processing.

mem0-ts/src/oss/src/prompts · high confidence

Adds the \integrations/agent-plugin-core\ module, which centralizes shared Python and TypeScript behavior for coding-agent plugins (including Claude Code, Cursor, Codex, Kimi, and Antigravity), along with build scripts, validation schemas, and conformance tests. Introduces \integrations/AGENTS.md\ to document the integration layout, build commands, and surface attribution headers, and \integrations/CLAUDE.md\ as a symlink to that guide.

integrations · high confidence

The mem0 Python CLI is now available, providing a command-line interface to manage your memory layer. It includes commands for configuration, entity management, and event inspection, along with features like automatic agent-mode detection, API key validation, and anonymous usage telemetry via PostHog. The CLI also syncs your API key to ecosystem touchpoints like Claude Code and shell environments to ensure consistent access across tools.

_cli/python/src/mem0\cli · high confidence

The Mem0 demo application now features a comprehensive UI overhaul. It introduces a MemoryIndicator component that displays a badge and popover showing the status of retrieved and updated memories (accessed, created, updated, deleted) along with relevance scores. Markdown content in chat threads is now rendered with syntax highlighting, copy-to-code-block functionality, and animated text highlighting. The interface is fully responsive, featuring a mobile-friendly sidebar drawer for thread management and settings (including dark mode toggling and memory reset). Additionally, theme-aware logos and a GitHub link button have been added to enhance branding and navigation.

examples/mem0-demo/components · high confidence

This change introduces the core server routing layer for self-hosted deployments, adding new endpoints for user authentication (register, login, refresh, profile updates), API key lifecycle management (create, list, revoke), and administrative operations (entity deletion, request log viewing). Users can now create and manage API keys with proper 404 handling for invalid IDs, register the initial admin account with rate limiting, and admins can view request logs and delete entities via the new /api-keys, /auth, /entities, and /requests routes.

server/routers · high confidence

A new CI script (scripts/check-llms-txt-coverage.py) now validates that docs/llms.txt accurately reflects the repository's .mdx pages, reporting missing or stale links and optionally scaffolding placeholders for new pages under an 'Unclassified' section. An ignore list (scripts/llms-txt-ignore.txt) excludes internal snippets, templates, and changelogs from this check. Additionally, a migration utility (scripts/oss-to-platform-migrate.sh) is introduced to help users move their local Qdrant-hosted memories to the hosted platform service, handling authentication, telemetry aliasing, and data export/import.

scripts · high confidence

The TypeScript OSS SDK now supports a wider range of LLM providers, including Anthropic, AWS Bedrock, Azure OpenAI, Google, Groq, Mistral, Ollama, and xAI (Grok), alongside OpenAI-compatible wrappers for DeepSeek, LiteLLM, LM Studio, MiniMax, Sarvam, Together, and vLLM. A new Langchain integration allows using any Langchain-compatible model instance, and a base LLM interface standardizes the provider contract. This expands the SDK's compatibility with various AI services and local inference engines.

mem0-ts/src/oss/src/llms · high confidence

Mem0 now publishes structured skill definitions for AI coding assistants (such as Claude Code, Codex, and Cursor) to help developers work with the platform. The new \skills/\ directory introduces three reference skills—\mem0\ (Python/TypeScript SDKs), \mem0-cli\ (terminal workflows), and \mem0-vercel-ai-sdk\ (Vercel AI provider)—that load SDK knowledge into the assistant's context. It also adds three pipeline skills that execute end-to-end workflows on demand: \mem0-integrate\ (wires Mem0 into an existing repo via a TDD pipeline), \mem0-test-integration\ (verifies the integration), and \mem0-oss-to-platform\ (migrates projects from the OSS SDK to the hosted Platform).

skills · high confidence

The Node.js CLI now includes a suite of new commands to support Agent Mode and the AgentRush platform. Users can bootstrap Agent Mode via \mem0 init --agent\ (unattended signup) and claim accounts via OTP using \mem0 init --email\. The \mem0 identify\ command allows agents to declare their identity, while \mem0 agent-rush\ enables submitting and searching public memories for the AgentRush event. Additional platform management commands include \mem0 config\ (show/get/set), \mem0 entities\ (list/delete), \mem0 events\ (list/status), \mem0 whoami\ (display AGENTRUSH identifier), and \mem0 utils\ (status/import). These commands interact with the v1 API and support structured output for agent consumption.

cli/node/src/commands · high confidence

Added example scripts in the OSS examples directory demonstrating how to use the new Mem0 TypeScript SDK. The basic.ts example shows how to initialize the Memory client with default settings, configure it for local inference using Ollama (with nomic-embed-text and llama3.1:8b), or use cloud providers like OpenAI, covering operations such as adding, updating, searching, and deleting memories. The local-llms.ts example provides an interactive chat interface that integrates Ollama for both embedding and language model generation, allowing users to chat with their stored memories locally.

mem0-ts/src/oss/examples · high confidence

The TypeScript SDK now supports a wider range of embedding providers, including AWS Bedrock, Azure OpenAI, FastEmbed, Google, HuggingFace, LangChain, LM Studio, Ollama, Together AI, and Vertex AI. A new \Embedder\ interface standardizes the \embed\ and \embedBatch\ methods across all providers, ensuring consistent behavior. Most providers are implemented as optional dependencies, loaded lazily to avoid unnecessary package installations. The AWS Bedrock embedder supports both Amazon Titan and Cohere models, with batch size and concurrency limits to handle API constraints. The Ollama embedder automatically pulls models if they are not present locally. The Together AI embedder respects the \TOGETHER\_API\_BASE\ environment variable for custom endpoints. The Vertex AI embedder supports different embedding types for add, update, and search actions, and handles model-specific instance limits.

mem0-ts/src/oss/src/embeddings · high confidence

Added a new example script that integrates the Mem0 memory client with the OpenAI SDK to demonstrate how to store and retrieve user memories for personalized responses. The example shows how to inject stored memories into the prompt context when using OpenAI's responses API with custom tools defined via Zod schemas.

examples/openai-inbuilt-tools · high confidence

Added new Jupyter notebooks and helper modules in the examples directory to demonstrate recent SDK capabilities. The user-profiles notebook shows how to configure and generate structured user profiles from conversation history using a JSON schema, while the mem0-autogen notebook illustrates integrating Mem0 with AutoGen agents. Additionally, a new Mem0Teachability helper class and customer-support-chatbot example demonstrate how agents can learn and retain task-advice pairs and question-answer pairs from prior interactions to improve future responses.

examples/notebooks · high confidence

The \examples/graph-db-demo\ directory now includes Jupyter notebooks demonstrating how to use Mem0 with various graph database backends for memory storage. New examples cover Kuzu (embedded), Memgraph, Neo4j, Amazon Neptune DB (requiring a separate vector store like OpenSearch), and Amazon Neptune Analytics (which handles both graph and vector storage). These notebooks provide configuration templates and usage patterns for integrating these specific graph stores with Mem0's memory features.

examples/graph-db-demo · high confidence

The system now supports a v3-style hybrid search pipeline that combines semantic vector search with BM25 keyword matching and entity-based boosting. This change introduces new utility modules in mem0/utils: entity\_extraction.py uses spaCy to identify proper nouns, quoted text, and noun compounds; lemmatization.py prepares text for BM25 matching while preserving ambiguous -ing forms; scoring.py implements additive scoring that normalizes BM25 scores via query-length-adaptive sigmoids and combines them with semantic and entity signals; spacy\_models.py provides a thread-safe, shared spaCy model loader to avoid redundant disk I/O; factory.py expands LLM and embedder provider support with new provider-specific config classes and improved config conversion logic; gcp\_auth.py centralizes Google Cloud authentication for Vertex AI and GenAI clients; and http.py standardizes httpx client construction with proxy support. Users benefit from more accurate, explainable search results that leverage multiple retrieval signals and better infrastructure for authentication and HTTP configuration.

mem0/utils · high confidence

Added a collection of new example scripts in the examples/misc directory demonstrating various AI agent patterns integrated with Mem0 for persistent memory. These include a voice-enabled diet assistant using Cartesia TTS, a fitness tracker, a healthcare assistant leveraging Google ADK, a movie recommender using Grok 3, a multi-LLM research team with shared knowledge, a personal assistant with image support, a personalized search agent using Tavily, a GitHub research agent with AWS ElastiCache and Neptune, a study buddy with spaced repetition, a vLLM integration example for high-performance inference, and a voice assistant using ElevenLabs.

examples/misc · high confidence

The LLM configuration module has been restructured into a modular system with a shared base configuration and dedicated config classes for each supported provider (Anthropic, AWS Bedrock, Azure OpenAI, DeepSeek, Gemini, LM Studio, MiniMax, Ollama, OpenAI, vLLM, and X.AI). This change introduces provider-specific parameters such as custom base URLs, API keys, and region settings, while standardizing common parameters like temperature, max tokens, and vision support. Users can now configure LLM providers with greater precision and flexibility, including support for reasoning models, proxy settings, and response monitoring callbacks.

mem0/configs/llms · high confidence

The embedding subsystem has been restructured into a modular provider system, introducing dedicated implementations for AWS Bedrock, Azure OpenAI, FastEmbed, Gemini, Hugging Face, LangChain, LM Studio, Ollama, OpenAI, Together, and Vertex AI, all inheriting from a common base class. This change introduces native batch embedding capabilities (embed\_batch) across most providers to improve performance, adds support for local/offline embeddings via FastEmbed, and enables Azure OpenAI authentication via DefaultAzureCredential. Users can now select from a wider range of embedding providers and benefit from optimized batch processing.

mem0/embeddings · high confidence

Added a new example script demonstrating a multi-agent personal learning system using LlamaIndex's AgentWorkflow and Mem0 for shared memory. The example features a TutorAgent and a PracticeAgent that collaborate to teach topics like machine learning, adapting to the student's history and learning style across sessions.

examples/multiagents · high confidence

The TypeScript OSS SDK now includes a reranking capability with four provider implementations: Cohere (using the \cohere-ai\ SDK), ZeroEntropy (using the \zeroentropy\ SDK), a local Cross-Encoder (using \@huggingface/transformers\), and an LLM-based reranker. All providers implement a common \Reranker\ interface that returns documents sorted by relevance score. The Cohere and ZeroEntropy implementations lazy-load their respective optional peer dependencies so that importing the SDK does not require them unless the reranker is actually used. The Cross-Encoder implementation lazy-loads the Hugging Face Transformers library to avoid pulling in ONNX runtime dependencies at startup. The LLM reranker uses a provided LLM instance to score documents via a system prompt. All providers support a \topK\ limit and fall back to the original document order with a score of 0.0 (or 0.5 for the LLM reranker) if the underlying service or model fails.

mem0-ts/src/oss/src/rerankers · high confidence

Added three new scripts to the server to support self-hosted deployments: \seed.sh\ automates the initial setup by creating an admin account, generating an API key, and providing connection details; \reset\_admin\_password.py\ allows administrators to reset user passwords via environment variables; and \prune\_request\_logs.py\ enables the deletion of old request log entries based on a configurable retention period.

server/scripts · high confidence

The TypeScript OSS SDK now supports a wide range of vector storage backends, including Azure AI Search, Azure MySQL, Baidu Mochow, Cassandra, Chroma, Databricks, Elasticsearch, Milvus, and a LangChain wrapper. This addition allows users to persist and query vector memories using their preferred infrastructure, with the LangChain adapter enabling compatibility with existing LangChain vector stores.

_mem0-ts/src/oss/src/vector\stores · high confidence

The TypeScript OSS SDK now implements the v3 memory pipeline, introducing hybrid search capabilities that combine semantic vector search with BM25 keyword matching and entity-based boosting. This update adds a new \BM25\ utility for keyword scoring, an \entity\_extraction\ module that identifies PROPER, QUOTED, TOPIC, and IDENTIFIER entities using NLP or regex, and a \scoring\ system that normalizes and additively combines these signals. Additionally, the SDK includes a \RerankerFactory\ supporting multiple providers (Cohere, LLM, ZeroEntropy, CrossEncoder), a \toCamelCasePreservingIds\ utility for API response formatting, and stricter expiration date validation. Telemetry is now sampled at 10% for hot-path events to reduce volume, and OSS-specific notices are managed via a centralized config system.

mem0-ts/src/oss/src/utils · high confidence

Applied a patch to the tar library (version 7.5.22) to resolve 17 HIGH and CRITICAL security vulnerabilities identified by Vanta and Dependabot across the pnpm workspaces.

mem0-ts/patches · high confidence

The client package has been reorganized into distinct modules (main, project, types, utils) to support the v3 memory API. The \MemoryClient\ now uses Pydantic-based option models (e.g., \AddMemoryOptions\, \SearchMemoryOptions\) for input validation and IDE autocompletion. Identity fields like \user\_id\ and \agent\_id\ must now be passed inside a \filters\ dictionary rather than as top-level arguments, aligning with the v3 API's requirements. The SDK also introduces project-scoped operations via \Project\ and \AsyncProject\ classes, allowing management of custom instructions, categories, and agent-specific settings within an organization. Error handling has been standardized with structured exception classes and improved HTTP error reporting.

mem0/client · high confidence

The TypeScript OSS SDK now supports a broader range of configuration options through updated type definitions. Users can configure AWS Bedrock and Vertex AI embedding providers, as well as the vLLM LLM provider. The schema now includes fields for timeout configuration in LLM clients, URL overrides for Ollama and OpenAI-compatible endpoints, and specific settings for the new reranker component (including Cohere and HuggingFace options). Additionally, the system supports Valkey as a vector store provider, history storage via Supabase, and multimodal message inputs.

mem0-ts/src/oss/src/types · high confidence

The PI Agent plugin now stamps surface identity headers (X-Mem0-Source, X-Application, X-Mem0-Client) on the shared Mem0 client at construction, ensuring that all traffic—including automatic recall, capture, memory tools, and deletions—is attributed to the PI\_AGENT surface rather than appearing as generic SDK traffic. The X-Mem0-Client stack is bounded to 4 entries and 200 characters, preserving the plugin's own entry and dropping whole entries at the character cap. Command results (e.g., /mem0-forget, /mem0-search) are now visible to the user via display:true messages, and search results are relevance-filtered using the configured searchThreshold. Telemetry now uses a persistent anonymous ID, respects the MEM0\_TELEMETRY opt-out, and emits namespaced events (pi.tool.mem0\memory, pi.command.\) with correct source attribution.

integrations/pi-agent-plugin · high confidence

The Python CLI now uses a dedicated backend abstraction layer (in \mem0\_cli/backend\) to communicate with the mem0 Platform API. This introduces a \PlatformBackend\ implementation that handles HTTP requests via \httpx\, automatically tagging requests with source and client version headers, and extracting operational notices from API responses. The base interface defines the core memory operations (add, search, get, list, update, delete) and event commands, ensuring the CLI interacts with the v3 API routes consistently.

_cli/python/src/mem0\cli/backend · high confidence

The repository has been renamed from embedchain to Mem0, with the root README updated to reflect the new product identity, branding, and benchmark results. The project now ships as a polyglot monorepo containing a Python SDK (mem0/), a TypeScript SDK (mem0-ts/), Python and Node CLIs, and a self-hosted server. A new AGENTS.md file establishes development conventions, toolchains, and contribution gates (CLA and accepted-issue requirements) for the repository. The underlying memory algorithm has been upgraded to v3, featuring single-pass additive extraction, entity linking, and multi-signal retrieval, alongside new integration points for agent plugins and Claude Code skills.

(repo-wide) · high confidence

The \mem0/configs\ module has been restructured to introduce a centralized configuration system using Pydantic models. Users can now explicitly configure the vector store, LLM, embedder, and optional reranker via \MemoryConfig\, with Azure-specific settings (API key, endpoint, deployment, headers) isolated in \AzureConfig\. The default API version is set to \v1.1\. Additionally, the module now defines \MemoryType\ enums (semantic, episodic, procedural) and provides updated prompt templates for fact retrieval and memory updates, including stricter instructions to extract facts solely from user or assistant messages respectively.

mem0/configs · high confidence

The TypeScript OSS SDK now includes a dedicated configuration layer with a \ConfigManager\ and a \defaults.ts\ file that establishes sensible out-of-the-box settings. Users benefit from a standardized default setup using OpenAI for embeddings and LLMs, SQLite for history, and an in-memory vector store. The manager intelligently merges user-provided settings with these defaults, handling normalization of snake\_case keys (for Python SDK compatibility), auto-detecting embedding dimensions to avoid mismatches with non-OpenAI embedders, and preventing OpenAI-specific defaults (like baseURL and model) from incorrectly shadowing other providers' configurations.

mem0-ts/src/oss/src/config · high confidence

The Node CLI backend has been rewritten to target the v3 API routes (e.g., /v3/memories/add/), introducing support for new \add\ options such as \agentCustomInstructions\, \customCategories\, and \structuredDataSchema\. The implementation now includes robust error handling with specific \AuthError\, \NotFoundError\, and \APIError\ classes, dynamic URL path encoding, and automatic extraction of \mem0\_notice\ messages from API responses for user surfacing.

cli/node/src/backend · high confidence

The \mem0\ Python SDK now provides a comprehensive set of structured exception classes (e.g., \AuthenticationError\, \RateLimitError\, \ValidationError\) that replace generic API errors. These exceptions include specific error codes, user-friendly suggestions, and debug information, enabling applications to handle errors more precisely and implement targeted recovery logic such as exponential backoff for rate limits or validation feedback for users.

mem0 · high confidence

The embedding configuration module has been restructured to support a single, unified config class that handles initialization for multiple embedding providers. Users can now configure provider-specific settings directly within this class, including base URLs for OpenAI, Ollama, Hugging Face, and LM Studio, Azure OpenAI parameters via AzureConfig, AWS Bedrock credentials and region (with automatic fallback to the AWS\_REGION environment variable), Vertex AI credentials, and HTTP proxy settings. This change centralizes embedding setup logic, allowing users to define all necessary provider details in one place without needing separate configuration structures for each backend.

mem0/configs/embeddings · high confidence

The configuration classes for all supported vector stores (including Azure AI Search, Azure MySQL, Baidu, Cassandra, Chroma, Databricks, Elasticsearch, FAISS, Langchain, Milvus, MongoDB, Neptune, OpenSearch, Oracle, PGVector, Pinecone, Qdrant, Redis, S3 Vectors, Supabase, Turbopuffer, Upstash, Valkey, Vertex AI, and Weaviate) have been rewritten as Pydantic v2 models. This change enforces strict input validation by rejecting unknown fields, standardizes connection and authentication parameter handling, and introduces specific configuration options such as SSL modes for PGVector, hybrid search for Azure AI Search, and cluster mode for Valkey.

_mem0/configs/vector\stores · high confidence

Added Node CLI test suite; Added comprehensive unit tests for the TypeScript MemoryClient; Added test coverage for entity extraction, LLM factory configuration, lemmatization, and scoring utilities; Added test coverage for memory subsystem fixes and OSS notices; Added test coverage for new providers and SQLite migration; Added test coverage for reranker configuration, scoring, and failure handling; Added test directory placeholder; Added test utility for Memory API operations; Added tests for memory prompt configuration logic; Added tests for the Turbopuffer vector store implementation; Added unit tests for LLM provider integrations; Added unit tests for vector store providers; Comprehensive test coverage for embedding providers; Expanded test coverage for Python SDK and server components; Expanded test coverage for TypeScript OSS SDK providers and stores; Initial test suite for the Python mem0 CLI; Integration test suite for the TypeScript SDK client.

This release adds the official Mem0 CLI for both Python and Node.js, providing a command-line interface for managing memory operations. It also introduces new integration plugins for DeepSeek Harness and AWS Strands agents, along with an n8n community node, enabling seamless memory integration across these platforms. Additionally, several example applications (including a Vercel AI SDK chat app and a YouTube assistant Chrome extension) are added to demonstrate usage patterns.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 36 → 42 (+6.2)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 62 → 69 (+7.5)
• Architecture 83 → 68 (-14.7)
• Maturity 62 → 74 (+11.9)
• Readiness 15 → 29 (+13.6)
• Security 42 → 67 (+25.0)
• Accessibility 39 (new)
• Performance 60 (new)

• Change coupling: index.ts ↔ factory.ts (mem0-ts/src/oss/src/index.ts)
• Change coupling: index.ts ↔ tsup.config.ts (mem0-ts/src/oss/src/index.ts)
• Change coupling: mem0.ts ↔ telemetry.ts (mem0-ts/src/client/mem0.ts)
• Change coupling: platform.ts ↔ index.ts (cli/node/src/backend/platform.ts)
• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (mem0-ts/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (poetry.lock)
• Critical CVE: [GHSA redacted] (poetry.lock)
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (mem0/vector_stores/cassandra.py)
• Duplicated block (10 lines × 2) (mem0/vector_stores/databricks.py)
• Duplicated block (10 lines × 2) (mem0/vector_stores/databricks.py)
• Duplicated block (11 lines × 2) (mem0/vector_stores/opensearch.py)
• Duplicated block (11 lines × 2) (tests/memory/test_main.py)
• Duplicated block (12 lines × 4) (cli/python/tests/test_commands.py)
• Duplicated block (13 lines × 2) (mem0/vector_stores/redis.py)
• Duplicated block (16 lines × 2) (tests/vector_stores/test_elasticsearch.py)
• Duplicated block (17 lines × 2) (mem0/memory/main.py)
• Duplicated block (17 lines × 2) (mem0/vector_stores/databricks.py)
• Duplicated block (19 lines × 2) (tests/vector_stores/test_pgvector.py)
• …and 129 more

• AWSBedrockLLM._generate_standard (cognitive 45) (mem0/llms/aws_bedrock.py)
• AWSBedrockLLM._generate_standard (cyclomatic 22) (mem0/llms/aws_bedrock.py)
• AWSBedrockLLM._parse_response (cognitive 29) (mem0/llms/aws_bedrock.py)
• AWSBedrockLLM._parse_response (cyclomatic 20) (mem0/llms/aws_bedrock.py)
• AsyncMemory._add_to_vector_store (cognitive 125) (mem0/memory/main.py)
• AsyncMemory._add_to_vector_store (cyclomatic 65) (mem0/memory/main.py)
• AsyncMemory._compute_entity_boosts_async (cognitive 33) (mem0/memory/main.py)
• AsyncMemory._compute_entity_boosts_async (cyclomatic 18) (mem0/memory/main.py)
• AsyncMemory._get_all_from_vector_store (cognitive 22) (mem0/memory/main.py)
• AsyncMemory._process_metadata_filters (cognitive 36) (mem0/memory/main.py)
• AsyncMemory._process_metadata_filters (cyclomatic 16) (mem0/memory/main.py)
• AsyncMemory._remove_memory_from_entity_store (cognitive 32) (mem0/memory/main.py)
• AsyncMemory._remove_memory_from_entity_store (cyclomatic 20) (mem0/memory/main.py)
• AsyncMemory._search_vector_store (cognitive 40) (mem0/memory/main.py)
• AsyncMemory._search_vector_store (cyclomatic 23) (mem0/memory/main.py)
• AsyncMemory.delete_all (cognitive 19) (mem0/memory/main.py)
• AsyncMemory.search (cognitive 22) (mem0/memory/main.py)
• AsyncMemory.search (cyclomatic 19) (mem0/memory/main.py)
• Banned license: psycopg
• Banned license: psycopg-pool
• …and 1221 more

• 95 commits — 53 feature/other, 42 fixes

• mem0-ts/src — 11 commits
• docs/components — 8 commits
• docs/docs.json — 7 commits
• integrations/mem0-plugin — 6 commits
• integrations/agent-plugin-core — 5 commits
• mem0/vector_stores — 5 commits
• docs/changelog — 4 commits
• docs/cookbooks — 4 commits
• docs/integrations — 4 commits
• docs/platform — 4 commits
• (root) — 3 commits
• integrations/claude-code-plugin — 3 commits
• .github/workflows — 2 commits
• cli/node — 2 commits
• docs/api-reference — 2 commits
• docs/open-source — 2 commits
• docs/templates — 2 commits
• integrations/deepseek-plugin — 2 commits
• integrations/vercel-ai-sdk — 2 commits
• mem0/configs — 2 commits

• fix: Fix broken links: remove duplicate reranking redirect (#6975)
• fix: fix(agent-plugins): match memo prompts and tool descriptions, release 0.3.3 (#7420)
• fix: fix(ci): make the vouch check speak, unblock list updates, widen the docs exemption (#6974)
• fix: fix(cli): surface agent_custom_instructions on add in both CLIs (#6910)
• fix: fix(client): honor page_size in get_all when page is not passed (#6900)
• fix: fix(docs): SEO improvements for page titles, internal links, and URL structure (#7224)
• fix: fix(docs): balance code fences in cookbook_template.mdx (#7054)
• fix: fix(docs): correct rendered titles and remaining SEO links (#7344)
• fix: fix(docs): redirect the eight 404 paths and repair dead wildcard rules (#7053)
• fix: fix(examples): migrate OSS Memory search/get_all calls to v3 filters API (#7300)
• fix: fix(integrations/zapier): address Zapier publishing review (#6985)
• fix: fix(llms/aws_bedrock): iterate Converse content blocks for Anthropic text (#6369)
• fix: fix(llms/aws_bedrock): resolve provider for application inference profile ARNs (#6899)
• fix: fix(llms/vllm): honor VLLM_BASE_URL instead of always using localhost (#6897)
• fix: fix(mem0-plugin): drop unused pytest import breaking make lint on main (#6937)
• fix: fix(mem0-plugin): stop search errors from looking like empty results (#6898)
• fix: fix(memory): escape delimiters when building the session scope key (#6892)
• fix: fix(memory): exclude vector-store-rejected records from ADD results (#7066)
• fix: fix(memory): restore Memory and AsyncMemory context-manager protocol (#7354)
• fix: fix(oss): stop ConfigManager from injecting OpenAI's baseURL and model into other providers (#7350)
• …and 75 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

mem0ai/mem0 was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.