Enhance update method to support metadata (#2976 )

Fix pinecone for async memory (#2975 )
Fix Build CI Failure (#2973 )
2025-06-18 10:07:18 -07:00 · 2025-06-18 01:37:45 +05:30 · 2025-06-17 09:39:19 -07:00 · 2025-06-17 18:54:53 +05:30 · 2025-06-17 17:55:18 +05:30 · 2025-06-17 17:47:09 +05:30
26 changed files with 1502 additions and 393 deletions
@@ -52,6 +52,8 @@ jobs:
        with:
          path: .venv
          key: venv-mem0-${{ runner.os }}-${{ hashFiles('**/pyproject.toml') }}
+      - name: Install GEOS Libraries
+        run: sudo apt-get update && sudo apt-get install -y libgeos-dev
      - name: Install dependencies
        run: |
          make install_all
@@ -102,4 +104,4 @@ jobs:
        with:
          file: coverage.xml
        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
@@ -288,6 +288,11 @@ mode: "wide"

 <Tab title="TypeScript">

+<Update label="2025-06-17" description="v2.1.31">
+**Improvement :**
+- **Client:** Added param `filter_memories`.
+</Update>
+
 <Update label="2025-06-06" description="v2.1.30">
 **New Features:**
 - **OSS:** Added Cloudflare support
@@ -692,6 +697,11 @@ mode: "wide"

 <Tab title="Vercel AI SDK">

+<Update label="2025-06-15" description="v1.0.6">
+**New Features:**
+- **Vercel AI SDK:** Added param `filter_memories`.
+</Update>
+
 <Update label="2025-05-23" description="v1.0.5">
 **New Features:**
 - **Vercel AI SDK:** Added support for Google provider.
@@ -4,7 +4,11 @@ title: Gemini

 <Snippet file="paper-release.mdx" />

-To use Gemini model, you have to set the `GEMINI_API_KEY` environment variable. You can obtain the Gemini API key from the [Google AI Studio](https://aistudio.google.com/app/apikey)
+To use the Gemini model, set the `GEMINI_API_KEY` environment variable. You can obtain the Gemini API key from [Google AI Studio](https://aistudio.google.com/app/apikey).
+
+> **Note:** As of the latest release, Mem0 uses the new `google.genai` SDK instead of the deprecated `google.generativeai`. All message formatting and model interaction now use the updated `types` module from `google.genai`.
+
+> **Note:** Some Gemini models are being deprecated and will retire soon. It is recommended to migrate to the latest stable models like `"gemini-2.0-flash-001"` or `"gemini-2.0-flash-lite-001"` to ensure ongoing support and improvements.

 ## Usage

@@ -12,28 +16,32 @@ To use Gemini model, you have to set the `GEMINI_API_KEY` environment variable.
 import os
 from mem0 import Memory

-os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
-os.environ["GEMINI_API_KEY"] = "your-api-key"
+os.environ["OPENAI_API_KEY"] = "your-openai-api-key"  # Used for embedding model
+os.environ["GEMINI_API_KEY"] = "your-gemini-api-key"

 config = {
    "llm": {
        "provider": "gemini",
        "config": {
-            "model": "gemini-1.5-flash-latest",
+            "model": "gemini-2.0-flash-001",
            "temperature": 0.2,
            "max_tokens": 2000,
+            "top_p": 1.0
        }
    }
 }

 m = Memory.from_config(config)
+
 messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
-    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
-    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thrillers, but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thrillers and suggest sci-fi movies instead."}
 ]
+
 m.add(messages, user_id="alice", metadata={"category": "movies"})
+
 ```

 ## Config
@@ -23,6 +23,7 @@ config = {
            "temperature": 0.2,
            "max_tokens": 2000,
            "lmstudio_base_url": "http://localhost:1234/v1", # default LM Studio API URL
+            "lmstudio_response_format": {"type": "json_schema", "json_schema": {"type": "object", "schema": {}}},
        }
    }
 }
@@ -236,6 +236,7 @@
                "icon": "plug",
                "pages": [
                  "integrations",
+                  "integrations/agentops",
                  "integrations/vercel-ai-sdk",
                  "integrations/flowise",
                  "integrations/crewai",
@@ -18,6 +18,23 @@ Here are the available integrations for Mem0:
 ## Integrations

 <CardGroup cols={2}>
+  <Card
+    title="AgentOps"
+    icon={
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="25"
+        height="26"
+        viewBox="0 0 30 36"
+        fill="none"
+      >
+      <path d="M10.4659 6.47277C10.45 6.37428 10.4381 6.27986 10.4303 6.18101L10.4285 6.16388C10.4212 6.09482 10.414 6.02566 10.4106 5.95626L1.18538 21.8752C0.505422 23.0493 0.323356 24.4208 0.675227 25.7289C0.849119 26.3869 1.14971 26.9859 1.55323 27.5098C1.95675 28.0338 2.46282 28.4751 3.05175 28.8143C3.83464 29.2675 4.70856 29.5 5.59028 29.5C6.03318 29.5 6.4798 29.4408 6.91899 29.3226C8.23581 28.972 9.3349 28.1326 10.0152 26.9545L15.9268 16.749V16.7449L16.5001 15.7637L17.6431 13.7936L16.5001 11.8234L15.9309 10.8381L15.9268 10.8341L13.7836 7.13406C13.6651 6.933 13.5741 6.72418 13.5109 6.51165C13.2817 5.80223 13.3292 5.04172 13.6097 4.37599L13.8115 4.02535C14.3532 3.09155 15.31 2.53987 16.3184 2.47692C16.3738 2.46915 16.4251 2.46915 16.4804 2.46915C16.5421 2.46915 16.6038 2.47257 16.6654 2.47599L16.6822 2.47692C17.6906 2.53987 18.6474 3.09155 19.1892 4.02535L21.2216 7.52838L21.8146 8.55289L21.8421 8.60399L30.1024 22.8601C30.5174 23.5814 30.6281 24.4167 30.4148 25.2205C30.1975 26.0244 29.6832 26.6942 28.9598 27.1081C28.2364 27.5258 27.3977 27.6361 26.5911 27.4195C25.7844 27.2066 25.1123 26.6905 24.6968 25.9696L18.2119 14.7788L17.069 16.7449L22.9847 26.9545C23.6646 28.1326 24.7641 28.972 26.0809 29.3226C26.5197 29.4408 26.9626 29.5 27.4096 29.5C28.2914 29.5 29.1612 29.2675 29.9482 28.8143C31.1264 28.1367 31.9728 27.0411 32.3247 25.7289C32.6766 24.4208 32.4949 23.0493 31.8145 21.8752L21.1261 3.43034C20.7029 2.51617 20.0033 1.72011 19.0621 1.18027C18.5281 0.877027 17.9708 0.675975 17.3975 0.581189C17.3027 0.565268 17.2076 0.549717 17.1129 0.537868C17.0099 0.52602 16.9074 0.518244 16.8045 0.510469C16.6027 0.498621 16.3972 0.494548 16.1914 0.510469C16.0885 0.518244 15.9859 0.52639 15.883 0.537868C15.795 0.54887 15.7067 0.563384 15.6187 0.577852L15.5984 0.581189C15.0291 0.675605 14.4673 0.876657 13.9375 1.18027C12.9885 1.72789 12.2766 2.53579 11.8537 3.46181C11.7742 3.63473 11.707 3.81282 11.6471 3.99314C11.6361 4.02668 11.6269 4.06051 11.6177 4.09435C11.612 4.11503 11.6064 4.13579 11.6003 4.15642C11.5624 4.28601 11.5275 4.41634 11.4996 4.54853C11.4885 4.60231 11.4794 4.65668 11.4703 4.71111L11.4666 4.73329C11.4443 4.86399 11.4264 4.99543 11.4145 5.12762C11.4093 5.18686 11.4045 5.24573 11.4012 5.30534C11.3934 5.44567 11.3923 5.58637 11.3963 5.72744C11.3969 5.74403 11.3962 5.76062 11.3956 5.7772C11.3949 5.79616 11.3942 5.81512 11.3952 5.83407C11.3952 5.86184 11.3952 5.88924 11.3993 5.92071C11.3998 5.9291 11.4006 5.93736 11.4014 5.94564C11.402 5.95125 11.4026 5.95687 11.403 5.96255C11.4045 5.98181 11.4064 6.00106 11.4082 6.02031C11.4097 6.03577 11.4109 6.05122 11.4122 6.06674C11.4142 6.09134 11.4163 6.11621 11.419 6.14139L11.4428 6.32282C11.4506 6.38983 11.4625 6.46092 11.4744 6.52757C11.5063 6.68863 11.5468 6.84896 11.5936 7.0078C11.5944 7.0102 11.5949 7.0127 11.5955 7.0152C11.5958 7.01662 11.5961 7.01804 11.5965 7.01944C11.5967 7.02051 11.597 7.02157 11.5974 7.02261C11.6483 7.19293 11.7081 7.36177 11.7787 7.52838C11.8619 7.72943 11.9607 7.92641 12.0715 8.11932L12.3245 8.5566V8.56067L12.4984 8.85614L12.7199 9.24232H12.7239L12.728 9.25417L14.7802 12.7927V12.7968L14.7883 12.805V12.809L15.3576 13.7943L14.7883 14.7796L8.30344 25.9703C7.88431 26.6912 7.21216 27.2077 6.40921 27.4202C6.14019 27.4913 5.86338 27.5306 5.59474 27.5306C5.053 27.5306 4.51906 27.3888 4.04085 27.1089C3.31705 26.6953 2.79909 26.0251 2.58581 25.2213C2.36845 24.4174 2.47917 23.5821 2.89829 22.8609L11.1585 8.60473L11.186 8.56141V8.55734C11.1266 8.45478 11.0753 8.35629 11.024 8.25409C11.0105 8.22496 10.9969 8.19611 10.9834 8.16739C10.9458 8.08735 10.9086 8.00836 10.8739 7.92715C10.8718 7.92504 10.8708 7.92194 10.8698 7.91887C10.8688 7.91602 10.8679 7.91319 10.8661 7.91123V7.90346C10.8423 7.8483 10.8186 7.79311 10.7989 7.73795C10.7476 7.60799 10.7041 7.47803 10.6644 7.3477C10.6012 7.15479 10.5536 6.96152 10.518 6.76861C10.4942 6.67012 10.4786 6.5757 10.4667 6.47684C10.4667 6.47684 10.47 6.47684 10.4659 6.47277Z" fill="currentColor"></path>
+      </svg>
+    }
+    href="/integrations/agentops"
+  >
+    Monitor and analyze Mem0 operations with comprehensive AI agent analytics and LLM observability.
+  </Card>
  <Card
    title="LangChain"
    icon={
@@ -305,6 +322,7 @@ Here are the available integrations for Mem0:
  >
    Build autonomous agents with memory using Agno framework.
  </Card>
+
  <Card
    title="Keywords AI"
    icon={
@@ -0,0 +1,172 @@
+---
+title: AgentOps
+---
+<Snippet file="paper-release.mdx" />
+
+Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [AgentOps](https://agentops.ai), a comprehensive monitoring and analytics platform for AI agents. This integration enables automatic tracking and analysis of memory operations, providing insights into agent performance and memory usage patterns.
+
+## Overview
+
+1. Automatic monitoring of Mem0 operations and performance metrics
+2. Real-time tracking of memory add, search, and retrieval operations
+3. Analytics dashboard with memory usage patterns and insights
+4. Error tracking and debugging capabilities for memory operations
+
+## Prerequisites
+
+Before setting up Mem0 with AgentOps, ensure you have:
+
+1. Installed the required packages:
+```bash
+pip install mem0ai agentops
+```
+
+2. Valid API keys:
+   - [AgentOps API Key](https://app.agentops.ai/dashboard/api-keys)
+   - OpenAI API Key (for LLM operations)
+   - [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys) (optional, for cloud operations)
+
+## Basic Integration Example
+
+The following example demonstrates how to integrate Mem0 with AgentOps monitoring for comprehensive memory operation tracking:
+
+```python
+#Import the required libraries for local memory management with Mem0
+from mem0 import Memory, AsyncMemory
+import os
+import asyncio
+import logging
+from dotenv import load_dotenv
+import agentops
+
+#Set up environment variables for API keys
+os.environ["AGENTOPS_API_KEY"] = os.getenv("AGENTOPS_API_KEY")
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
+
+#Set up the configuration for local memory storage and define sample user data. 
+local_config = {
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o-mini",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        },
+    }
+}
+user_id = "alice_demo"
+agent_id = "assistant_demo"
+run_id = "session_001"
+
+sample_messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {
+        "role": "assistant",
+        "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future.",
+    },
+]
+
+sample_preferences = [
+    "I prefer dark roast coffee over light roast",
+    "I exercise every morning at 6 AM",
+    "I'm vegetarian and avoid all meat products",
+    "I love reading science fiction novels",
+    "I work in software engineering",
+]
+
+#This function demonstrates sequential memory operations using the synchronous Memory class
+def demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id):
+    """
+    Demonstrate synchronous Memory class operations.
+    """
+
+    agentops.start_trace("mem0_memory_example", tags=["mem0_memory_example"])
+    try:
+        
+        memory = Memory.from_config(local_config)
+
+        result = memory.add(
+            sample_messages, user_id=user_id, metadata={"category": "movie_preferences", "session": "demo"}
+        )
+
+        for i, preference in enumerate(sample_preferences):
+            result = memory.add(preference, user_id=user_id, metadata={"type": "preference", "index": i})
+       
+        search_queries = [
+            "What movies does the user like?",
+            "What are the user's food preferences?",
+            "When does the user exercise?",
+        ]
+
+        for query in search_queries:
+            results = memory.search(query, user_id=user_id)
+        
+            if results and "results" in results:
+                for j, result in enumerate(results): 
+                    print(f"Result {j+1}: {result.get('memory', 'N/A')}")
+            else:
+                print("No results found")
+
+        all_memories = memory.get_all(user_id=user_id)
+        if all_memories and "results" in all_memories:
+            print(f"Total memories: {len(all_memories['results'])}")
+
+        delete_all_result = memory.delete_all(user_id=user_id)
+        print(f"Delete all result: {delete_all_result}")
+
+        agentops.end_trace(end_state="success")
+    except Exception as e:
+        agentops.end_trace(end_state="error")
+
+# Execute sync demonstrations
+demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id)
+
+```
+
+For detailed information on this integration, refer to the official [Agentops Mem0 integration documentation](https://docs.agentops.ai/v2/integrations/mem0).
+
+
+## Key Features
+
+### 1. Automatic Operation Tracking
+
+AgentOps automatically monitors all Mem0 operations:
+
+- **Memory Operations**: Track add, search, get_all, delete operations and much more
+- **Performance Metrics**: Monitor response times and success rates
+- **Error Tracking**: Capture and analyze operation failures
+
+### 2. Real-time Analytics Dashboard
+
+Access comprehensive analytics through the AgentOps dashboard:
+
+- **Usage Patterns**: Visualize memory usage trends over time
+- **User Behavior**: Analyze how different users interact with memory
+- **Performance Insights**: Identify bottlenecks and optimization opportunities
+
+### 3. Session Management
+
+Organize your monitoring with structured sessions:
+
+- **Session Tracking**: Group related operations into logical sessions
+- **Success/Failure Rates**: Track session outcomes for reliability monitoring
+- **Custom Metadata**: Add context to sessions for better analysis
+
+## Best Practices
+
+1. **Initialize Early**: Always initialize AgentOps before importing Mem0 classes
+2. **Session Management**: Use meaningful session names and end sessions appropriately
+3. **Error Handling**: Wrap operations in try-catch blocks and report failures
+4. **Tagging**: Use tags to organize different types of memory operations
+5. **Environment Separation**: Use different projects or tags for dev/staging/prod
+
+## Help & Resources
+
+- [AgentOps Documentation](https://docs.agentops.ai/)
+- [AgentOps Dashboard](https://app.agentops.ai/)
+- [Mem0 Platform](https://app.mem0.ai/)
+
+<Snippet file="get-help.mdx" /> 
+ 
@@ -238,16 +238,24 @@ The Mem0's graph supports the following operations:
 ### Add Memories

 <Note>
-If you are using Mem0 with Graph Memory, it is recommended to pass `user_id`. Use `userId` in NodeSDK.
+Mem0 with Graph Memory supports both `user_id` and `agent_id` parameters. You can use either or both to organize your memories. Use `userId` and `agentId` in NodeSDK.
 </Note>

 <CodeGroup>
 ```python Python
