Fix broken link to removed expiration-date page

Generated-By: mintlify-agent

cookbooks/helper/mem0_teachability.py

@@ -56,7 +56,7 @@ class Mem0Teachability(AgentCapability):
 
     def process_last_received_message(self, text: Union[Dict, str]):
         expanded_text = text
-        if self.memory.get_all(agent_id=self.agent_id):
+        if self.memory.get_all(filters={"agent_id": self.agent_id}):
             expanded_text = self._consider_memo_retrieval(text)
         self._consider_memo_storage(text)
         return expanded_text
@@ -139,7 +139,7 @@ class Mem0Teachability(AgentCapability):
         return comment + self._concatenate_memo_texts(memo_list)
 
     def _retrieve_relevant_memos(self, input_text: str) -> list:
-        search_results = self.memory.search(input_text, agent_id=self.agent_id, limit=self.max_num_retrievals)
+        search_results = self.memory.search(input_text, filters={"agent_id": self.agent_id}, top_k=self.max_num_retrievals)
         memo_list = [result["memory"] for result in search_results if result["score"] <= self.recall_threshold]
 
         if self.verbosity >= 1 and not memo_list:

docs/api-reference/memory/get-memories.mdx

@@ -53,47 +53,3 @@ memories = client.get_all(
 
 </CodeGroup>
 
-## Graph Memory
-
-To retrieve graph memory relationships between entities, pass `output_format="v1.1"` in your request. This will return memories with entity and relationship information from the knowledge graph.
-
-<CodeGroup>
-```python Code
-memories = client.get_all(
-    filters={
-        "user_id": "alex"
-    }
-)
-```
-
-```python Output
-{
-    "results": [
-        {
-            "id": "f4cbdb08-7062-4f3e-8eb2-9f5c80dfe64c",
-            "memory": "Alex is planning a trip to San Francisco",
-            "entities": [
-                {
-                    "id": "entity-1",
-                    "name": "Alex",
-                    "type": "person"
-                },
-                {
-                    "id": "entity-2",
-                    "name": "San Francisco",
-                    "type": "location"
-                }
-            ],
-            "relations": [
-                {
-                    "source": "entity-1",
-                    "target": "entity-2",
-                    "relationship": "traveling_to"
-                }
-            ]
-        }
-    ]
-}
-```
-
-</CodeGroup>

docs/changelog/highlights.mdx

@@ -6,7 +6,7 @@ mode: "wide"
 
 <Update label="2026-04-14" description="Mem0 SDK v2.0.0 / v3.0.0">
 
-**New Memory Algorithm — State-of-the-Art Accuracy at 90% Lower Cost**
+**New Memory Algorithm — State-of-the-Art Accuracy at ~3-4x Lower Cost**
 
 Ground-up rewrite of the memory pipeline with 20+ point benchmark improvements:
 
@@ -15,7 +15,7 @@ Ground-up rewrite of the memory pipeline with 20+ point benchmark improvements:
 - **BEAM (1M tokens):** **64.1** — production-scale memory evaluation
 - **Agent memories are first-class** — Previous algorithm: 46% on assistant recall. New: **100%**
 - **Temporal reasoning works** — "Where did I live before SF?" Previous: 51%. New: **93%**
-- **90% fewer tokens** — Under 7K tokens per retrieval vs 25K+ for full-context approaches
+- **~3-4x fewer tokens** — Under 7K tokens per retrieval vs 25K+ for full-context approaches
 - **ADD-only extraction** — Memories accumulate; nothing is overwritten or deleted
 - **Hybrid retrieval** — Semantic + BM25 keyword + entity boost, scored in parallel
 - **Entity linking** — Entities extracted, embedded, and linked across memories

docs/changelog/platform.mdx

@@ -4,6 +4,13 @@ description: "Release notes for the Mem0 hosted platform — backend, dashboard,
 mode: "wide"
 ---
 
+<Update label="2026-04-16" description="">
+
+**Improvements:**
+- **UI:** Removed Graph Memory tab, page, and all references from dashboard, sidebar, project settings, playground, and billing
+
+</Update>
+
 <Update label="2025-07-23" description="">
 
 **Bug Fixes:**

docs/cookbooks/companions/travel-assistant.mdx

@@ -158,7 +158,7 @@ class PersonalTravelAssistant:
         return [m['memory'] for m in memories.get('results', [])]
 
     def search_memories(self, query, user_id):
-        memories = self.memory.search(query, user_id=user_id)
+        memories = self.memory.search(query, filters={"user_id": user_id})
         return [m['memory'] for m in memories.get('results', [])]
 
 # Usage example

docs/cookbooks/essentials/building-ai-companion.mdx

@@ -354,10 +354,10 @@ Exclude:
 ```
   </Tab>
   <Tab title="Open Source">
-Tell Mem0 what matters by including `custom_fact_extraction_prompt` in the config dict:
+Tell Mem0 what matters by including `custom_instructions` in the config dict:
 
 ```python
-MEMORY_CONFIG["custom_fact_extraction_prompt"] = """
+MEMORY_CONFIG["custom_instructions"] = """
 Extract from running coach conversations:
 - Training goals and race targets
 - Physical constraints or injuries
@@ -375,7 +375,7 @@ Return JSON with key "facts" as a list of strings (use [] if nothing to store).
 memory = Memory.from_config(MEMORY_CONFIG)
 ```
 
-<Note>`custom_fact_extraction_prompt` is a top-level key in the config dictionary passed to `Memory.from_config()`. Make sure it's set before creating the Memory instance — not after.</Note>
+<Note>`custom_instructions` is a top-level key in the config dictionary passed to `Memory.from_config()`. Make sure it's set before creating the Memory instance — not after.</Note>
   </Tab>
 </Tabs>
 
@@ -520,7 +520,7 @@ memory.add(
 # "hey" → don't store
 # "cool thanks" → don't store
 
-# Or rely on custom_fact_extraction_prompt to filter automatically
+# Or rely on custom_instructions to filter automatically
 ```
   </Tab>
 </Tabs>
@@ -545,11 +545,11 @@ expiration = (datetime.now() + timedelta(days=14)).strftime("%Y-%m-%d")
 mem0_client.add(
     [{"role": "user", "content": "Rolled my left ankle, needs rest"}],
     user_id="max",
-    expiration_date=expiration
+    metadata={"memory_bucket": "constraints", "expires_on": expiration}
 )
 ```
 
-In 14 days, this memory disappears automatically. Ray stops asking about the ankle.
+Store `expires_on` in metadata and periodically clean up expired memories. Ray stops asking about the ankle once it's removed.
   </Tab>
   <Tab title="Open Source">
 ```python
@@ -627,7 +627,7 @@ MEMORY_CONFIG = {
             "ollama_base_url": "http://localhost:11434",
         },
     },
