diff --git a/README.md b/README.md index 9a81e74ef..8ec498d55 100644 --- a/README.md +++ b/README.md @@ -48,47 +48,46 @@ | --- | --- | --- | --- | --- | | **LoCoMo** | 71.4 | **92.5** | 7.0K | 0.88s | | **LongMemEval** | 67.8 | **94.4** | 6.8K | 1.09s | -| **BEAM (1M)** | β€” | **64.1** | 6.7K | 1.00s | -| **BEAM (10M)** | β€” | **48.6** | 6.9K | 1.05s | +| **BEAM (1M)** | n/a | **64.1** | 6.7K | 1.00s | +| **BEAM (10M)** | n/a | **48.6** | 6.9K | 1.05s | All benchmarks run on the same production-representative model stack. Single-pass retrieval (one call, no agentic loops) at a top_200 retrieval budget. Scores reflect Mem0's managed platform, which includes proprietary optimizations not available in the open-source SDK; open-source users should expect directionally similar gains but not identical numbers. **What changed:** -- **Single-pass ADD-only extraction** -- one LLM call, no UPDATE/DELETE. Memories accumulate; nothing is overwritten. -- **Agent-generated facts are first-class** -- when an agent confirms an action, that information is now stored with equal weight. -- **Entity linking** -- entities are extracted, embedded, and linked across memories for retrieval boosting. -- **Multi-signal retrieval** -- semantic, BM25 keyword, and entity matching scored in parallel and fused. -- **Temporal Reasoning** -- time-aware retrieval that ranks the right dated instance for queries about current state, past events, and upcoming plans. +- **Single-pass ADD-only extraction**: one LLM call, no UPDATE/DELETE. Memories accumulate; nothing is overwritten. +- **Agent-generated facts are first-class**: when an agent confirms an action, that information is now stored with equal weight. +- **Entity linking**: entities are extracted, embedded, and linked across memories for retrieval boosting. +- **Multi-signal retrieval**: semantic, BM25 keyword, and entity matching scored in parallel and fused. +- **Temporal Reasoning**: time-aware retrieval that ranks the right dated instance for queries about current state, past events, and upcoming plans. See the [migration guide](https://docs.mem0.ai/migration/oss-v2-to-v3) for upgrade instructions. The [evaluation framework](https://github.com/mem0ai/memory-benchmarks) is open-sourced so anyone can reproduce the numbers. ## Research Highlights -- **92.5 on LoCoMo** -- +21 points over the previous algorithm -- **94.4 on LongMemEval** -- +27 points, with 98.2 on assistant memory recall -- **64.1 on BEAM (1M)** -- production-scale memory evaluation at 1M tokens +- **92.5 on LoCoMo**: +21 points over the previous algorithm +- **94.4 on LongMemEval**: +27 points, with 98.2 on assistant memory recall +- **64.1 on BEAM (1M)**: production-scale memory evaluation at 1M tokens - [Read the full paper](https://mem0.ai/research) # Introduction -[Mem0](https://mem0.ai) ("mem-zero") enhances AI assistants and agents with an intelligent memory layer, enabling personalized AI interactions. It remembers user preferences, adapts to individual needs, and continuously learns over timeβ€”ideal for customer support chatbots, AI assistants, and autonomous systems. +[Mem0](https://mem0.ai) ("mem-zero") gives AI assistants and agents persistent memory. It stores facts extracted from conversations, scopes them to a user, agent, or run, and retrieves the relevant ones on the next query. ### Key Features & Use Cases -**Core Capabilities:** -- **Multi-Level Memory**: Seamlessly retains User, Session, and Agent state with adaptive personalization -- **Developer-Friendly**: Intuitive API, cross-platform SDKs, and a fully managed service option +**Core capabilities:** +- Memory scoped to `user_id`, `agent_id`, or `run_id`, with metadata and filters on top +- The same API across the OSS library, self-hosted server, and hosted Platform, plus Python and TypeScript SDKs -**Applications:** -- **AI Assistants**: Consistent, context-rich conversations -- **Customer Support**: Recall past tickets and user history for tailored help -- **Healthcare**: Track patient preferences and history for personalized care -- **Productivity & Gaming**: Adaptive workflows and environments based on user behavior +**Use cases:** +- AI assistants and chatbots that keep context across sessions +- Customer support tools that recall a user's past tickets and preferences +- Coding agents that remember project conventions and prior decisions ([Agent Skills](#agent-skills)) ## πŸš€ Quickstart Guide ### Sign up as an agent -AI agents can mint a working Mem0 API key in under five seconds β€” no email, no dashboard, no OTP. Four commands end-to-end: +AI agents can mint a working Mem0 API key in under five seconds: no email, no dashboard, no OTP. Four commands end-to-end: ```bash # 1. Install @@ -104,15 +103,15 @@ mem0 add "I am using mem0" mem0 search "am I using mem0" ``` -The human owner can claim the account later with `mem0 init --email ` β€” same key, memories preserved. Full guide: [Sign up as an agent](https://docs.mem0.ai/platform/agent-signup). +The human owner can claim the account later with `mem0 init --email ` (same key, memories preserved). Full guide: [Sign up as an agent](https://docs.mem0.ai/platform/agent-signup). | | Library | Self-Hosted Server | Cloud Platform | |---|---------|-------------------|----------------| | **Best for** | Testing, prototyping | Teams running on their own infrastructure | Zero-ops production use | | **Setup** | `pip install mem0ai` | `docker compose up` | Sign up at [app.mem0.ai](https://app.mem0.ai?utm_source=oss&utm_medium=readme) | -| **Dashboard** | -- | [Yes](https://docs.mem0.ai/open-source/setup) | Yes | -| **Auth & API Keys** | -- | Yes | Yes | -| **Advanced Features** | -- | Teasers | All included | +| **Dashboard** | n/a | [Yes](https://docs.mem0.ai/open-source/setup) | Yes | +| **Auth & API Keys** | n/a | Yes | Yes | +| **Advanced Features** | n/a | Teasers | All included | Just testing? Use the library. Building for a team? Self-hosted. Want zero ops? Cloud. @@ -140,7 +139,7 @@ npm install mem0ai > **Note:** Self-hosted auth is on by default. Upgrading from a pre-auth build? Set `ADMIN_API_KEY`, register an admin through the wizard, or `AUTH_DISABLED=true` for local dev only. See [upgrade notes](https://docs.mem0.ai/open-source/setup#upgrade-notes). ```bash -# Recommended: one command β€” start the stack, create an admin, issue the first API key. +# Recommended: one command starts the stack, creates an admin, and issues the first API key. cd server && make bootstrap # Manual: start the stack and finish setup via the browser wizard. @@ -173,7 +172,7 @@ See the [CLI documentation](https://docs.mem0.ai/platform/cli) for the full comm Teach your AI coding assistant (Claude Code, Codex, Cursor, Windsurf, OpenCode, OpenClaw, and any tool that supports the skills standard) how to build with Mem0. Two categories: -**Reference skills β€” always on** (SDK knowledge loaded into the assistant's context): +**Reference skills, always on** (SDK knowledge loaded into the assistant's context): ```bash npx skills add https://github.com/mem0ai/mem0 --skill mem0 @@ -181,7 +180,7 @@ npx skills add https://github.com/mem0ai/mem0 --skill mem0-cli npx skills add https://github.com/mem0ai/mem0 --skill mem0-vercel-ai-sdk ``` -**Pipeline skills β€” run on demand** (execute an end-to-end workflow in an existing repo): +**Pipeline skills, run on demand** (execute an end-to-end workflow in an existing repo): ```bash npx skills add https://github.com/mem0ai/mem0 --skill mem0-integrate @@ -193,11 +192,11 @@ Use `/mem0-integrate` to wire Mem0 into an existing repo via a test-first pipeli ### Basic Usage -Mem0 requires an LLM to function, with `gpt-5-mini` from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/components/llms/overview). +Mem0 requires an LLM to function, with `gpt-5-mini` from OpenAI as the default. It supports a variety of LLMs; see [Supported LLMs](https://docs.mem0.ai/components/llms/overview). -Mem0 uses `text-embedding-3-small` from OpenAI as the default embedding model. For best results with hybrid search (semantic + keyword + entity boosting), we recommend using at least [Qwen 600M](https://huggingface.co/Alibaba-NLP/gte-Qwen2-1.5B-instruct) or a comparable embedding model. See [Supported Embeddings](https://docs.mem0.ai/components/embedders/overview) for configuration details. +The default embedding model is `text-embedding-3-small` from OpenAI. For best results with hybrid search (semantic + keyword + entity boosting), use at least [Qwen 600M](https://huggingface.co/Alibaba-NLP/gte-Qwen2-1.5B-instruct) or a comparable embedding model. See [Supported Embeddings](https://docs.mem0.ai/components/embedders/overview) for configuration details. -First step is to instantiate the memory: +**Self-hosted (`Memory`, `pip install mem0ai`):** ```python from openai import OpenAI @@ -207,36 +206,75 @@ openai_client = OpenAI() memory = Memory() def chat_with_memories(message: str, user_id: str = "default_user") -> str: - # Retrieve relevant memories relevant_memories = memory.search(query=message, filters={"user_id": user_id}, top_k=3) memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories["results"]) - # Generate Assistant response system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}" messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}] response = openai_client.chat.completions.create(model="gpt-5-mini", messages=messages) assistant_response = response.choices[0].message.content - # Create new memories from the conversation messages.append({"role": "assistant", "content": assistant_response}) memory.add(messages, user_id=user_id) return assistant_response -def main(): - print("Chat with AI (type 'exit' to quit)") - while True: - user_input = input("You: ").strip() - if user_input.lower() == 'exit': - print("Goodbye!") - break - print(f"AI: {chat_with_memories(user_input)}") - -if __name__ == "__main__": - main() +print(chat_with_memories("I prefer dark mode and vim keybindings")) +print(chat_with_memories("What editor settings do I like?")) ``` -For detailed integration steps, see the [Quickstart](https://docs.mem0.ai/quickstart) and [API Reference](https://docs.mem0.ai/api-reference). +**Hosted Platform (`MemoryClient`, `MEM0_API_KEY` from [app.mem0.ai](https://app.mem0.ai?utm_source=oss&utm_medium=readme)):** + +```python +import os +from mem0 import MemoryClient + +client = MemoryClient(api_key=os.environ["MEM0_API_KEY"]) + +messages = [{"role": "user", "content": "I prefer dark mode and vim keybindings"}] +client.add(messages, user_id="alice") + +results = client.search("What does Alice prefer?", filters={"user_id": "alice"}, top_k=3) +all_memories = client.get_all(filters={"user_id": "alice"}) +``` + +**TypeScript** (`npm install mem0ai`; see [`mem0-ts/README.md`](https://github.com/mem0ai/mem0/blob/main/mem0-ts/README.md) and the [Node quickstart](https://docs.mem0.ai/open-source/node-quickstart)): + +```typescript +import { MemoryClient, type Message } from "mem0ai"; +import { Memory } from "mem0ai/oss"; + +const messages: Message[] = [{ role: "user", content: "I prefer dark mode and vim keybindings" }]; + +const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! }); +await client.add(messages, { userId: "alice" }); +const results = await client.search("What does Alice prefer?", { filters: { user_id: "alice" } }); + +const memory = new Memory(); +await memory.add(messages, { userId: "alice" }); +const local = await memory.search("What does Alice prefer?", { filters: { user_id: "alice" } }); +``` + +For detailed integration steps, see the [Python Quickstart](https://docs.mem0.ai/open-source/python-quickstart), [Platform Quickstart](https://docs.mem0.ai/platform/quickstart), and [API Reference](https://docs.mem0.ai/api-reference). + +### What the SDK Covers + +| Feature | Docs | +|---|---| +| Memory ops: `add`, `search`, `get`, `get_all`, `update`, `delete`, `delete_all`, `history` | [Python Quickstart](https://docs.mem0.ai/open-source/python-quickstart) | +| Entity scoping (`user_id`, `agent_id`, `run_id`) | [Entity-scoped memory](https://docs.mem0.ai/platform/features/entity-scoped-memory) | +| Metadata and filters | [Metadata filtering](https://docs.mem0.ai/open-source/features/metadata-filtering) | +| Async clients (`AsyncMemory`, `AsyncMemoryClient`) | [Async memory](https://docs.mem0.ai/open-source/features/async-memory) | +| Graph memory | [Graph memory](https://docs.mem0.ai/platform/features/graph-memory) | +| Rerankers | [Reranker-enhanced search](https://docs.mem0.ai/open-source/features/reranker-search) | +| Custom instructions | [Custom instructions](https://docs.mem0.ai/open-source/features/custom-instructions) | +| Multimodal (images, files) | [Multimodal support](https://docs.mem0.ai/open-source/features/multimodal-support) | +| Webhooks (Platform) | [Webhooks](https://docs.mem0.ai/platform/features/webhooks) | +| Memory export (Platform) | [Memory export](https://docs.mem0.ai/platform/features/memory-export) | +| Feedback (Platform) | [Feedback mechanism](https://docs.mem0.ai/platform/features/feedback-mechanism) | +| Memory expiration (Platform) | [Memory expiration](https://docs.mem0.ai/platform/features/memory-expiration) | +| Custom categories (Platform) | [Custom categories](https://docs.mem0.ai/platform/features/custom-categories) | +| Dream, memory synthesis (Platform) | [Dream](https://docs.mem0.ai/platform/features/dream) | ## πŸ”— Integrations & Demos @@ -266,4 +304,4 @@ We now have a paper you can cite: ## βš–οΈ License -Apache 2.0 β€” see the [LICENSE](https://github.com/mem0ai/mem0/blob/main/LICENSE) file for details. +Apache 2.0. See the [LICENSE](https://github.com/mem0ai/mem0/blob/main/LICENSE) file for details. diff --git a/mem0-ts/README.md b/mem0-ts/README.md index 7baae2f96..56f6cca7e 100644 --- a/mem0-ts/README.md +++ b/mem0-ts/README.md @@ -1,59 +1,265 @@ -# Mem0 - The Memory Layer for Your AI Apps +# mem0ai -Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. We offer both cloud and open-source solutions to cater to different needs. +[![npm version](https://img.shields.io/npm/v/mem0ai.svg)](https://www.npmjs.com/package/mem0ai) +[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/mem0ai/mem0/blob/main/LICENSE) -See the complete [OSS Docs](https://docs.mem0.ai/open-source/node-quickstart). -See the complete [Platform API Reference](https://docs.mem0.ai/api-reference). +Mem0 is a memory layer for AI agents: it extracts, stores, and retrieves facts from conversations so an LLM app can stay personalized across sessions instead of re-reading the full chat history on every call. This package gives you two clients: a hosted `MemoryClient` backed by the Mem0 Platform, and a self-hosted `Memory` you run in-process against your own LLM, embedder, and vector store. -## 1. Installation +Docs: [Node quickstart](https://docs.mem0.ai/open-source/node-quickstart) Β· [Platform quickstart](https://docs.mem0.ai/platform/quickstart) Β· [API reference](https://docs.mem0.ai/api-reference) -For the open-source version, you can install the Mem0 package using npm: +## Install ```bash -npm i mem0ai +npm install mem0ai ``` -## 2. API Key Setup +Requires Node 18 or later. -For the cloud offering, sign in to [Mem0 Platform](https://app.mem0.ai/dashboard/api-keys?utm_source=oss&utm_medium=mem0-ts-readme) to obtain your API Key. +## Platform or open source -## 3. Client Features +| | Platform (`MemoryClient`) | Open source (`Memory`) | +| ------------------- | -------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | +| Import | `import { MemoryClient } from "mem0ai"` | `import { Memory } from "mem0ai/oss"` | +| Where memories live | Mem0's hosted API | Your own vector store, in-process | +| Setup | `MEM0_API_KEY` from [app.mem0.ai/dashboard/api-keys](https://app.mem0.ai/dashboard/api-keys) | `OPENAI_API_KEY` (default LLM and embedder), or any [supported provider](#supported-providers) | +| Extraction | Managed, asynchronous, includes graph memory | Runs against the LLM you configure, no graph memory | -### Cloud Offering +## Platform quickstart -The cloud version provides a comprehensive set of features, including: +```ts +import { MemoryClient, type Message } from "mem0ai"; -- **Memory Operations**: Perform CRUD operations on memories. -- **Search Capabilities**: Search for relevant memories using advanced filters. -- **Memory History**: Track changes to memories over time. -- **Error Handling**: Robust error handling for API-related issues. -- **Async/Await Support**: All methods return promises for easy integration. +const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! }); -### Open-Source Offering +const messages: Message[] = [ + { role: "user", content: "I'm a vegetarian and I'm allergic to nuts." }, + { role: "assistant", content: "Got it, I'll remember that." }, +]; -The open-source version includes the following top features: +await client.add(messages, { userId: "alex" }); +``` -- **Memory Management**: Add, update, delete, and retrieve memories. -- **Vector Store Integration**: Supports various vector store providers for efficient memory retrieval. -- **LLM Support**: Integrates with multiple LLM providers for generating responses. -- **Customizable Configuration**: Easily configure memory settings and providers. -- **SQLite Storage**: Use SQLite for memory history management. +`add()` queues extraction and returns `{ eventId, status: "PENDING" }` right away. The extracted memories become searchable a few seconds later: -## 4. Memory Operations +```ts +const found = await client.search("What does Alex eat?", { + filters: { user_id: "alex" }, + topK: 5, +}); -Mem0 provides a simple and customizable interface for performing memory operations. You can create long-term and short-term memories, search for relevant memories, and manage memory history. +const page = await client.getAll({ + filters: { user_id: "alex" }, + pageSize: 20, +}); -## 5. Error Handling +const memory = await client.get(found.results[0].id); +const history = await client.history(memory.id); -The MemoryClient throws errors for any API-related issues. You can catch and handle these errors effectively. +await client.update(memory.id, { + text: "Alex is a vegetarian, allergic to nuts and shellfish.", +}); +await client.delete(memory.id); +await client.deleteAll({ userId: "alex" }); +``` -## 6. Using with async/await +Note that `search` and `getAll` reject top-level `userId`/`agentId`/`appId`/`runId`: those go inside `filters`, and `filters` keys are always snake_case (`user_id`, not `userId`). `add` and `deleteAll` are the opposite: they take entity ids as top-level camelCase options. -All methods of the MemoryClient return promises, allowing for seamless integration with async/await syntax. +### More platform operations -## 7. Testing the Client +```ts +import { MemoryClient, Feedback, WebhookEvent } from "mem0ai"; -To test the MemoryClient in a Node.js environment, you can create a simple script to verify the functionality of memory operations. +const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! }); + +const users = await client.users(); +await client.deleteUsers({ userId: "alex" }); + +await client.batchUpdate([{ memoryId: "mem-1", text: "Updated text" }]); +await client.batchDelete(["mem-1", "mem-2"]); + +const project = await client.getProject({ + fields: ["customInstructions", "customCategories"], +}); +await client.updateProject({ customInstructions: "Always answer in French." }); + +const webhook = await client.createWebhook({ + name: "memory-events", + url: "https://example.com/webhooks/mem0", + eventTypes: [WebhookEvent.MEMORY_ADDED, WebhookEvent.MEMORY_UPDATED], +}); +await client.deleteWebhook({ webhookId: webhook.webhookId! }); + +await client.feedback({ memoryId: "mem-1", feedback: Feedback.POSITIVE }); + +const { id: exportId } = await client.createMemoryExport({ + schema: { name: "string", preferences: "string[]" }, + filters: { user_id: "alex" }, +}); +const exportResult = await client.getMemoryExport({ memoryExportId: exportId }); + +await client.ping(); +``` + +`getProject`/`updateProject` need an API key scoped to a single organization and project. `getWebhooks`/`createWebhook` resolve the project from the client automatically; there is no `projectId` field on the create payload. + +## Open source quickstart + +```ts +import { Memory } from "mem0ai/oss"; + +const memory = new Memory(); + +const messages = [ + { role: "user", content: "I'm a vegetarian and I'm allergic to nuts." }, + { role: "assistant", content: "Got it, I'll remember that." }, +]; + +await memory.add(messages, { userId: "alex" }); + +const found = await memory.search("What does Alex eat?", { + filters: { user_id: "alex" }, +}); +const all = await memory.getAll({ filters: { user_id: "alex" } }); + +await memory.update( + found.results[0].id, + "Alex is a vegetarian, allergic to nuts and shellfish.", +); +const history = await memory.history(found.results[0].id); +await memory.delete(found.results[0].id); +await memory.reset(); +``` + +With no config, `Memory` uses OpenAI `gpt-5-mini` for extraction, OpenAI `text-embedding-3-small` for embeddings, an in-memory (non-persistent) vector store, and a SQLite history log at `memory.db`. `add`, `search`, and `getAll` all require at least one of `userId`/`agentId`/`runId` (top-level for `add`, inside `filters` as `user_id`/`agent_id`/`run_id` for `search` and `getAll`). + +### Chat loop example + +```ts +import OpenAI from "openai"; +import { Memory } from "mem0ai/oss"; + +const openai = new OpenAI(); +const memory = new Memory(); + +async function chatWithMemories( + message: string, + userId = "default_user", +): Promise { + const relevant = await memory.search(message, { + filters: { user_id: userId }, + topK: 3, + }); + const memoriesStr = relevant.results + .map((entry) => `- ${entry.memory}`) + .join("\n"); + + const systemPrompt = `You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n${memoriesStr}`; + const messages = [ + { role: "system" as const, content: systemPrompt }, + { role: "user" as const, content: message }, + ]; + + const response = await openai.chat.completions.create({ + model: "gpt-5-mini", + messages, + }); + const assistantResponse = response.choices[0].message.content ?? ""; + + await memory.add( + [...messages, { role: "assistant" as const, content: assistantResponse }], + { userId }, + ); + + return assistantResponse; +} +``` + +Requires `npm install openai` alongside `mem0ai`. + +### Configuration + +Pass a config object to `new Memory()` to swap the LLM, embedder, vector store, history store, or reranker: + +```ts +import { Memory } from "mem0ai/oss"; + +const memory = new Memory({ + llm: { + provider: "anthropic", + config: { + apiKey: process.env.ANTHROPIC_API_KEY, + model: "claude-sonnet-4-5", + }, + }, + embedder: { + provider: "openai", + config: { + apiKey: process.env.OPENAI_API_KEY, + model: "text-embedding-3-small", + }, + }, + vectorStore: { + provider: "qdrant", + config: { + collectionName: "memories", + host: "localhost", + port: 6333, + dimension: 1536, + }, + }, + reranker: { + provider: "cohere", + config: { + apiKey: process.env.COHERE_API_KEY, + model: "rerank-english-v3.0", + }, + }, + historyDbPath: "memory.db", +}); +``` + +Set `rerank: true` on `search()` to use the configured reranker. There is no `graphStore` option: graph memory is a Platform-only feature, not part of the OSS TypeScript SDK. + +### Supported providers + +Provider SDKs are optional peer dependencies. Install the package for the provider you use (for example `npm install @qdrant/js-client-rest` for Qdrant); the rest stay out of your bundle. + +| Kind | Provider strings | +| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| LLMs | `openai`, `openai_structured`, `anthropic`, `groq`, `mistral`, `google` (`gemini`), `azure_openai`, `ollama`, `lmstudio`, `together`, `deepseek`, `xai`, `sarvam`, `aws_bedrock`, `litellm`, `minimax`, `vllm`, `langchain` | +| Embedders | `openai`, `azure_openai`, `google` (`gemini`), `aws_bedrock`, `vertexai`, `huggingface`, `fastembed`, `ollama`, `lmstudio`, `together`, `langchain` | +| Vector stores | `memory`, `qdrant`, `chroma`, `pgvector`, `pinecone`, `milvus`, `mongodb`, `weaviate`, `redis`, `valkey`, `supabase`, `cassandra`, `elasticsearch`, `opensearch`, `turbopuffer`, `upstash_vector`, `vectorize`, `s3_vectors`, `baidu`, `databricks`, `oracledb`, `azure-ai-search`, `azure_mysql`, `neptune-analytics`, `vertex_ai_vector_search`, `langchain` | +| Rerankers | `cohere`, `zero_entropy`, `llm_reranker`, `sentence_transformer`, `huggingface` | + +## Filters + +`filters` selects which memories a search, `getAll`, or export applies to. Keys are snake_case. A flat object ANDs its keys together; wrap conditions in `AND`/`OR` for explicit grouping: + +```ts +{ filters: { user_id: "alex", categories: { contains: "food" } } } + +{ + filters: { + OR: [{ agent_id: "assistant-1" }, { run_id: "session-42" }], + }, +} +``` + +Comparison operators: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`, `contains`, `icontains`. The open-source `Memory` also supports `nin`; the Platform client does not. See [Memory filters](https://docs.mem0.ai/platform/features/v2-memory-filters) for the full grammar. + +## CLI and integrations + +```bash +npm install -g @mem0/cli +``` + +The CLI wraps both clients from your shell. See [CLI reference](https://docs.mem0.ai/platform/cli). + +Using the Vercel AI SDK? See the [Vercel AI SDK integration](https://docs.mem0.ai/integrations/vercel-ai-sdk). + +## License + +Apache-2.0 ## Getting Help