+# Using only user_id
 m.add("I like pizza", user_id="alice")
+
+# Using both user_id and agent_id
+m.add("I like pizza", user_id="alice", agent_id="food-assistant")
 ```

 ```typescript TypeScript
+// Using only userId
 memory.add("I like pizza", { userId: "alice" });
+
+// Using both userId and agentId
+memory.add("I like pizza", { userId: "alice", agentId: "food-assistant" });
 ```

 ```json Output
@@ -260,11 +268,19 @@ memory.add("I like pizza", { userId: "alice" });

 <CodeGroup>
 ```python Python
+# Get all memories for a user
 m.get_all(user_id="alice")
+
+# Get all memories for a specific agent belonging to a user
+m.get_all(user_id="alice", agent_id="food-assistant")
 ```

 ```typescript TypeScript
+// Get all memories for a user
 memory.getAll({ userId: "alice" });
+
+// Get all memories for a specific agent belonging to a user
+memory.getAll({ userId: "alice", agentId: "food-assistant" });
 ```

 ```json Output
@@ -277,7 +293,8 @@ memory.getAll({ userId: "alice" });
            'metadata': None,
            'created_at': '2024-08-20T14:09:27.588719-07:00',
            'updated_at': None,
-            'user_id': 'alice'
+            'user_id': 'alice',
+            'agent_id': 'food-assistant'
        }
    ],
    'entities': [
@@ -295,11 +312,19 @@ memory.getAll({ userId: "alice" });

 <CodeGroup>
 ```python Python
+# Search memories for a user
 m.search("tell me my name.", user_id="alice")
+
+# Search memories for a specific agent belonging to a user
+m.search("tell me my name.", user_id="alice", agent_id="food-assistant")
 ```

 ```typescript TypeScript
+// Search memories for a user
 memory.search("tell me my name.", { userId: "alice" });
+
+// Search memories for a specific agent belonging to a user
+memory.search("tell me my name.", { userId: "alice", agentId: "food-assistant" });
 ```

 ```json Output
@@ -312,7 +337,8 @@ memory.search("tell me my name.", { userId: "alice" });
            'metadata': None,
            'created_at': '2024-08-20T14:09:27.588719-07:00',
            'updated_at': None,