-    "custom_fact_extraction_prompt": """
+    "custom_instructions": """
     Extract: goals, constraints, preferences, progress
     Exclude: greetings, filler, casual chat
     Return JSON with key "facts" as a list of strings.
@@ -684,8 +684,7 @@ expiration = (datetime.now() + timedelta(days=14)).strftime("%Y-%m-%d")
 mem0_client.add(
     [{"role": "user", "content": "Rolled ankle, need light workouts"}],
     user_id="max",
-    categories=["constraints"],
-    expiration_date=expiration
+    metadata={"memory_bucket": "constraints", "expires_on": expiration}
 )
 ```
   </Tab>

docs/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph.mdx

@@ -1,361 +0,0 @@
----
-title: Choose Vector vs Graph Memory
-description: "Blend vector search with graph relationships to answer multi-hop questions."
----
-
-
-Most AI agents use vector stores for RAG operations - they work great for semantic search and retrieving relevant context. But there's a gap when queries require understanding connections between entities.
-
-Mem0 brings graph memory into the picture to fill this gap. In this cookbook, we'll create a company knowledge base with Mem0, using both vector and graph stores. You'll learn when each one helps along the way.
-
----
-
-## Vector and Graph Stores
-
-When you add a memory to Mem0, it goes into a **vector store** by default. Vector stores are excellent at semantic search - finding memories that match the meaning of your query.
-
-**Graph stores** work differently. They extract **entities** (people, projects, teams) and **relationships between them** (works_with, reports_to, member_of). This lets you answer questions that need connecting information across multiple memories.
-
-We will go through examples in this cookbook while building a company's knowledge base along the way.
-
----
-
-## Starting Simple
-
-Since we're building a company knowledge base, let's add some employee information:
-
-```python
-from mem0 import MemoryClient
-
-client = MemoryClient(api_key="your-api-key")
-# Add employee info
-client.add("Emma is a software engineer in Seattle", user_id="company_kb")
-client.add("David is a product manager in Austin", user_id="company_kb")
-
-```
-
-Now let's search for Emma's role:
-
-```python
-results = client.search("What does Emma do?", filters={"user_id": "company_kb"})
-print(results['results'][0]['memory'])
-
-```
-
-**Output:**
-
-```
-Emma is a software engineer in Seattle
-
-```
-
-<Info>
-**Expected output:** Vector search returned Emma's role instantly. When queries ask for facts directly stored in one memory, vector semantic search is perfect—fast and accurate.
-</Info>
-
-This works perfectly. Vector search found the memory that semantically matches "What does Emma do?" and returned Emma's role.
-
----
-
-## Adding Team Structure
-
-Let's add some information about how the team works together:
-
-```python
-client.add("Emma works with David on the mobile app redesign", user_id="company_kb")
-client.add("David reports to Rachel, who manages the design team", user_id="company_kb")
-
-```
-
-Now we have two pieces of information stored:
-
-1. Emma works with David
-2. David reports to Rachel
-
-Let's try asking something that needs both pieces:
-
-```python
-results = client.search(
-    "Who is Emma's teammate's manager?",
-    filters={"user_id": "company_kb"}
-)
-
-for r in results['results']:
-    print(r['memory'])
-
-```
-
-**Output:**
-
-```
-Emma works with David on the mobile app redesign
-David reports to Rachel, who manages the design team
-
-```
-
-Vector search returned both memories, but it didn't connect them. You'd need to manually figure out:
-
-- Emma's teammate is David (from memory 1)
-- David's manager is Rachel (from memory 2)
-- So the answer is Rachel
-
-<Warning>
-Vector search can't traverse relationships. It returns relevant memories, but you must connect the dots manually. For "Who is Emma's teammate's manager?", vector search gives you the pieces—not the answer. This breaks down as queries get more complex (3+ hops).
-</Warning>
-
----
-
-## Enter Graph Memory
-
-Let's add the same information with graph memory enabled:
-
-```python
-client.add(
-    "Emma works with David on the mobile app redesign",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-client.add(
-    "David reports to Rachel, who manages the design team",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-```
-
-When you set `enable_graph=True`, Mem0 extracts entities and relationships:
-
-- `emma --[works_with]--> david`
-- `david --[reports_to]--> rachel`
-- `rachel --[manages]--> design_team`
-
-Now the same query works differently:
-
-```python
-results = client.search(
-    "Who is Emma's teammate's manager?",
-    filters={"user_id": "company_kb"},
-    enable_graph=True
-)
-
-print(results['results'][0]['memory'])
-print("\\nRelationships found:")
-for rel in results.get('relations', []):
-    print(f"  {rel['source']}, {rel['target']} ({rel['relationship']})")
-
-```
-
-**Output:**
-
-```
-David reports to Rachel, who manages the design team
-
-Relationships found:
-  emma, david (works_with)
-  david, rachel (reports_to)
-
-```
-
-<Info>
-**Expected behavior:** Graph memory returns the direct answer—"David reports to Rachel"—plus the relationship chain that got there. No manual connecting needed. The graph traversed: Emma → works_with → David → reports_to → Rachel.
-</Info>
-
-Graph memory traversed the relationships automatically: Emma works with David, David reports to Rachel, so Rachel is the answer.
-
----
-
-## How It Connects
-
-Here's what the graph looks like behind the scenes:
-
-```mermaid
-graph LR
-    Emma[Emma] -->|works_with| David[David]
-    David -->|reports_to| Rachel[Rachel]
-    Rachel -->|manages| DesignTeam[Design Team]
-    David -->|works_on| MobileApp[Mobile App]
-    Emma -->|works_on| MobileApp
-
-```
-
-Graph memory lets you discover relations and memories which are tricky to do with direct vector stores.
-
-Vector search would need the exact words in your query to match. Graph memory follows the connections.
-
----
-
-## When to Use Each
-
-Use **vector store** (default) when:
-
-- Searching documents by semantic similarity
-- Looking up facts that don't need relationships
-- Building FAQs or knowledge bases where each item stands alone
-
-Use **graph memory** when:
-
-- Tracking organizational hierarchies (who reports to whom)
-- Understanding project teams (who collaborates with whom)
-- Building CRMs (which contacts connect to which companies)
-- Product recommendations (what items are bought together)
-
-For our company knowledge base, we'll use both:
-
-- Vector for individual facts: "Emma specializes in React"
-- Graph for relationships: "Emma works with David"
-
----
-
-## Putting It Together
-
-Let's build a small company knowledge base with both approaches:
-
-```python
-# Facts about individuals - vector store is fine
-client.add("Emma specializes in React and TypeScript", user_id="company_kb")
-client.add("David has 5 years of product management experience", user_id="company_kb")
-
-# Relationships - use graph memory
-client.add(
-    "Emma and David work together on the mobile app",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-client.add(
-    "David reports to Rachel",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-client.add(
-    "Rachel runs weekly team syncs every Tuesday",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-```
-
-Now we can ask different types of questions:
-
-```python
-# Direct fact - vector search
-results = client.search("What are Emma's skills?", filters={"user_id": "company_kb"})
-print(results['results'][0]['memory'])
-
-```
-
-**Output:**
-
-```
-Emma specializes in React and TypeScript
-
-```
-
-```python
-# Multi-hop relationship - graph search
-results = client.search(
-    "What meetings does Emma's project manager's boss run?",
-    filters={"user_id": "company_kb"},
-    enable_graph=True
-)
-print(results['results'][0]['memory'])
-
-```
-
-**Output:**
-
-```
-Rachel runs weekly team syncs every Tuesday
-
-```
-
-Graph memory connected: Emma works with David, David reports to Rachel, Rachel runs team syncs.
-
-<Tip>
-Enable graph memory when your queries need multi-hop traversal: org charts (who reports to whom), project teams (who collaborates), CRMs (which contacts connect to companies). For single-fact lookups, stick with vector search—it's faster and cheaper.
-</Tip>
-
----
-
-## The Tradeoff
-
-Graph memory adds processing time and cost. When you call `client.add()` with `enable_graph=True`, Mem0 makes extra LLM calls to extract entities and relationships.
-
-<Note>
-**Cost consideration:** Graph memory extraction adds ~2-3 extra LLM calls per `add()` operation to identify entities and relationships. Use it selectively—enable graph for organizational structure and long-term relationships, skip it for temporary notes and simple facts.
-</Note>
-
-Use graph memory when the relationship traversal adds real value. For most use cases, vector search is sufficient and faster.
-
-```python
-# Long-term organizational structure - worth using graph
-client.add(
-    "Emma mentors two junior engineers on the frontend team",
-    user_id="company_kb",
-    enable_graph=True
-)
-
-# Temporary notes - skip graph, not worth the cost
-client.add(
-    "Emma is out sick today",
-    user_id="company_kb",
-    run_id="daily_notes"
-)
-
-```
-
----
-
-## Enabling Graph Memory
-
-You can enable graph memory in two ways:
-
-**Per-call** (recommended to start):
-
-```python
-client.add("Emma works with David", user_id="company_kb", enable_graph=True)
-client.search("team structure", filters={"user_id": "company_kb"}, enable_graph=True)
-
-```
-
-**Project-wide** (if most of your data has relationships):
-
-```python
-client.project.update(enable_graph=True)
-
-# Now every add uses graph automatically
-client.add("Emma mentors Jordan", user_id="company_kb")
-
-```
-
----
-
-## What You Built
-
-A hybrid company knowledge base that combines both architectures:
-
-- **Vector search** - Fast semantic lookups for individual facts (Emma's skills, David's experience)
-- **Graph memory** - Multi-hop relationship traversal (Emma's teammate's manager, project hierarchies)
-- **Selective enablement** - Graph only for long-term organizational structure, vector for everything else
-- **Cost optimization** - Skip graph extraction for temporary notes and simple facts
-
-This pattern scales from 10-person startups to enterprise org charts with thousands of employees.
-
----
-
-## Summary
-
-Vector stores handle most memory operations efficiently—semantic search works great for finding relevant information. Add graph memory when your queries need to understand how entities connect across multiple hops.
-
-The key is knowing which tool fits your query pattern: direct questions work with vectors, multi-hop relationship queries need graphs.
-
-<CardGroup cols={2}>
-  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
-    Scope memories across users, agents, apps, and sessions to balance personalization and reuse.
-  </Card>
-  <Card title="Export Everything Safely" icon="download" href="/cookbooks/essentials/exporting-memories">
-    Learn how to migrate or audit stored memories with structured exports.
-  </Card>
-</CardGroup>

docs/cookbooks/essentials/controlling-memory-ingestion.mdx

@@ -513,11 +513,6 @@ These controls prevent retrieval failures and ensure your AI assistant works wit
 
 Start with conservative filters (only store confirmed facts) and iterate based on your application's needs. Combine custom instructions with confidence thresholds for the most reliable memory ingestion pipeline.
 
-<CardGroup cols={2}>
-  <Card title="Expire Short-Term Data" icon="timer" href="/cookbooks/essentials/memory-expiration-short-and-long-term">
-    Automatically clean up session context before it clutters retrieval.
-  </Card>
-  <Card title="Choose Your Memory Architecture" icon="sitemap" href="/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph">
-    Learn when to layer graph memory alongside vectors for multi-hop queries.
-  </Card>
-</CardGroup>
+<Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
+  Learn core memory patterns including temporary vs permanent data handling.
+</Card>

docs/cookbooks/essentials/exporting-memories.mdx

@@ -280,8 +280,8 @@ This covers data portability, GDPR compliance, system migrations, and manual rev
 Use **`get_all()`** for bulk retrieval, **`search()`** for specific questions, and **`create_memory_export()`** for structured data exports with custom schemas. Remember exports expire after 7 days—download them locally for long-term archives.
 
 <CardGroup cols={2}>
-  <Card title="Expire Short-Term Data" icon="timer" href="/cookbooks/essentials/memory-expiration-short-and-long-term">
-    Keep exports lean by clearing session context before you archive it.
+  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
+    Learn core memory patterns including temporary vs permanent data handling.
   </Card>
   <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
     Ensure only verified insights make it into your export pipeline.

docs/cookbooks/essentials/memory-expiration-short-and-long-term.mdx

@@ -1,277 +0,0 @@
----
-title: Set Memory Expiration
-description: "Define short-term versus long-term retention so the store stays fresh."
----
-
-
-While building memory systems, we realized their size grows fast. Session notes, temporary context, chat history - everything starts accumulating and bogging down the system. This pollutes search results and increase storage costs. Not every memory needs to persist forever.
-
-In this cookbook, we'll go through how to use short-term vs long-term memories and see where it's best to use them.
-
----
-
-## Overview
-
-By default, Mem0 memories persist forever. This works for user preferences and core facts, but temporary data should expire automatically.
-
-In this tutorial, we will:
-
-- Understand default (permanent) memory behavior
-- Add expiration dates for temporary memories
-- Decide what should be temporary vs permanent
-
----
-
-## Setup
-
-```python
-from mem0 import MemoryClient
-from datetime import datetime, timedelta
-
-client = MemoryClient(api_key="your-api-key")
-```
-
-<Note>
-Import `datetime` and `timedelta` to calculate expiration dates. Without these imports, you'll need to manually format ISO timestamps—error-prone and harder to read.
-</Note>
-
----
-
-## Default Behavior: Everything Persists
-
-By default, all memories persist forever:
-
-```python
-# Store user preference
-client.add("User prefers dark mode", user_id="sarah")
-
-# Store session context
-client.add("Currently browsing electronics category", user_id="sarah")
-
-# 6 months later - both still exist
-results = client.get_all(filters={"user_id": "sarah"})
-print(f"Total memories: {len(results['results'])}")
-
-```
-
-**Output:**
-
-```
-Total memories: 2
-
-```
-
-Both the preference and session context persist. The preference is useful, but the 6-month-old session context is not.
-
----
-
-## The Problem: Memory Bloat
-
-Without expiration, memories accumulate forever. Session notes from weeks ago mix with current preferences. Storage grows, search results get polluted with irrelevant old context, and retrieval quality degrades.
-
-<Warning>
-Memory bloat degrades search quality. When "User prefers dark mode" competes with "Currently browsing electronics" from 6 months ago, semantic search returns stale session data instead of actual preferences. Old memories pollute retrieval.
-</Warning>
-
----
-
-## Short-Term Memories: Adding Expiration
-
-Set `expiration_date` to make memories temporary:
-
-```python
-from datetime import datetime, timedelta
-
-# Session context - expires in 7 days
-expires_at = (datetime.now() + timedelta(days=7)).isoformat()
-
-client.add(
-    "Currently browsing electronics category",
-    user_id="sarah",
-    expiration_date=expires_at
-)
-
-# User preference - no expiration, persists forever
-client.add(
-    "User prefers dark mode",
-    user_id="sarah"
-)
-
-```
-
-<Info icon="check">
-**Expected behavior:** After 7 days, the session context automatically disappears—no cron jobs, no manual cleanup. The preference persists forever. Mem0 handles expiration transparently.
-</Info>
-
-Memories with `expiration_date` are automatically removed after expiring. No cleanup job needed - Mem0 handles it.
-
-<Tip>
-Start conservative with short expiration windows (7 days), then extend them based on usage patterns. It's easier to increase retention than to clean up over-retained stale data. Monitor search quality to find the right balance.
-</Tip>
-
----
-
-## When to Use Each
-
-### Permanent Memories (no expiration_date):
-
-**Use for:**
-
-- User preferences and settings
-- Account information
-- Important facts and milestones
-- Historical data that matters long-term
-
-```python
-client.add("User prefers email notifications", user_id="sarah")
-client.add("User's birthday is March 15th", user_id="sarah")
-client.add("User completed onboarding on Jan 5th", user_id="sarah")
-
-```
-
-### Temporary Memories (with expiration_date):
-
-**Use for:**
-
-- Session context (current page, browsing history)
-- Temporary reminders
-- Recent chat history
-- Cached data
-
-```python
-expires_7d = (datetime.now() + timedelta(days=7)).isoformat()
-
-client.add(
-    "Currently viewing product ABC123",
-    user_id="sarah",
-    expiration_date=expires_7d
-)
-
-client.add(
-    "Asked about return policy",
-    user_id="sarah",
-    expiration_date=expires_7d
-)
-
-```
-
----
-
-## Setting Different Expiration Periods
-
-Different data needs different lifetimes:
-
-```python
-# Session context - 7 days
-expires_7d = (datetime.now() + timedelta(days=7)).isoformat()
-client.add("Browsing electronics", user_id="sarah", expiration_date=expires_7d)
-
-# Recent chat - 30 days
-expires_30d = (datetime.now() + timedelta(days=30)).isoformat()
-client.add("User asked about warranty", user_id="sarah", expiration_date=expires_30d)
-
-# Important preference - no expiration
-client.add("User prefers dark mode", user_id="sarah")
-
-```
-
----
-
-## Using Metadata to Track Memory Types
-
-Tag memories to make filtering easier:
-
-```python
-expires_7d = (datetime.now() + timedelta(days=7)).isoformat()
-
-# Tag session context
-client.add(
-    "Browsing electronics",
-    user_id="sarah",
-    expiration_date=expires_7d,
-    metadata={"type": "session"}
-)
-
-# Tag preference
-client.add(
-    "User prefers dark mode",
-    user_id="sarah",
-    metadata={"type": "preference"}
-)
-
-# Query only preferences
-preferences = client.get_all(
-    filters={
-        "AND": [
-            {"user_id": "sarah"},
-            {"metadata": {"type": "preference"}}
-        ]
-    }
-)
-
-```
-
----
-
-## Checking Expiration Status
-
-See which memories will expire and when:
-
-```python
-results = client.get_all(filters={"user_id": "sarah"})
-
-for memory in results['results']:
-    exp_date = memory.get('expiration_date')
-
-    if exp_date:
-        print(f"Temporary: {memory['memory']}")
-        print(f"  Expires: {exp_date}\\n")
-    else:
-        print(f"Permanent: {memory['memory']}\\n")
-
-```
-
-**Output:**
-
-```
-Temporary: Browsing electronics
-  Expires: 2025-11-01T10:30:00Z
-
-Temporary: Viewed MacBook Pro and Dell XPS
-  Expires: 2025-11-01T10:30:00Z
-
-Permanent: User prefers dark mode
-
-Permanent: User prefers email notifications
-
-```
-
----
-
-## What You Built
-
-A self-cleaning memory system with automatic retention policies:
-
-- **Automatic expiration** - Memories self-destruct after defined periods, no cron jobs needed
-- **Tiered retention** - 7-day session context, 30-day chat history, permanent preferences
-- **Metadata tagging** - Classify memories by type (session, preference, chat) for filtered retrieval
-- **Expiration tracking** - Check which memories will expire and when using `get_all()`
-
-This pattern keeps storage costs low and search quality high as your memory store scales.
-
----
-
-## Summary
-
-Memory expiration keeps storage clean and search results relevant. Use **`expiration_date`** for temporary data (session context, recent chats), skip it for permanent facts (preferences, account info). Mem0 handles cleanup automatically—no background jobs required.
-
-Start by identifying what's temporary versus permanent, then set conservative expiration windows and adjust based on retrieval quality.
-
-<CardGroup cols={2}>
-  <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
-    Pair expirations with ingestion rules so only trusted context persists.
-  </Card>
-  <Card title="Export Memories Safely" icon="download" href="/cookbooks/essentials/exporting-memories">
-    Build compliant archives once your retention windows are dialed in.
-  </Card>
-</CardGroup>

docs/cookbooks/integrations/healthcare-google-adk.mdx

@@ -77,7 +77,7 @@ def retrieve_patient_info(query: str) -> dict:
     results = mem0_client.search(
         query,
         user_id=USER_ID,
-        limit=5,
+        top_k=5,
         threshold=0.7  # Higher threshold for more relevant results
     )
 

docs/cookbooks/integrations/openai-tool-calls.mdx

@@ -28,13 +28,10 @@ Get your Mem0 API key from the <a href="https://app.mem0.ai/dashboard/api-keys"
 ### Configuration
 
 ```javascript
-const mem0Config = {
-    apiKey: process.env.MEM0_API_KEY,
-    user_id: "sample-user",
-};
+const USER_ID = "sample-user";
 
 const openAIClient = new OpenAI();
-const mem0Client = new MemoryClient(mem0Config);
+const mem0Client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });
 ```
 
 ## Adding Memories
@@ -43,14 +40,14 @@ Store user preferences, past interactions, or any relevant information:
 <CodeGroup>
 ```javascript JavaScript
 async function addUserPreferences() {
-    const mem0Client = new MemoryClient(mem0Config);
+    const mem0Client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });
     
     const userPreferences = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most.";
     
     await mem0Client.add([{
         role: "user",
         content: userPreferences,
-    }], mem0Config);
+    }], { userId: "sample-user" });
 }
 
 await addUserPreferences();