-            'user_id': 'alice'
+            'user_id': 'alice',
+            'agent_id': 'food-assistant'
        }
    ],
    'entities': [
@@ -331,11 +357,19 @@ memory.search("tell me my name.", { userId: "alice" });

 <CodeGroup>
 ```python Python
+# Delete all memories for a user
 m.delete_all(user_id="alice")
+
+# Delete all memories for a specific agent belonging to a user
+m.delete_all(user_id="alice", agent_id="food-assistant")
 ```

 ```typescript TypeScript
+// Delete all memories for a user
 memory.deleteAll({ userId: "alice" });
+
+// Delete all memories for a specific agent belonging to a user
+memory.deleteAll({ userId: "alice", agentId: "food-assistant" });
 ```
 </CodeGroup>

@@ -516,6 +550,42 @@ memory.search("Who is spiderman?", { userId: "alice123" });

 > **Note:** The Graph Memory implementation is not standalone. You will be adding/retrieving memories to the vector store and the graph store simultaneously.

+## Using Multiple Agents with Graph Memory
+
+When working with multiple agents, you can use the `agent_id` parameter to organize memories by both user and agent. This allows you to:
+
+1. Create agent-specific knowledge graphs
+2. Share common knowledge between agents
+3. Isolate sensitive or specialized information to specific agents
+
+### Example: Multi-Agent Setup
+
+<CodeGroup>
+```python Python
+# Add memories for different agents
+m.add("I prefer Italian cuisine", user_id="bob", agent_id="food-assistant")
+m.add("I'm allergic to peanuts", user_id="bob", agent_id="health-assistant")
+m.add("I live in Seattle", user_id="bob")  # Shared across all agents
+
+# Search within specific agent context
+food_preferences = m.search("What food do I like?", user_id="bob", agent_id="food-assistant")
+health_info = m.search("What are my allergies?", user_id="bob", agent_id="health-assistant")
+location = m.search("Where do I live?", user_id="bob")  # Searches across all agents
+```
+
+```typescript TypeScript
+// Add memories for different agents
+memory.add("I prefer Italian cuisine", { userId: "bob", agentId: "food-assistant" });
+memory.add("I'm allergic to peanuts", { userId: "bob", agentId: "health-assistant" });
+memory.add("I live in Seattle", { userId: "bob" });  // Shared across all agents
+
+// Search within specific agent context
+const foodPreferences = memory.search("What food do I like?", { userId: "bob", agentId: "food-assistant" });
+const healthInfo = memory.search("What are my allergies?", { userId: "bob", agentId: "health-assistant" });
+const location = memory.search("Where do I live?", { userId: "bob" });  // Searches across all agents
+```
+</CodeGroup>
+
 If you want to use a managed version of Mem0, please check out [Mem0](https://mem0.dev/pd). If you have any questions, please feel free to reach out to us using one of the following methods:

-<Snippet file="get-help.mdx" />
+<Snippet file="get-help.mdx" />
@@ -1780,24 +1780,26 @@ curl -X GET "https://api.mem0.ai/v1/memories/<memory-id-here>/history/" \

 ### 4.6 Update Memory

-Update a memory with new data.
+Update a memory with new data. You can update the memory's text, metadata, or both.

 <CodeGroup>

 ```python Python
-message = "I recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes.."
-client.update(memory_id, message)
+client.update(
+    memory_id="<memory-id-here>",
+    text="I am now a vegetarian.", 
+    metadata={"diet": "vegetarian"}
+)
 ```

 ```javascript JavaScript
-const message = "I recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes..";
-client.update("memory-id-here", message)
+client.update("memory-id-here", { text: "I am now a vegetarian.", metadata: { diet: "vegetarian" } })
    .then(result => console.log(result))
    .catch(error => console.error(error));
 ```

 ```bash cURL
-curl -X PUT "https://api.mem0.ai/v1/memories/memory-id-here" \
+curl -X PUT "https://api.mem0.ai/v1/memories/<memory-id-here>" \
        -H "Authorization: Token your-api-key" \
        -H "Content-Type: application/json" \
        -d '{
@@ -2552,7 +2552,7 @@ azure = ["adlfs (>=2024.2.0)"]
 clip = ["open-clip", "pillow", "torch"]
 dev = ["pre-commit", "ruff"]
 docs = ["mkdocs", "mkdocs-jupyter", "mkdocs-material", "mkdocstrings[python]"]
-embeddings = ["awscli (>=1.29.57)", "boto3 (>=1.28.57)", "botocore (>=1.31.57)", "cohere", "google-generativeai", "huggingface-hub", "instructorembedding", "open-clip-torch", "openai (>=1.6.1)", "pillow", "sentence-transformers", "torch"]
+embeddings = ["awscli (>=1.29.57)", "boto3 (>=1.28.57)", "botocore (>=1.31.57)", "cohere", "google-generativeai", "huggingface-hub", "instructorembedding", "open-clip-torch", "openai (>=1.6.1)", "pillow", "sentence-transformers", "torch", "google-genai"]
 tests = ["aiohttp", "boto3", "duckdb", "pandas (>=1.4)", "polars (>=0.19)", "pytest", "pytest-asyncio", "pytest-mock", "pytz", "tantivy"]

 [[package]]
@@ -7129,7 +7129,7 @@ cffi = ["cffi (>=1.11)"]
 aws = ["langchain-aws"]
 elasticsearch = ["elasticsearch"]
 gmail = ["google-api-core", "google-api-python-client", "google-auth", "google-auth-httplib2", "google-auth-oauthlib", "requests"]
-google = ["google-generativeai"]
+google = ["google-generativeai", "google-genai"]
 googledrive = ["google-api-python-client", "google-auth-httplib2", "google-auth-oauthlib"]
 lancedb = ["lancedb"]
 llama2 = ["replicate"]
@@ -0,0 +1,124 @@
+"""Simple Voice Agent with Memory: Personal Food Assistant.
+A food assistant that remembers your dietary preferences and speaks recommendations
+Powered by Agno + Cartesia + Mem0
+
+export MEM0_API_KEY=your_mem0_api_key
+export OPENAI_API_KEY=your_openai_api_key
+export CARTESIA_API_KEY=your_cartesia_api_key
+"""
+
+from textwrap import dedent
+from agno.agent import Agent
+from agno.models.openai import OpenAIChat
+from agno.tools.cartesia import CartesiaTools
+from agno.utils.audio import write_audio_to_file
+from mem0 import MemoryClient
+
+memory_client = MemoryClient()
+USER_ID = "food_user_01"
+
+# Agent instructions
+agent_instructions = dedent(
+    """Follow these steps SEQUENTIALLY to provide personalized food recommendations with voice:
+    1. Analyze the user's food request and identify what type of recommendation they need.
+    2. Consider their dietary preferences, restrictions, and cooking habits from memory context.
+    3. Generate a personalized food recommendation based on their stored preferences.
+    4. Analyze the appropriate tone for the response (helpful, enthusiastic, cautious for allergies).
+    5. Call `list_voices` to retrieve available voices.
+    6. Select a voice that matches the helpful, friendly tone.
+    7. Call `text_to_speech` to generate the final audio recommendation.
+    """
+)
+
+# Simple agent that remembers food preferences
+food_agent = Agent(
+    name="Personal Food Assistant",
+    description="Provides personalized food recommendations with memory and generates voice responses using Cartesia TTS tools.",
+    instructions=agent_instructions,
+    model=OpenAIChat(id="gpt-4o"),
+    tools=[CartesiaTools(voice_localize_enabled=True)],
+    show_tool_calls=True,
+)
+
+
+def get_food_recommendation(user_query: str, user_id):
+    """Get food recommendation with memory context"""
+
+    # Search memory for relevant food preferences
+    memories_result = memory_client.search(
+        query=user_query,
+        user_id=user_id,
+        limit=5
+    )
+
+    # Add memory context to the message
+    memories = [f"- {result['memory']}" for result in memories_result]
+    memory_context = "Memories about user that might be relevant:\n" + "\n".join(memories)
+
+    # Combine memory context with user request
+    full_request = f"""
+    {memory_context}
+
+    User: {user_query}
+
+    Answer the user query based on provided context and create a voice note.
+    """
+
+    # Generate response with voice (same pattern as translator)
+    food_agent.print_response(full_request)
+    response = food_agent.run_response
+
+    # Save audio file
+    if response.audio:
+        import time
+        timestamp = int(time.time())
+        filename = f"food_recommendation_{timestamp}.mp3"
+        write_audio_to_file(
+            response.audio[0].base64_audio,
+            filename=filename,
+        )
+        print(f"Audio saved as {filename}")
+
+    return response.content
+
+
+def initialize_food_memory(user_id):
+    """Initialize memory with food preferences"""
+    messages = [
+        {
+            "role": "user",
+            "content": "Hi, I'm Sarah. I'm vegetarian and lactose intolerant. I love spicy food, especially Thai and Indian cuisine.",
+        },
+        {
+            "role": "assistant",
+            "content": "Hello Sarah! I've noted that you're vegetarian, lactose intolerant, and love spicy Thai and Indian food.",
+        },
+        {
+            "role": "user",
+            "content": "I prefer quick breakfasts since I'm always rushing, but I like cooking elaborate dinners. I also meal prep on Sundays.",
+        },
+        {
+            "role": "assistant",
+            "content": "Got it! Quick breakfasts, elaborate dinners, and Sunday meal prep. I'll remember this for future recommendations.",
+        },
+        {
+            "role": "user",
+            "content": "I'm trying to eat more protein. I like quinoa, lentils, chickpeas, and tofu. I hate mushrooms though.",
+        },
+        {
+            "role": "assistant",
+            "content": "Perfect! I'll focus on protein-rich options like quinoa, lentils, chickpeas, and tofu, and avoid mushrooms.",
+        },
+    ]
+
+    memory_client.add(messages, user_id=user_id)
+    print("Food preferences stored in memory")
+
+
+# Initialize the memory for the user once in order for the agent to learn the user preference
+initialize_food_memory(user_id=USER_ID)
+
+print(get_food_recommendation("Which type of restaurants should I go tonight for dinner and cuisines preferred?", user_id=USER_ID))
+# OUTPUT: 🎵 Audio saved as food_recommendation_1750162610.mp3
+# For dinner tonight, considering your love for healthy spic optionsy, you could try a nice Thai, Indian, or Mexican restaurant.
+# You might find dishes with quinoa, chickpeas, tofu, and fresh herbs delightful. Enjoy your dinner!
@@ -1,6 +1,6 @@
 {
  "name": "mem0ai",
-  "version": "2.1.30",
+  "version": "2.1.31",
  "description": "The Memory Layer For Your AI Apps",
  "main": "./dist/index.js",
  "module": "./dist/index.mjs",
@@ -24,6 +24,7 @@ export interface MemoryOptions {
  timestamp?: number;
  output_format?: string | OutputFormat;
  async_mode?: boolean;
+  filter_memories?: boolean;
 }

 export interface ProjectOptions {
@@ -43,6 +43,7 @@ class BaseLlmConfig(ABC):
        sarvam_base_url: Optional[str] = "https://api.sarvam.ai/v1",
        # LM Studio specific
        lmstudio_base_url: Optional[str] = "http://localhost:1234/v1",
+        lmstudio_response_format: dict = None,
        # AWS Bedrock specific
        aws_access_key_id: Optional[str] = None,
        aws_secret_access_key: Optional[str] = None,
@@ -95,6 +96,8 @@ class BaseLlmConfig(ABC):
        :type sarvam_base_url: Optional[str], optional
        :param lmstudio_base_url: LM Studio base URL to be use, defaults to "http://localhost:1234/v1"
        :type lmstudio_base_url: Optional[str], optional
+        :param lmstudio_response_format: LM Studio response format to be use, defaults to None
+        :type lmstudio_response_format: Optional[Dict], optional
        """

        self.model = model
@@ -134,6 +137,7 @@ class BaseLlmConfig(ABC):

        # LM Studio specific
        self.lmstudio_base_url = lmstudio_base_url
+        self.lmstudio_response_format = lmstudio_response_format

        # AWS Bedrock specific
        self.aws_access_key_id = aws_access_key_id
@@ -2,9 +2,9 @@ import os
 from typing import Dict, List, Optional

 try:
-    import google.generativeai as genai
-    from google.generativeai import GenerativeModel, protos
-    from google.generativeai.types import content_types
+    from google import genai
+    from google.genai import types
+    
 except ImportError:
    raise ImportError(
        "The 'google-generativeai' library is required. Please install it using 'pip install google-generativeai'."
@@ -22,66 +22,71 @@ class GeminiLLM(LLMBase):
            self.config.model = "gemini-1.5-flash-latest"

        api_key = self.config.api_key or os.getenv("GEMINI_API_KEY")
-        genai.configure(api_key=api_key)
-        self.client = GenerativeModel(model_name=self.config.model)
+        self.client_gemini = genai.Client(
+            api_key=api_key,
+        )

    def _parse_response(self, response, tools):
        """
        Process the response based on whether tools are used or not.

        Args:
-            response: The raw response from API.
+            response: The raw response from the API.
            tools: The list of tools provided in the request.

        Returns:
            str or dict: The processed response.
        """
+        candidate = response.candidates[0]
+        content = candidate.content.parts[0].text if candidate.content.parts else None
+
        if tools:
            processed_response = {
-                "content": (content if (content := response.candidates[0].content.parts[0].text) else None),
+                "content": content,
                "tool_calls": [],
            }

-            for part in response.candidates[0].content.parts:
-                if fn := part.function_call:
-                    if isinstance(fn, protos.FunctionCall):
-                        fn_call = type(fn).to_dict(fn)
-                        processed_response["tool_calls"].append({"name": fn_call["name"], "arguments": fn_call["args"]})
-                        continue
-                    processed_response["tool_calls"].append({"name": fn.name, "arguments": fn.args})
+            for part in candidate.content.parts:
+                fn = getattr(part, "function_call", None)
+                if fn:
+                    processed_response["tool_calls"].append({
+                        "name": fn.name,
+                        "arguments": fn.args,
+                    })

            return processed_response
-        else:
-            return response.candidates[0].content.parts[0].text

-    def _reformat_messages(self, messages: List[Dict[str, str]]):
+        return content
+
+
+    def _reformat_messages(self, messages: List[Dict[str, str]]) -> List[types.Content]:
        """
-        Reformat messages for Gemini.
+        Reformat messages for Gemini using google.genai.types.

        Args:
            messages: The list of messages provided in the request.

        Returns:
-            list: The list of messages in the required format.
+            list: A list of types.Content objects with proper role and parts.
        """
        new_messages = []

        for message in messages:
            if message["role"] == "system":
                content = "THIS IS A SYSTEM PROMPT. YOU MUST OBEY THIS: " + message["content"]
-
            else:
                content = message["content"]

            new_messages.append(
-                {
-                    "parts": content,
-                    "role": "model" if message["role"] == "model" else "user",
-                }
+                types.Content(
+                    role="model" if message["role"] == "model" else "user",
+                    parts=[types.Part(text=content)]
+                )
            )

        return new_messages

+
    def _reformat_tools(self, tools: Optional[List[Dict]]):
        """
        Reformat tools for Gemini.
@@ -126,6 +131,7 @@ class GeminiLLM(LLMBase):
        tools: Optional[List[Dict]] = None,
        tool_choice: str = "auto",
    ):
+        
        """
        Generate a response based on the given messages using Gemini.

@@ -149,23 +155,37 @@ class GeminiLLM(LLMBase):
            params["response_mime_type"] = "application/json"
            if "schema" in response_format:
                params["response_schema"] = response_format["schema"]
+
+        tool_config = None
        if tool_choice:
-            tool_config = content_types.to_tool_config(
-                {
-                    "function_calling_config": {
-                        "mode": tool_choice,
-                        "allowed_function_names": (
-                            [tool["function"]["name"] for tool in tools] if tool_choice == "any" else None
-                        ),
-                    }
-                }
+            tool_config = types.ToolConfig(
+                function_calling_config=types.FunctionCallingConfig(
+                    mode=tool_choice.upper(),  # Assuming 'any' should become 'ANY', etc.
+                    allowed_function_names=[
+                        tool["function"]["name"] for tool in tools
+                    ] if tool_choice == "any" else None
+                )
            )

-        response = self.client.generate_content(
-            contents=self._reformat_messages(messages),
-            tools=self._reformat_tools(tools),
-            generation_config=genai.GenerationConfig(**params),
-            tool_config=tool_config,
-        )
+        print(f"Tool config: {tool_config}")
+        print(f"Params: {params}" )
+        print(f"Messages: {messages}")
+        print(f"Tools: {tools}")
+        print(f"Reformatted messages: {self._reformat_messages(messages)}")
+        print(f"Reformatted tools: {self._reformat_tools(tools)}")
+
+        response = self.client_gemini.models.generate_content(
+                model=self.config.model,
+                contents=self._reformat_messages(messages),
+                config=types.GenerateContentConfig(
+                    temperature= self.config.temperature,
+                    max_output_tokens= self.config.max_tokens,
+                    top_p= self.config.top_p,
+                    tools=self._reformat_tools(tools),
+                    tool_config=tool_config,
+
+                ),
+            )
+        print(f"Response test: {response}")

        return self._parse_response(response, tools)
@@ -46,6 +46,8 @@ class LMStudioLLM(LLMBase):
        }
        if response_format:
            params["response_format"] = response_format
+        if self.config.lmstudio_response_format is not None:
+            params["response_format"] = self.config.lmstudio_response_format

        response = self.client.chat.completions.create(**params)
        return response.choices[0].message.content
@@ -80,8 +80,8 @@ class MemoryGraph:

        # TODO: Batch queries with APOC plugin
        # TODO: Add more filter support
-        deleted_entities = self._delete_entities(to_be_deleted, filters["user_id"])
-        added_entities = self._add_entities(to_be_added, filters["user_id"], entity_type_map)
+        deleted_entities = self._delete_entities(to_be_deleted, filters)
+        added_entities = self._add_entities(to_be_added, filters, entity_type_map)

        return {"deleted_entities": deleted_entities, "added_entities": added_entities}

@@ -122,32 +122,35 @@ class MemoryGraph:
        return search_results

    def delete_all(self, filters):
-        cypher = f"""
-        MATCH (n {self.node_label} {{user_id: $user_id}})
-        DETACH DELETE n
-        """
-        params = {"user_id": filters["user_id"]}
+        if filters.get("agent_id"):
+            cypher = f"""
+            MATCH (n {self.node_label} {{user_id: $user_id, agent_id: $agent_id}})
+            DETACH DELETE n
+            """
+            params = {"user_id": filters["user_id"], "agent_id": filters["agent_id"]}
+        else:
+            cypher = f"""
+            MATCH (n {self.node_label} {{user_id: $user_id}})
+            DETACH DELETE n
+            """
+            params = {"user_id": filters["user_id"]}
        self.graph.query(cypher, params=params)

-    def get_all(self, filters, limit=100):
-        """
-        Retrieves all nodes and relationships from the graph database based on optional filtering criteria.

-        Args:
-            filters (dict): A dictionary containing filters to be applied during the retrieval.
-            limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
-        Returns:
-            list: A list of dictionaries, each containing:
-                - 'contexts': The base data store response for each memory.
-                - 'entities': A list of strings representing the nodes and relationships
-        """
-        # return all nodes and relationships
+    def get_all(self, filters, limit=100):
+        agent_filter = ""
+        params = {"user_id": filters["user_id"], "limit": limit}
+        if filters.get("agent_id"):
+            agent_filter = "AND n.agent_id = $agent_id AND m.agent_id = $agent_id"
+            params["agent_id"] = filters["agent_id"]
+
        query = f"""
        MATCH (n {self.node_label} {{user_id: $user_id}})-[r]->(m {self.node_label} {{user_id: $user_id}})
+        WHERE 1=1 {agent_filter}
        RETURN n.name AS source, type(r) AS relationship, m.name AS target
        LIMIT $limit
        """
-        results = self.graph.query(query, params={"user_id": filters["user_id"], "limit": limit})
+        results = self.graph.query(query, params=params)

        final_results = []
        for result in results:
@@ -163,6 +166,7 @@ class MemoryGraph:

        return final_results

+
    def _retrieve_nodes_from_data(self, data, filters):
        """Extracts all the entities mentioned in the query."""
        _tools = [EXTRACT_ENTITIES_TOOL]
@@ -197,23 +201,27 @@ class MemoryGraph:
        return entity_type_map

    def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
-        """Eshtablish relations among the extracted nodes."""
+        """Establish relations among the extracted nodes."""
+
+    # Compose user identification string for prompt
+        user_identity = f"user_id: {filters['user_id']}"
+        if filters.get("agent_id"):
+            user_identity += f", agent_id: {filters['agent_id']}"
+
        if self.config.graph_store.custom_prompt:
+            system_content = EXTRACT_RELATIONS_PROMPT.replace("USER_ID", user_identity)
+            # Add the custom prompt line if configured
+            system_content = system_content.replace(
+                "CUSTOM_PROMPT", f"4. {self.config.graph_store.custom_prompt}"
+            )
            messages = [
-                {
-                    "role": "system",
-                    "content": EXTRACT_RELATIONS_PROMPT.replace("USER_ID", filters["user_id"]).replace(
-                        "CUSTOM_PROMPT", f"4. {self.config.graph_store.custom_prompt}"
-                    ),
-                },
+                {"role": "system", "content": system_content},
                {"role": "user", "content": data},
            ]
        else:
+            system_content = EXTRACT_RELATIONS_PROMPT.replace("USER_ID", user_identity)
            messages = [
-                {
-                    "role": "system",
-                    "content": EXTRACT_RELATIONS_PROMPT.replace("USER_ID", filters["user_id"]),
-                },
+                {"role": "system", "content": system_content},
                {"role": "user", "content": f"List of entities: {list(entity_type_map.keys())}. \n\nText: {data}"},
            ]

@@ -227,8 +235,8 @@ class MemoryGraph:
        )

        entities = []
-        if extracted_entities["tool_calls"]:
-            entities = extracted_entities["tool_calls"][0]["arguments"]["entities"]
+        if extracted_entities.get("tool_calls"):
+            entities = extracted_entities["tool_calls"][0].get("arguments", {}).get("entities", [])

        entities = self._remove_spaces_from_entities(entities)
        logger.debug(f"Extracted entities: {entities}")
@@ -237,32 +245,43 @@ class MemoryGraph:
    def _search_graph_db(self, node_list, filters, limit=100):
        """Search similar nodes among and their respective incoming and outgoing relations."""
        result_relations = []
+        agent_filter = ""
+        if filters.get("agent_id"):
+            agent_filter = "AND n.agent_id = $agent_id AND m.agent_id = $agent_id"
+
        for node in node_list:
            n_embedding = self.embedding_model.embed(node)

            cypher_query = f"""
            MATCH (n {self.node_label})
            WHERE n.embedding IS NOT NULL AND n.user_id = $user_id
+            {agent_filter}
            WITH n, round(2 * vector.similarity.cosine(n.embedding, $n_embedding) - 1, 4) AS similarity // denormalize for backward compatibility
            WHERE similarity >= $threshold
-            CALL (n) {{
-                MATCH (n)-[r]->(m) 
+            CALL {{
+                MATCH (n)-[r]->(m)
+                WHERE m.user_id = $user_id {agent_filter.replace("n.", "m.")} 
                RETURN n.name AS source, elementId(n) AS source_id, type(r) AS relationship, elementId(r) AS relation_id, m.name AS destination, elementId(m) AS destination_id
                UNION
-                MATCH (m)-[r]->(n) 
+                MATCH (m)-[r]->(n)
+                WHERE m.user_id = $user_id {agent_filter.replace("n.", "m.")}
                RETURN m.name AS source, elementId(m) AS source_id, type(r) AS relationship, elementId(r) AS relation_id, n.name AS destination, elementId(n) AS destination_id
            }}
-            WITH distinct source, source_id, relationship, relation_id, destination, destination_id, similarity //deduplicate
+            WITH distinct source, source_id, relationship, relation_id, destination, destination_id, similarity
            RETURN source, source_id, relationship, relation_id, destination, destination_id, similarity
            ORDER BY similarity DESC
            LIMIT $limit
            """
+
            params = {
                "n_embedding": n_embedding,
                "threshold": self.threshold,
                "user_id": filters["user_id"],
                "limit": limit,
            }
+            if filters.get("agent_id"):
+                params["agent_id"] = filters["agent_id"]
+
            ans = self.graph.query(cypher_query, params=params)
            result_relations.extend(ans)

@@ -271,7 +290,13 @@ class MemoryGraph:
    def _get_delete_entities_from_search_output(self, search_output, data, filters):
        """Get the entities to be deleted from the search output."""
        search_output_string = format_entities(search_output)
-        system_prompt, user_prompt = get_delete_messages(search_output_string, data, filters["user_id"])
+
+        # Compose user identification string for prompt
+        user_identity = f"user_id: {filters['user_id']}"
+        if filters.get("agent_id"):
+            user_identity += f", agent_id: {filters['agent_id']}"
+
+        system_prompt, user_prompt = get_delete_messages(search_output_string, data, user_identity)

        _tools = [DELETE_MEMORY_TOOL_GRAPH]
        if self.llm_provider in ["azure_openai_structured", "openai_structured"]:
@@ -288,44 +313,59 @@ class MemoryGraph:
        )

        to_be_deleted = []
-        for item in memory_updates["tool_calls"]:
-            if item["name"] == "delete_graph_memory":
-                to_be_deleted.append(item["arguments"])
-        # in case if it is not in the correct format
+        for item in memory_updates.get("tool_calls", []):
+            if item.get("name") == "delete_graph_memory":
+                to_be_deleted.append(item.get("arguments"))
+        # Clean entities formatting
        to_be_deleted = self._remove_spaces_from_entities(to_be_deleted)
        logger.debug(f"Deleted relationships: {to_be_deleted}")
        return to_be_deleted

-    def _delete_entities(self, to_be_deleted, user_id):
+    def _delete_entities(self, to_be_deleted, filters):
        """Delete the entities from the graph."""
+        user_id = filters["user_id"]
+        agent_id = filters.get("agent_id", None)
        results = []
+        
        for item in to_be_deleted:
            source = item["source"]
            destination = item["destination"]
            relationship = item["relationship"]

+            # Build the agent filter for the query
+            agent_filter = ""
+            params = {
+                "source_name": source,
+                "dest_name": destination,
+                "user_id": user_id,
+            }
+            
+            if agent_id:
+                agent_filter = "AND n.agent_id = $agent_id AND m.agent_id = $agent_id"
+                params["agent_id"] = agent_id
+
            # Delete the specific relationship between nodes
            cypher = f"""
            MATCH (n {self.node_label} {{name: $source_name, user_id: $user_id}})
            -[r:{relationship}]->
            (m {self.node_label} {{name: $dest_name, user_id: $user_id}})
+            WHERE 1=1 {agent_filter}
            DELETE r
            RETURN 
                n.name AS source,
                m.name AS target,
                type(r) AS relationship
            """
-            params = {
-                "source_name": source,
-                "dest_name": destination,
-                "user_id": user_id,
-            }
+            
            result = self.graph.query(cypher, params=params)
            results.append(result)
+        
        return results

-    def _add_entities(self, to_be_added, user_id, entity_type_map):
+    def _add_entities(self, to_be_added, filters, entity_type_map):
        """Add the new entities to the graph. Merge the nodes if they already exist."""
+        user_id = filters["user_id"]
+        agent_id = filters.get("agent_id", None)
        results = []
        for item in to_be_added:
            # entities
@@ -346,65 +386,80 @@ class MemoryGraph:
            dest_embedding = self.embedding_model.embed(destination)

            # search for the nodes with the closest embeddings
-            source_node_search_result = self._search_source_node(source_embedding, user_id, threshold=0.9)
-            destination_node_search_result = self._search_destination_node(dest_embedding, user_id, threshold=0.9)
+            source_node_search_result = self._search_source_node(source_embedding, filters, threshold=0.9)
+            destination_node_search_result = self._search_destination_node(dest_embedding, filters, threshold=0.9)

            # TODO: Create a cypher query and common params for all the cases
            if not destination_node_search_result and source_node_search_result:
-                cypher = f"""
-                    MATCH (source)
-                    WHERE elementId(source) = $source_id
-                    SET source.mentions = coalesce(source.mentions, 0) + 1
-                    WITH source
-                    MERGE (destination {destination_label} {{name: $destination_name, user_id: $user_id}})
-                    ON CREATE SET
-                        destination.created = timestamp(),
-                        destination.mentions = 1
-                        {destination_extra_set}
-                    ON MATCH SET
-                        destination.mentions = coalesce(destination.mentions, 0) + 1
-                    WITH source, destination
-                    CALL db.create.setNodeVectorProperty(destination, 'embedding', $destination_embedding)
-                    WITH source, destination
-                    MERGE (source)-[r:{relationship}]->(destination)
-                    ON CREATE SET 
-                        r.created = timestamp(),
-                        r.mentions = 1
-                    ON MATCH SET
-                        r.mentions = coalesce(r.mentions, 0) + 1
-                    RETURN source.name AS source, type(r) AS relationship, destination.name AS target
-                    """
+                # Build destination MERGE properties
+                merge_props = ["name: $destination_name", "user_id: $user_id"]
+                if agent_id:
+                    merge_props.append("agent_id: $agent_id")
+                merge_props_str = ", ".join(merge_props)

+                cypher = f"""
+                MATCH (source)
+                WHERE elementId(source) = $source_id
+                SET source.mentions = coalesce(source.mentions, 0) + 1
+                WITH source
+                MERGE (destination {destination_label} {{{merge_props_str}}})
+                ON CREATE SET
+                    destination.created = timestamp(),
+                    destination.mentions = 1
+                    {destination_extra_set}
+                ON MATCH SET
+                    destination.mentions = coalesce(destination.mentions, 0) + 1
+                WITH source, destination
+                CALL db.create.setNodeVectorProperty(destination, 'embedding', $destination_embedding)
+                WITH source, destination
+                MERGE (source)-[r:{relationship}]->(destination)
+                ON CREATE SET 
+                    r.created = timestamp(),
+                    r.mentions = 1
+                ON MATCH SET
+                    r.mentions = coalesce(r.mentions, 0) + 1
+                RETURN source.name AS source, type(r) AS relationship, destination.name AS target
+                """
+                
                params = {
                    "source_id": source_node_search_result[0]["elementId(source_candidate)"],
                    "destination_name": destination,
                    "destination_embedding": dest_embedding,
                    "user_id": user_id,
                }
+                if agent_id:
+                    params["agent_id"] = agent_id
+
            elif destination_node_search_result and not source_node_search_result:
+                # Build source MERGE properties
+                merge_props = ["name: $source_name", "user_id: $user_id"]
+                if agent_id:
+                    merge_props.append("agent_id: $agent_id")
+                merge_props_str = ", ".join(merge_props)
+
                cypher = f"""
-                    MATCH (destination)
-                    WHERE elementId(destination) = $destination_id
-                    SET destination.mentions = coalesce(destination.mentions, 0) + 1
-                    WITH destination
-                    MERGE (source {source_label} {{name: $source_name, user_id: $user_id}})
-                    ON CREATE SET
-                        source.created = timestamp(),
-                        source.mentions = 1
-                        {source_extra_set}
-                    ON MATCH SET
-                        source.mentions = coalesce(source.mentions, 0) + 1
-                    WITH source, destination
-                    CALL db.create.setNodeVectorProperty(source, 'embedding', $source_embedding)
-                    WITH source, destination
-                    MERGE (source)-[r:{relationship}]->(destination)
-                    ON CREATE SET 
-                        r.created = timestamp(),
-                        r.mentions = 1
-                    ON MATCH SET
-                        r.mentions = coalesce(r.mentions, 0) + 1
-                    RETURN source.name AS source, type(r) AS relationship, destination.name AS target
-                    """
+                MATCH (destination)
+                WHERE elementId(destination) = $destination_id
+                SET destination.mentions = coalesce(destination.mentions, 0) + 1
+                WITH destination
+                MERGE (source {source_label} {{{merge_props_str}}})
+                ON CREATE SET
+                    source.created = timestamp(),
+                    source.mentions = 1
+                    {source_extra_set}
+                ON MATCH SET
+                    source.mentions = coalesce(source.mentions, 0) + 1
+                WITH source, destination
+                CALL db.create.setNodeVectorProperty(source, 'embedding', $source_embedding)
+                WITH source, destination
+                MERGE (source)-[r:{relationship}]->(destination)
+                ON CREATE SET 
+                    r.created = timestamp(),
+                    r.mentions = 1
+                ON MATCH SET
+                    r.mentions = coalesce(r.mentions, 0) + 1
+                RETURN source.name AS source, type(r) AS relationship, destination.name AS target
+                """

                params = {
                    "destination_id": destination_node_search_result[0]["elementId(destination_candidate)"],
@@ -412,53 +467,68 @@ class MemoryGraph:
                    "source_embedding": source_embedding,
                    "user_id": user_id,
                }
+                if agent_id:
+                    params["agent_id"] = agent_id
+
            elif source_node_search_result and destination_node_search_result:
                cypher = f"""
-                    MATCH (source)
-                    WHERE elementId(source) = $source_id
-                    SET source.mentions = coalesce(source.mentions, 0) + 1
-                    WITH source
-                    MATCH (destination)
-                    WHERE elementId(destination) = $destination_id
-                    SET destination.mentions = coalesce(destination.mentions) + 1
-                    MERGE (source)-[r:{relationship}]->(destination)
-                    ON CREATE SET 
-                        r.created_at = timestamp(),
-                        r.updated_at = timestamp(),
-                        r.mentions = 1
-                    ON MATCH SET r.mentions = coalesce(r.mentions, 0) + 1
-                    
-                    
-                    RETURN source.name AS source, type(r) AS relationship, destination.name AS target
-                    """
+                MATCH (source)
+                WHERE elementId(source) = $source_id
+                SET source.mentions = coalesce(source.mentions, 0) + 1
+                WITH source
+                MATCH (destination)
+                WHERE elementId(destination) = $destination_id
+                SET destination.mentions = coalesce(destination.mentions, 0) + 1
+                MERGE (source)-[r:{relationship}]->(destination)
+                ON CREATE SET 
+                    r.created_at = timestamp(),
+                    r.updated_at = timestamp(),
+                    r.mentions = 1
+                ON MATCH SET r.mentions = coalesce(r.mentions, 0) + 1
+                RETURN source.name AS source, type(r) AS relationship, destination.name AS target
+                """
+
                params = {
                    "source_id": source_node_search_result[0]["elementId(source_candidate)"],
                    "destination_id": destination_node_search_result[0]["elementId(destination_candidate)"],
                    "user_id": user_id,
                }
+                if agent_id:
+                    params["agent_id"] = agent_id
+
            else:
+                # Build dynamic MERGE props for both source and destination
+                source_props = ["name: $source_name", "user_id: $user_id"]
+                dest_props = ["name: $dest_name", "user_id: $user_id"]
+                if agent_id:
+                    source_props.append("agent_id: $agent_id")
+                    dest_props.append("agent_id: $agent_id")
+                source_props_str = ", ".join(source_props)
+                dest_props_str = ", ".join(dest_props)
+
                cypher = f"""
-                    MERGE (source {source_label} {{name: $source_name, user_id: $user_id}})
-                    ON CREATE SET source.created = timestamp(),
-                                  source.mentions = 1
-                                  {source_extra_set}
-                    ON MATCH SET source.mentions = coalesce(source.mentions, 0) + 1
-                    WITH source
-                    CALL db.create.setNodeVectorProperty(source, 'embedding', $source_embedding)
-                    WITH source
-                    MERGE (destination {destination_label} {{name: $dest_name, user_id: $user_id}})
-                    ON CREATE SET destination.created = timestamp(),
-                                  destination.mentions = 1
-                                  {destination_extra_set}
-                    ON MATCH SET destination.mentions = coalesce(destination.mentions, 0) + 1
-                    WITH source, destination
-                    CALL db.create.setNodeVectorProperty(destination, 'embedding', $source_embedding)
-                    WITH source, destination
-                    MERGE (source)-[rel:{relationship}]->(destination)
-                    ON CREATE SET rel.created = timestamp(), rel.mentions = 1
-                    ON MATCH SET rel.mentions = coalesce(rel.mentions, 0) + 1
-                    RETURN source.name AS source, type(rel) AS relationship, destination.name AS target
-                    """
+                MERGE (source {source_label} {{{source_props_str}}})
+                ON CREATE SET source.created = timestamp(),
+                            source.mentions = 1
+                            {source_extra_set}
+                ON MATCH SET source.mentions = coalesce(source.mentions, 0) + 1
+                WITH source
+                CALL db.create.setNodeVectorProperty(source, 'embedding', $source_embedding)
+                WITH source
+                MERGE (destination {destination_label} {{{dest_props_str}}})
+                ON CREATE SET destination.created = timestamp(),
+                            destination.mentions = 1
+                            {destination_extra_set}
+                ON MATCH SET destination.mentions = coalesce(destination.mentions, 0) + 1
+                WITH source, destination
+                CALL db.create.setNodeVectorProperty(destination, 'embedding', $dest_embedding)
+                WITH source, destination
+                MERGE (source)-[rel:{relationship}]->(destination)
+                ON CREATE SET rel.created = timestamp(), rel.mentions = 1
+                ON MATCH SET rel.mentions = coalesce(rel.mentions, 0) + 1
+                RETURN source.name AS source, type(rel) AS relationship, destination.name AS target
+                """
+
                params = {
                    "source_name": source,
                    "dest_name": destination,
@@ -466,6 +536,8 @@ class MemoryGraph:
                    "dest_embedding": dest_embedding,
                    "user_id": user_id,
                }
+                if agent_id:
+                    params["agent_id"] = agent_id
            result = self.graph.query(cypher, params=params)
            results.append(result)
        return results
@@ -477,11 +549,16 @@ class MemoryGraph:
            item["destination"] = item["destination"].lower().replace(" ", "_")
        return entity_list

-    def _search_source_node(self, source_embedding, user_id, threshold=0.9):
+    def _search_source_node(self, source_embedding, filters, threshold=0.9):
+        agent_filter = ""
+        if filters.get("agent_id"):
+            agent_filter = "AND source_candidate.agent_id = $agent_id"
+
        cypher = f"""
            MATCH (source_candidate {self.node_label})
            WHERE source_candidate.embedding IS NOT NULL 
            AND source_candidate.user_id = $user_id
+            {agent_filter}

            WITH source_candidate,
            round(2 * vector.similarity.cosine(source_candidate.embedding, $source_embedding) - 1, 4) AS source_similarity // denormalize for backward compatibility
@@ -496,18 +573,26 @@ class MemoryGraph:

        params = {
            "source_embedding": source_embedding,
-            "user_id": user_id,
+            "user_id": filters["user_id"],
            "threshold": threshold,
        }
+        if filters.get("agent_id"):
+            params["agent_id"] = filters["agent_id"]

        result = self.graph.query(cypher, params=params)
        return result

-    def _search_destination_node(self, destination_embedding, user_id, threshold=0.9):
+
+    def _search_destination_node(self, destination_embedding, filters, threshold=0.9):
+        agent_filter = ""
+        if filters.get("agent_id"):
+            agent_filter = "AND destination_candidate.agent_id = $agent_id"
+
        cypher = f"""
            MATCH (destination_candidate {self.node_label})
            WHERE destination_candidate.embedding IS NOT NULL 
            AND destination_candidate.user_id = $user_id
+            {agent_filter}

            WITH destination_candidate,
            round(2 * vector.similarity.cosine(destination_candidate.embedding, $destination_embedding) - 1, 4) AS destination_similarity // denormalize for backward compatibility
@@ -520,11 +605,14 @@ class MemoryGraph:

            RETURN elementId(destination_candidate)
            """
+
        params = {
            "destination_embedding": destination_embedding,
-            "user_id": user_id,
+            "user_id": filters["user_id"],
            "threshold": threshold,
        }
+        if filters.get("agent_id"):
+            params["agent_id"] = filters["agent_id"]

        result = self.graph.query(cypher, params=params)
        return result
@@ -1415,7 +1415,9 @@ class AsyncMemory(MemoryBase):
    async def _get_all_from_vector_store(self, filters, limit):
        memories_result = await asyncio.to_thread(self.vector_store.list, filters=filters, limit=limit)
        actual_memories = (
-            memories_result[0] if isinstance(memories_result, tuple) and len(memories_result) > 0 else memories_result
+            memories_result[0]
+            if isinstance(memories_result, (tuple, list)) and len(memories_result) > 0
+            else memories_result
        )

        promoted_payload_keys = [
@@ -118,11 +118,19 @@ class MemoryGraph:
        return search_results

    def delete_all(self, filters):
-        cypher = """
-        MATCH (n {user_id: $user_id})
-        DETACH DELETE n
-        """
-        params = {"user_id": filters["user_id"]}
+        """Delete all nodes and relationships for a user or specific agent."""
+        if filters.get("agent_id"):
+            cypher = """
+            MATCH (n:Entity {user_id: $user_id, agent_id: $agent_id})
+            DETACH DELETE n
+            """
+            params = {"user_id": filters["user_id"], "agent_id": filters["agent_id"]}
+        else:
+            cypher = """
+            MATCH (n:Entity {user_id: $user_id})
+            DETACH DELETE n
+            """
+            params = {"user_id": filters["user_id"]}
        self.graph.query(cypher, params=params)

    def get_all(self, filters, limit=100):
@@ -131,20 +139,31 @@ class MemoryGraph:

        Args:
            filters (dict): A dictionary containing filters to be applied during the retrieval.
+                Supports 'user_id' (required) and 'agent_id' (optional).
            limit (int): The maximum number of nodes and relationships to retrieve. Defaults to 100.
        Returns:
            list: A list of dictionaries, each containing:
-                - 'contexts': The base data store response for each memory.
-                - 'entities': A list of strings representing the nodes and relationships
+                - 'source': The source node name.
+                - 'relationship': The relationship type.
+                - 'target': The target node name.
        """
-
-        # return all nodes and relationships
-        query = """
-        MATCH (n:Entity {user_id: $user_id})-[r]->(m:Entity {user_id: $user_id})
-        RETURN n.name AS source, type(r) AS relationship, m.name AS target
-        LIMIT $limit
-        """
-        results = self.graph.query(query, params={"user_id": filters["user_id"], "limit": limit})
+        # Build query based on whether agent_id is provided
+        if filters.get("agent_id"):
+            query = """
+            MATCH (n:Entity {user_id: $user_id, agent_id: $agent_id})-[r]->(m:Entity {user_id: $user_id, agent_id: $agent_id})
+            RETURN n.name AS source, type(r) AS relationship, m.name AS target
+            LIMIT $limit
+            """
+            params = {"user_id": filters["user_id"], "agent_id": filters["agent_id"], "limit": limit}
+        else:
+            query = """
+            MATCH (n:Entity {user_id: $user_id})-[r]->(m:Entity {user_id: $user_id})
+            RETURN n.name AS source, type(r) AS relationship, m.name AS target
+            LIMIT $limit
+            """
+            params = {"user_id": filters["user_id"], "limit": limit}
+        
+        results = self.graph.query(query, params=params)

        final_results = []
        for result in results:
@@ -241,33 +260,65 @@ class MemoryGraph:
        for node in node_list:
            n_embedding = self.embedding_model.embed(node)

-            cypher_query = """
-            MATCH (n:Entity {user_id: $user_id})-[r]->(m:Entity)
-            WHERE n.embedding IS NOT NULL
-            WITH collect(n) AS nodes1, collect(m) AS nodes2, r
-            CALL node_similarity.cosine_pairwise("embedding", nodes1, nodes2)
-            YIELD node1, node2, similarity
-            WITH node1, node2, similarity, r
-            WHERE similarity >= $threshold
-            RETURN node1.user_id AS source, id(node1) AS source_id, type(r) AS relationship, id(r) AS relation_id, node2.user_id AS destination, id(node2) AS destination_id, similarity
-            UNION
-            MATCH (n:Entity {user_id: $user_id})<-[r]-(m:Entity)
-            WHERE n.embedding IS NOT NULL
-            WITH collect(n) AS nodes1, collect(m) AS nodes2, r
-            CALL node_similarity.cosine_pairwise("embedding", nodes1, nodes2)
-            YIELD node1, node2, similarity
-            WITH node1, node2, similarity, r
-            WHERE similarity >= $threshold
-            RETURN node2.name AS source, id(node2) AS source_id, type(r) AS relationship, id(r) AS relation_id, node1.name AS destination, id(node1) AS destination_id, similarity
-            ORDER BY similarity DESC
-            LIMIT $limit;
-            """
-            params = {
-                "n_embedding": n_embedding,
-                "threshold": self.threshold,
-                "user_id": filters["user_id"],
-                "limit": limit,
-            }
+            # Build query based on whether agent_id is provided
+            if filters.get("agent_id"):
+                cypher_query = """
+                MATCH (n:Entity {user_id: $user_id, agent_id: $agent_id})-[r]->(m:Entity)
+                WHERE n.embedding IS NOT NULL
+                WITH collect(n) AS nodes1, collect(m) AS nodes2, r
+                CALL node_similarity.cosine_pairwise("embedding", nodes1, nodes2)
+                YIELD node1, node2, similarity
+                WITH node1, node2, similarity, r
+                WHERE similarity >= $threshold
+                RETURN node1.name AS source, id(node1) AS source_id, type(r) AS relationship, id(r) AS relation_id, node2.name AS destination, id(node2) AS destination_id, similarity
+                UNION
+                MATCH (n:Entity {user_id: $user_id, agent_id: $agent_id})<-[r]-(m:Entity)
+                WHERE n.embedding IS NOT NULL
+                WITH collect(n) AS nodes1, collect(m) AS nodes2, r
+                CALL node_similarity.cosine_pairwise("embedding", nodes1, nodes2)
+                YIELD node1, node2, similarity
+                WITH node1, node2, similarity, r
+                WHERE similarity >= $threshold
+                RETURN node2.name AS source, id(node2) AS source_id, type(r) AS relationship, id(r) AS relation_id, node1.name AS destination, id(node1) AS destination_id, similarity
+                ORDER BY similarity DESC
+                LIMIT $limit;
+                """
+                params = {
+                    "n_embedding": n_embedding,
+                    "threshold": self.threshold,
+                    "user_id": filters["user_id"],
+                    "agent_id": filters["agent_id"],
+                    "limit": limit,
+                }
+            else:
+                cypher_query = """
+                MATCH (n:Entity {user_id: $user_id})-[r]->(m:Entity)
+                WHERE n.embedding IS NOT NULL
+                WITH collect(n) AS nodes1, collect(m) AS nodes2, r
+                CALL node_similarity.cosine_pairwise("embedding", nodes1, nodes2)
+                YIELD node1, node2, similarity
+                WITH node1, node2, similarity, r
+                WHERE similarity >= $threshold
+                RETURN node1.name AS source, id(node1) AS source_id, type(r) AS relationship, id(r) AS relation_id, node2.name AS destination, id(node2) AS destination_id, similarity
+                UNION
+                MATCH (n:Entity {user_id: $user_id})<-[r]-(m:Entity)
+                WHERE n.embedding IS NOT NULL
+                WITH collect(n) AS nodes1, collect(m) AS nodes2, r
+                CALL node_similarity.cosine_pairwise("embedding", nodes1, nodes2)
+                YIELD node1, node2, similarity
+                WITH node1, node2, similarity, r
+                WHERE similarity >= $threshold
+                RETURN node2.name AS source, id(node2) AS source_id, type(r) AS relationship, id(r) AS relation_id, node1.name AS destination, id(node1) AS destination_id, similarity
+                ORDER BY similarity DESC
+                LIMIT $limit;
+                """
+                params = {
+                    "n_embedding": n_embedding,
+                    "threshold": self.threshold,
+                    "user_id": filters["user_id"],
+                    "limit": limit,
+                }
+            
            ans = self.graph.query(cypher_query, params=params)
            result_relations.extend(ans)

@@ -300,38 +351,54 @@ class MemoryGraph:
        logger.debug(f"Deleted relationships: {to_be_deleted}")
        return to_be_deleted

-    def _delete_entities(self, to_be_deleted, user_id):
+    def _delete_entities(self, to_be_deleted, filters):
        """Delete the entities from the graph."""
+        user_id = filters["user_id"]
+        agent_id = filters.get("agent_id", None)
        results = []
+        
        for item in to_be_deleted:
            source = item["source"]
            destination = item["destination"]
            relationship = item["relationship"]

+            # Build the agent filter for the query
+            agent_filter = ""
+            params = {
+                "source_name": source,
+                "dest_name": destination,
+                "user_id": user_id,
+            }
+            
+            if agent_id:
+                agent_filter = "AND n.agent_id = $agent_id AND m.agent_id = $agent_id"
+                params["agent_id"] = agent_id
+
            # Delete the specific relationship between nodes
            cypher = f"""
            MATCH (n:Entity {{name: $source_name, user_id: $user_id}})
            -[r:{relationship}]->
-            (m {{name: $dest_name, user_id: $user_id}})
+            (m:Entity {{name: $dest_name, user_id: $user_id}})
+            WHERE 1=1 {agent_filter}
            DELETE r
            RETURN 
                n.name AS source,
                m.name AS target,
                type(r) AS relationship
            """
-            params = {
-                "source_name": source,
-                "dest_name": destination,
-                "user_id": user_id,
-            }
+            
            result = self.graph.query(cypher, params=params)
            results.append(result)
+        
        return results

    # added Entity label to all nodes for vector search to work
-    def _add_entities(self, to_be_added, user_id, entity_type_map):
+    def _add_entities(self, to_be_added, filters, entity_type_map):
        """Add the new entities to the graph. Merge the nodes if they already exist."""
+        user_id = filters["user_id"]
+        agent_id = filters.get("agent_id", None)
        results = []
+        
        for item in to_be_added:
            # entities
            source = item["source"]
@@ -346,18 +413,21 @@ class MemoryGraph:
            source_embedding = self.embedding_model.embed(source)
            dest_embedding = self.embedding_model.embed(destination)

-            # search for the nodes with the closest embeddings; this is basically
-            # comparison of one embedding to all embeddings in a graph -> vector
-            # search with cosine similarity metric
-            source_node_search_result = self._search_source_node(source_embedding, user_id, threshold=0.9)
-            destination_node_search_result = self._search_destination_node(dest_embedding, user_id, threshold=0.9)
+            # search for the nodes with the closest embeddings
+            source_node_search_result = self._search_source_node(source_embedding, filters, threshold=0.9)
+            destination_node_search_result = self._search_destination_node(dest_embedding, filters, threshold=0.9)

+            # Prepare agent_id for node creation
+            agent_id_clause = ""
+            if agent_id:
+                agent_id_clause = ", agent_id: $agent_id"
+            
            # TODO: Create a cypher query and common params for all the cases
            if not destination_node_search_result and source_node_search_result:
                cypher = f"""
                    MATCH (source:Entity)
                    WHERE id(source) = $source_id
-                    MERGE (destination:{destination_type}:Entity {{name: $destination_name, user_id: $user_id}})
+                    MERGE (destination:{destination_type}:Entity {{name: $destination_name, user_id: $user_id{agent_id_clause}}})
                    ON CREATE SET
                        destination.created = timestamp(),
                        destination.embedding = $destination_embedding,
@@ -374,11 +444,14 @@ class MemoryGraph:
                    "destination_embedding": dest_embedding,
                    "user_id": user_id,
                }
+                if agent_id:
+                    params["agent_id"] = agent_id
+                
            elif destination_node_search_result and not source_node_search_result:
                cypher = f"""
                    MATCH (destination:Entity)
                    WHERE id(destination) = $destination_id
-                    MERGE (source:{source_type}:Entity {{name: $source_name, user_id: $user_id}})
+                    MERGE (source:{source_type}:Entity {{name: $source_name, user_id: $user_id{agent_id_clause}}})
                    ON CREATE SET
                        source.created = timestamp(),
                        source.embedding = $source_embedding,
@@ -395,6 +468,9 @@ class MemoryGraph:
                    "source_embedding": source_embedding,
                    "user_id": user_id,
                }
+                if agent_id:
+                    params["agent_id"] = agent_id
+                
            elif source_node_search_result and destination_node_search_result:
                cypher = f"""
                    MATCH (source:Entity)
@@ -412,12 +488,15 @@ class MemoryGraph:
                    "destination_id": destination_node_search_result[0]["id(destination_candidate)"],
                    "user_id": user_id,
                }
+                if agent_id:
+                    params["agent_id"] = agent_id
+                
            else:
                cypher = f"""
-                    MERGE (n:{source_type}:Entity {{name: $source_name, user_id: $user_id}})
+                    MERGE (n:{source_type}:Entity {{name: $source_name, user_id: $user_id{agent_id_clause}}})
                    ON CREATE SET n.created = timestamp(), n.embedding = $source_embedding, n:Entity
                    ON MATCH SET n.embedding = $source_embedding
-                    MERGE (m:{destination_type}:Entity {{name: $dest_name, user_id: $user_id}})
+                    MERGE (m:{destination_type}:Entity {{name: $dest_name, user_id: $user_id{agent_id_clause}}})
                    ON CREATE SET m.created = timestamp(), m.embedding = $dest_embedding, m:Entity
                    ON MATCH SET m.embedding = $dest_embedding
                    MERGE (n)-[rel:{relationship}]->(m)
@@ -431,6 +510,9 @@ class MemoryGraph:
                    "dest_embedding": dest_embedding,
                    "user_id": user_id,
                }
+                if agent_id:
+                    params["agent_id"] = agent_id
+                
            result = self.graph.query(cypher, params=params)
            results.append(result)
        return results
@@ -442,37 +524,80 @@ class MemoryGraph:
            item["destination"] = item["destination"].lower().replace(" ", "_")
        return entity_list

-    def _search_source_node(self, source_embedding, user_id, threshold=0.9):
-        cypher = """
-            CALL vector_search.search("memzero", 1, $source_embedding) 
-            YIELD distance, node, similarity
-            WITH node AS source_candidate, similarity
-            WHERE source_candidate.user_id = $user_id AND similarity >= $threshold
-            RETURN id(source_candidate);
-            """
-
-        params = {
-            "source_embedding": source_embedding,
-            "user_id": user_id,
-            "threshold": threshold,
-        }
+    def _search_source_node(self, source_embedding, filters, threshold=0.9):
+        """Search for source nodes with similar embeddings."""
+        user_id = filters["user_id"]
+        agent_id = filters.get("agent_id", None)
+        
+        if agent_id:
+            cypher = """
+                CALL vector_search.search("memzero", 1, $source_embedding) 
+                YIELD distance, node, similarity
+                WITH node AS source_candidate, similarity
+                WHERE source_candidate.user_id = $user_id 
+                AND source_candidate.agent_id = $agent_id 
+                AND similarity >= $threshold
+                RETURN id(source_candidate);
+                """
+            params = {
+                "source_embedding": source_embedding,
+                "user_id": user_id,
+                "agent_id": agent_id,
+                "threshold": threshold,
+            }
+        else:
+            cypher = """
+                CALL vector_search.search("memzero", 1, $source_embedding) 
+                YIELD distance, node, similarity
+                WITH node AS source_candidate, similarity
+                WHERE source_candidate.user_id = $user_id 
+                AND similarity >= $threshold
+                RETURN id(source_candidate);
+                """
+            params = {
+                "source_embedding": source_embedding,
+                "user_id": user_id,
+                "threshold": threshold,
+            }

        result = self.graph.query(cypher, params=params)
        return result

-    def _search_destination_node(self, destination_embedding, user_id, threshold=0.9):
-        cypher = """
-            CALL vector_search.search("memzero", 1, $destination_embedding) 
-            YIELD distance, node, similarity
-            WITH node AS destination_candidate, similarity
-            WHERE node.user_id = $user_id AND similarity >= $threshold
-            RETURN id(destination_candidate);
-            """
-        params = {
-            "destination_embedding": destination_embedding,
-            "user_id": user_id,
-            "threshold": threshold,
-        }
+    def _search_destination_node(self, destination_embedding, filters, threshold=0.9):
+        """Search for destination nodes with similar embeddings."""
+        user_id = filters["user_id"]
+        agent_id = filters.get("agent_id", None)
+        
+        if agent_id:
+            cypher = """
+                CALL vector_search.search("memzero", 1, $destination_embedding) 
+                YIELD distance, node, similarity
+                WITH node AS destination_candidate, similarity
+                WHERE node.user_id = $user_id 
+                AND node.agent_id = $agent_id 
+                AND similarity >= $threshold
+                RETURN id(destination_candidate);
+                """
+            params = {
+                "destination_embedding": destination_embedding,
+                "user_id": user_id,
+                "agent_id": agent_id,
+                "threshold": threshold,
+            }
+        else:
+            cypher = """
+                CALL vector_search.search("memzero", 1, $destination_embedding) 
+                YIELD distance, node, similarity
+                WITH node AS destination_candidate, similarity
+                WHERE node.user_id = $user_id 
+                AND similarity >= $threshold
+                RETURN id(destination_candidate);
+                """
+            params = {
+                "destination_embedding": destination_embedding,
+                "user_id": user_id,
+                "threshold": threshold,
+            }

        result = self.graph.query(cypher, params=params)
        return result
@@ -5,8 +5,7 @@ from typing import Any, Dict, List, Optional, Union
 from pydantic import BaseModel

 try:
-    from pinecone import Pinecone, PodSpec, ServerlessSpec
-    from pinecone.data.dataclasses.vector import Vector
+    from pinecone import Pinecone, PodSpec, ServerlessSpec, Vector
 except ImportError:
    raise ImportError(
        "Pinecone requires extra dependencies. Install with `pip install pinecone pinecone-text`"
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "mem0ai"
-version = "0.1.108"
+version = "0.1.109"
 description = "Long-term memory for AI Agents"
 authors = [
    { name = "Mem0", email = "founders@mem0.ai" }
@@ -43,6 +43,8 @@ llms = [
    "ollama>=0.1.0",
    "vertexai>=0.1.0",
    "google-generativeai>=0.3.0",
+    "google-genai>=1.0.0",
+    
 ]
 extras = [
    "boto3>=1.34.0",
@@ -42,3 +42,30 @@ def test_generate_response_without_tools(mock_lm_studio_client):
    )

    assert response == "I'm doing well, thank you for asking!"
+
+def test_generate_response_specifying_response_format(mock_lm_studio_client):
+    config = BaseLlmConfig(
+        model="lmstudio-community/Meta-Llama-3.1-8B-Instruct-GGUF/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf",
+        temperature=0.7,
+        max_tokens=100,
+        top_p=1.0,
+        lmstudio_response_format={"type": "json_schema"},  # Specifying the response format in config
+    )
+    llm = LMStudioLLM(config)
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Hello, how are you?"},
+    ]
+
+    response = llm.generate_response(messages)
+
+    mock_lm_studio_client.chat.completions.create.assert_called_once_with(
+        model="lmstudio-community/Meta-Llama-3.1-8B-Instruct-GGUF/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf",
+        messages=messages,
+        temperature=0.7,
+        max_tokens=100,
+        top_p=1.0,
+        response_format={"type": "json_schema"},
+    )
+
+    assert response == "I'm doing well, thank you for asking!"
@@ -1,6 +1,6 @@
 {
  "name": "@mem0/vercel-ai-provider",
-  "version": "1.0.4",
+  "version": "1.0.6",
  "description": "Vercel AI Provider for providing memory to LLMs",
  "main": "./dist/index.js",
  "module": "./dist/index.mjs",
@@ -28,6 +28,7 @@
  "dependencies": {
    "@ai-sdk/anthropic": "1.1.12",
    "@ai-sdk/cohere": "1.1.12",
+    "@ai-sdk/google": "1.2.18",
    "@ai-sdk/groq": "1.1.11",
    "@ai-sdk/openai": "1.1.15",
    "@ai-sdk/provider": "1.0.9",
@@ -14,6 +14,9 @@ importers:
      '@ai-sdk/cohere':
        specifier: 1.1.12
        version: 1.1.12(zod@3.24.2)
+      '@ai-sdk/google':
+        specifier: 1.2.18
+        version: 1.2.18(zod@3.24.2)
      '@ai-sdk/groq':
        specifier: 1.1.11
        version: 1.1.11(zod@3.24.2)
@@ -84,6 +87,12 @@ packages:
    peerDependencies:
      zod: ^3.0.0

+  '@ai-sdk/google@1.2.18':
+    resolution: {integrity: sha512-8B70+i+uB12Ae6Sn6B9Oc6W0W/XorGgc88Nx0pyUrcxFOdytHBaAVhTPqYsO3LLClfjYN8pQ9GMxd5cpGEnUcA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.0.0
+
  '@ai-sdk/groq@1.1.11':
    resolution: {integrity: sha512-Y5WUyWuxkQarl4AVGeIMbNSp4/XiwW/mxp9SKeagfDhflVnQHd2ggISVD6HiOBQhznusITjWYYC66DJeBn0v6A==}
    engines: {node: '>=18'}
@@ -105,10 +114,20 @@ packages:
      zod:
        optional: true

+  '@ai-sdk/provider-utils@2.2.8':
+    resolution: {integrity: sha512-fqhG+4sCVv8x7nFzYnFo19ryhAa3w096Kmc3hWxMQfW/TubPOmt3A6tYZhl4mUfQWWQMsuSkLrtjlWuXBVSGQA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.23.8
+
  '@ai-sdk/provider@1.0.9':
    resolution: {integrity: sha512-jie6ZJT2ZR0uVOVCDc9R2xCX5I/Dum/wEK28lx21PJx6ZnFAN9EzD2WsPhcDWfCgGx3OAZZ0GyM3CEobXpa9LA==}
    engines: {node: '>=18'}

+  '@ai-sdk/provider@1.1.3':
+    resolution: {integrity: sha512-qZMxYJ0qqX/RfnuIaab+zp8UAeJn/ygXXAffR5I4N0n1IrvA6qBsjc8hXLmBiMV2zoXlifkacF7sEFnYnjBcqg==}
+    engines: {node: '>=18'}
+
  '@ai-sdk/react@1.1.18':
    resolution: {integrity: sha512-2wlWug6NVAc8zh3pgqtvwPkSNTdA6Q4x9CmrNXCeHcXfJkJ+MuHFQz/I7Wb7mLRajf0DAxsFLIhHyBCEuTkDNw==}
    engines: {node: '>=18'}
@@ -2751,6 +2770,12 @@ snapshots:
      '@ai-sdk/provider-utils': 2.1.10(zod@3.24.2)
      zod: 3.24.2

+  '@ai-sdk/google@1.2.18(zod@3.24.2)':
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      '@ai-sdk/provider-utils': 2.2.8(zod@3.24.2)
+      zod: 3.24.2
+
  '@ai-sdk/groq@1.1.11(zod@3.24.2)':
    dependencies:
      '@ai-sdk/provider': 1.0.9
@@ -2772,10 +2797,21 @@ snapshots:
    optionalDependencies:
      zod: 3.24.2

+  '@ai-sdk/provider-utils@2.2.8(zod@3.24.2)':
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      nanoid: 3.3.11
+      secure-json-parse: 2.7.0
+      zod: 3.24.2
+
  '@ai-sdk/provider@1.0.9':
    dependencies:
      json-schema: 0.4.0

+  '@ai-sdk/provider@1.1.3':
+    dependencies:
+      json-schema: 0.4.0
+
  '@ai-sdk/react@1.1.18(react@19.1.0)(zod@3.24.2)':
    dependencies:
      '@ai-sdk/provider-utils': 2.1.10(zod@3.24.2)
@@ -28,6 +28,7 @@ export interface Mem0ConfigSettings {
  rerank?: boolean;
  enable_graph?: boolean;
  output_format?: string;
+  filter_memories?: boolean;
 }

 export interface Mem0ChatConfig extends Mem0ConfigSettings, Mem0ProviderSettings {}
Author	SHA1	Message	Date
Prateek ChhikaraandGitHub	cdee6a4ff0	Enhance update method to support metadata (#2976 )	2025-06-18 10:07:18 -07:00
Dev KhantandGitHub	9eb4e77c75	Fix pinecone for async memory (#2975 )	2025-06-18 01:37:45 +05:30
Akshat JainandGitHub	c700d790db	Fix Build CI Failure (#2973 )	2025-06-17 09:39:19 -07:00
Antaripa SahaandGitHub	a90b572389	Memory agent powered by voice (Cartesia + Agno) (#2970 )	2025-06-17 18:54:53 +05:30
i-sunandGitHub	62c330e5b3	feat(LM Studio): Add response_format param for LM Studio to config (#2502 )	2025-06-17 17:55:18 +05:30
Akshat JainandGitHub	c70dc7614b	Fix: Add Google Genai library support (#2941 )	2025-06-17 17:47:09 +05:30
Fenil FalduandGitHub	e0003247c3	feat: add AgentOps integration (#2898 )	2025-06-17 11:38:39 +05:30
Saket AryanandGitHub	888ee766c5	TS SDK - filter memories param (#2971 )	2025-06-17 10:54:35 +05:30
Saket AryanandGitHub	c7e91171a0	Added Param `output_format` in AI SDK (#2960 )	2025-06-15 06:42:56 +05:30