@@ -91,7 +88,7 @@ await addUserPreferences();
 Search for relevant memories based on the current user input:
 
 ```javascript
-const relevantMemories = await mem0Client.search(userInput, mem0Config);
+const relevantMemories = await mem0Client.search(userInput, { userId: USER_ID });
 ```
 
 ## Structured Responses with Zod
@@ -152,10 +149,7 @@ import dotenv from 'dotenv';
 
 dotenv.config();
 
-const mem0Config = {
-    apiKey: process.env.MEM0_API_KEY,
-    user_id: "sample-user",
-};
+const USER_ID = "sample-user";
 
 async function run() {
     // Responses without memories
@@ -185,7 +179,7 @@ const Cars = z.object({
 
 async function main(memory = false) {
   const openAIClient = new OpenAI();
-  const mem0Client = new MemoryClient(mem0Config);
+  const mem0Client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });
 
   const input = "Suggest me some cars that I can buy today.";
 
@@ -195,12 +189,12 @@ async function main(memory = false) {
   await mem0Client.add([{
     role: "user",
     content: input,
-  }], mem0Config);
+  }], { userId: USER_ID });
 
   // Search for relevant memories
   let relevantMemories = []
   if (memory) {
-    relevantMemories = await mem0Client.search(input, mem0Config);
+    relevantMemories = await mem0Client.search(input, { userId: USER_ID });
   }
 
   const response = await openAIClient.responses.create({
@@ -213,14 +207,14 @@ async function main(memory = false) {
 }
 
 async function addSampleMemories() {
-  const mem0Client = new MemoryClient(mem0Config);
+  const mem0Client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });
 
   const myInterests = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most.";
   
   await mem0Client.add([{
     role: "user",
     content: myInterests,
-  }], mem0Config);
+  }], { userId: USER_ID });
 }
 
 const getMemoryString = (memories) => {

docs/cookbooks/overview.mdx

@@ -37,13 +37,6 @@ Here are some examples of how Mem0 can be integrated into various applications:
   >
     Filter speculation and low-confidence data.
   </Card>
-  <Card
-    title="Set Memory Expiration"
-    icon="timer"
-    href="/cookbooks/essentials/memory-expiration-short-and-long-term"
-  >
-    Short-term vs long-term retention strategies.
-  </Card>
 </CardGroup>
 
 ## Companion Playbooks

docs/core-concepts/memory-operations/delete.mdx

@@ -216,7 +216,7 @@ memory.delete_all(user_id="alice")
 ## Put it into practice
 
 - Review the <Link href="/api-reference/memory/delete-memory">Delete Memory API reference</Link>, plus <Link href="/api-reference/memory/batch-delete">Batch Delete</Link> and <Link href="/api-reference/memory/delete-memories">Filtered Delete</Link>.
-- Pair deletes with <Link href="/platform/features/expiration-date">Expiration Policies</Link> to automate retention.
+- Pair deletes with <Link href="/platform/features/entity-scoped-memory">Entity-Scoped Memory</Link> to manage retention per user, agent, or session.
 
 ## See it live
 
@@ -233,9 +233,9 @@ memory.delete_all(user_id="alice")
     href="/core-concepts/memory-operations/add"
   />
   <Card
-    title="Enable Expiration Policies"
-    description="Automate retention with the platform’s expiration feature."
+    title="Scope memories by entity"
+    description="Manage retention per user, agent, or session with entity-scoped memory."
     icon="clock"
-    href="/platform/features/expiration-date"
+    href="/platform/features/entity-scoped-memory"
   />
 </CardGroup>

docs/docs.json

@@ -328,10 +328,8 @@
                       "cookbooks/essentials/building-ai-companion",
                       "cookbooks/essentials/entity-partitioning-playbook",
                       "cookbooks/essentials/controlling-memory-ingestion",
-                      "cookbooks/essentials/memory-expiration-short-and-long-term",
                       "cookbooks/essentials/tagging-and-organizing-memories",
-                      "cookbooks/essentials/exporting-memories",
-                      "cookbooks/essentials/choosing-memory-architecture-vector-vs-graph"
+                      "cookbooks/essentials/exporting-memories"
                     ]
                   },
                   {
@@ -627,6 +625,10 @@
       "source": "/platform/features/expiration-date",
       "destination": "/"
     },
+    {
+      "source": "/cookbooks/essentials/memory-expiration-short-and-long-term",
+      "destination": "/cookbooks/essentials/building-ai-companion"
+    },
     {
       "source": "/platform/features/async-mode-default-change",
       "destination": "/"
@@ -639,6 +641,10 @@
       "source": "/platform/features/graph-memory",
       "destination": "/migration/oss-v2-to-v3"
     },
+    {
+      "source": "/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph",
+      "destination": "/migration/oss-v2-to-v3"
+    },
     {
       "source": "/changelog",
       "destination": "/changelog/highlights"

docs/llms.txt

@@ -208,10 +208,8 @@ Key differentiators:
 - [Building AI Companion](https://docs.mem0.ai/cookbooks/essentials/building-ai-companion): Core patterns for building AI agents with memory
 - [Partition Memories by Entity](https://docs.mem0.ai/cookbooks/essentials/entity-partitioning-playbook): Keep multi-tenant assistants isolated by tagging user, agent, app, and session identifiers
 - [Controlling Memory Ingestion](https://docs.mem0.ai/cookbooks/essentials/controlling-memory-ingestion): Fine-tune what gets stored in memory and when
-- [Memory Expiration](https://docs.mem0.ai/cookbooks/essentials/memory-expiration-short-and-long-term): Implement short-term and long-term memory strategies
 - [Tagging and Organizing Memories](https://docs.mem0.ai/cookbooks/essentials/tagging-and-organizing-memories): Advanced memory organization and categorization
 - [Exporting Memories](https://docs.mem0.ai/cookbooks/essentials/exporting-memories): Backup and transfer memory data between systems
-- [Choosing Memory Architecture](https://docs.mem0.ai/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph): Vector vs Graph memory architectures comparison
 
 ### AI Companion Examples
 - [Quickstart Demo](https://docs.mem0.ai/cookbooks/companions/quickstart-demo): Quick demo of building an AI companion with memory

docs/open-source/python-quickstart.mdx

@@ -98,7 +98,7 @@ Learn how to search, update, and manage memories with full CRUD operations
 </Card>
 
 <Card title="Advanced Features" icon="sparkles" href="/open-source/features/async-memory">
-Explore async support, graph memory, and multi-agent memory organization
+Explore async support and multi-agent memory organization
 </Card>
 </CardGroup>