feat: per-agent memory isolation for openclaw-mem0 plugin

Co-authored-by: deshraj <2945708+deshraj@users.noreply.github.com>

mem0-ts/src/oss/src/embeddings/ollama.ts

@@ -27,12 +27,9 @@ export class OllamaEmbedder implements Embedder {
     } catch (err) {
       logger.error(`Error ensuring model exists: ${err}`);
     }
-    // Ollama's Go server requires prompt to be a string. Coerce defensively
-    // since callers may pass values parsed from untrusted LLM JSON output.
-    const prompt = typeof text === "string" ? text : JSON.stringify(text);
     const response = await this.ollama.embeddings({
       model: this.model,
-      prompt,
+      prompt: text,
     });
     return response.embedding;
   }

mem0-ts/src/oss/src/memory/index.ts

@@ -15,7 +15,6 @@ import {
   HistoryManagerFactory,
 } from "../utils/factory";
 import {
-  FactRetrievalSchema,
   getFactRetrievalMessages,
   getUpdateMemoryMessages,
   parseMessages,
@@ -262,8 +261,7 @@ export class Memory {
     const cleanResponse = removeCodeBlocks(response as string);
     let facts: string[] = [];
     try {
-      const parsed = FactRetrievalSchema.parse(JSON.parse(cleanResponse));
-      facts = parsed.facts;
+      facts = JSON.parse(cleanResponse).facts || [];
     } catch (e) {
       console.error(
         "Failed to parse facts from LLM response:",

mem0-ts/src/oss/src/prompts/index.ts

@@ -1,18 +1,9 @@
 import { z } from "zod";
 
-// Accepts a string directly, or an object with a "fact" or "text" key
-// (common malformed shapes from smaller LLMs like llama3.1:8b).
-const factItem = z.union([
-  z.string(),
-  z.object({ fact: z.string() }).transform((o) => o.fact),
-  z.object({ text: z.string() }).transform((o) => o.text),
-]);
-
 // Define Zod schema for fact retrieval output
 export const FactRetrievalSchema = z.object({
   facts: z
-    .array(factItem)
-    .transform((arr) => arr.filter((s) => s.length > 0))
+    .array(z.string())
     .describe("An array of distinct facts extracted from the conversation."),
 });
 

mem0/vector_stores/qdrant.py

@@ -1,16 +1,12 @@
 import logging
 import os
 import shutil
-from typing import Optional
 
 from qdrant_client import QdrantClient
 from qdrant_client.models import (
     Distance,
     FieldCondition,
     Filter,
-    MatchAny,
-    MatchExcept,
-    MatchText,
     MatchValue,
     PointIdsList,
     PointStruct,
@@ -142,139 +138,26 @@ class Qdrant(VectorStoreBase):
         ]
         self.client.upsert(collection_name=self.collection_name, points=points)
 
-    def _build_field_condition(self, key: str, value) -> Optional[FieldCondition]:
-        """
-        Build a single FieldCondition from a key-value filter pair.
-
-        Supports the enhanced filter syntax documented at
-        https://docs.mem0.ai/open-source/features/metadata-filtering
-
-        Args:
-            key (str): The payload field name.
-            value: A scalar for simple equality, or a dict with one operator key.
-
-        Returns:
-            Optional[FieldCondition]: The Qdrant field condition, or None if the
-            value is the wildcard '*' (match any / field exists — skip filter).
-        """
-        if not isinstance(value, dict):
-            if value == "*":
-                # Wildcard: match any value. Qdrant has no direct "field exists"
-                # condition via FieldCondition, so we skip this filter (match all).
-                return None
-            # Simple equality: {"field": "value"}
-            return FieldCondition(key=key, match=MatchValue(value=value))
-
-        ops = set(value.keys())
-        range_ops = {"gt", "gte", "lt", "lte"}
-        non_range_ops = ops - range_ops
-
-        if ops & range_ops:
-            if non_range_ops:
-                raise ValueError(
-                    f"Cannot mix range operators ({ops & range_ops}) with "
-                    f"non-range operators ({non_range_ops}) for field '{key}'. "
-                    f"Use AND to combine them as separate conditions."
-                )
-            range_kwargs = {op: value[op] for op in range_ops if op in value}
-            return FieldCondition(key=key, range=Range(**range_kwargs))
-        elif "eq" in value:
-            return FieldCondition(key=key, match=MatchValue(value=value["eq"]))
-        elif "ne" in value:
-            return FieldCondition(key=key, match=MatchExcept(**{"except": [value["ne"]]}))
-        elif "in" in value:
-            return FieldCondition(key=key, match=MatchAny(any=value["in"]))
-        elif "nin" in value:
-            return FieldCondition(key=key, match=MatchExcept(**{"except": value["nin"]}))
-        elif "contains" in value or "icontains" in value:
-            # MatchText: with a full-text index, tokenized matching (all words must appear).
-            # Without a full-text index, exact substring match.
-            op = "icontains" if "icontains" in value else "contains"
-            text = value[op]
-            if op == "icontains":
-                logger.debug(
-                    "icontains on field '%s': Qdrant MatchText case sensitivity depends on "
-                    "full-text index configuration. Without a full-text index this behaves "
-                    "as a case-sensitive substring match (same as 'contains').",
-                    key,
-                )
-            return FieldCondition(key=key, match=MatchText(text=text))
-        else:
-            supported = {"eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "contains", "icontains"}
-            raise ValueError(
-                f"Unsupported filter operator(s) for field '{key}': {ops}. "
-                f"Supported operators: {supported}"
-            )
-
-    def _create_filter(self, filters: dict) -> Optional[Filter]:
+    def _create_filter(self, filters: dict) -> Filter:
         """
         Create a Filter object from the provided filters.
 
-        Supports the enhanced filter syntax with comparison operators (eq, ne,
-        gt, gte, lt, lte), list operators (in, nin), string operators (contains,
-        icontains), and logical operators (AND, OR, NOT).
-
         Args:
             filters (dict): Filters to apply.
 
         Returns:
-            Filter: The created Filter object, or None if filters is empty.
+            Filter: The created Filter object.
         """
         if not filters:
             return None
-
-        # Normalize $or/$not/$and → OR/NOT/AND and deduplicate.
-        # Memory._process_metadata_filters() renames OR→$or and NOT→$not,
-        # but effective_filters retains the original OR/NOT keys from
-        # deepcopy(input_filters).  Without dedup the same sub-conditions
-        # would be evaluated twice.
-        key_map = {"$or": "OR", "$not": "NOT", "$and": "AND"}
-        normalized = {}
+            
+        conditions = []
         for key, value in filters.items():
-            norm_key = key_map.get(key, key)
-            if norm_key not in normalized:
-                normalized[norm_key] = value
-
-        must = []
-        should = []
-        must_not = []
-
-        for key, value in normalized.items():
-            if key in ("AND", "OR", "NOT"):
-                if not isinstance(value, list):
-                    raise ValueError(
-                        f"{key} filter value must be a list of filter dicts, "
-                        f"got {type(value).__name__}"
-                    )
-
-            if key == "AND":
-                for sub in value:
-                    built = self._create_filter(sub)
-                    if built:
-                        must.append(built)
-            elif key == "OR":
-                for sub in value:
-                    built = self._create_filter(sub)
-                    if built:
-                        should.append(built)
-            elif key == "NOT":
-                for sub in value:
-                    built = self._create_filter(sub)
-                    if built:
-                        must_not.append(built)
+            if isinstance(value, dict) and "gte" in value and "lte" in value:
+                conditions.append(FieldCondition(key=key, range=Range(gte=value["gte"], lte=value["lte"])))
             else:
-                condition = self._build_field_condition(key, value)
-                if condition is not None:
-                    must.append(condition)
-
-        if not any([must, should, must_not]):
-            return None
-
-        return Filter(
-            must=must or None,
-            should=should or None,
-            must_not=must_not or None,
-        )
+                conditions.append(FieldCondition(key=key, match=MatchValue(value=value)))
+        return Filter(must=conditions) if conditions else None
 
     def search(self, query: str, vectors: list, limit: int = 5, filters: dict = None) -> list:
         """

openclaw/index.ts

@@ -268,17 +268,9 @@ class OSSProvider implements Mem0Provider {
     if (options.keyword_search != null) opts.keyword_search = options.keyword_search;
     if (options.reranking != null) opts.reranking = options.reranking;
     if (options.source) opts.source = options.source;
-    if (options.threshold != null) opts.threshold = options.threshold;
 
     const results = await this.memory.search(query, opts);
-    const normalized = normalizeSearchResults(results);
-
-    // Filter results by threshold if specified (client-side filtering as fallback)
-    if (options.threshold != null) {
-      return normalized.filter(item => (item.score ?? 0) >= options.threshold!);
-    }
-
-    return normalized;
+    return normalizeSearchResults(results);
   }
 
   async get(memoryId: string): Promise<MemoryItem> {
@@ -624,6 +616,22 @@ const memoryPlugin = {
     // Track current session ID for tool-level session scoping
     let currentSessionId: string | undefined;
 
+    // Track current agent ID for per-agent memory isolation
+    let currentAgentId: string | undefined;
+
+    // Helper: extract agentId from session key (pattern: agent:<agentId>:...)
+    // Returns undefined for the "main" agent to preserve default behavior.
+    function extractAgentId(sessionKey: string): string | undefined {
+      const match = sessionKey.match(/^agent:([^:]+):/);
+      return match && match[1] !== "main" ? match[1] : undefined;
+    }
+
+    // Helper: get effective userId for Mem0 operations.
+    // Precedence: explicit override > current agentId (non-main) > configured userId.
+    function effectiveUserId(userIdOverride?: string): string {
+      return userIdOverride || currentAgentId || cfg.userId;
+    }
+
     api.logger.info(
       `openclaw-mem0: registered (mode: ${cfg.mode}, user: ${cfg.userId}, graph: ${cfg.enableGraph}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture})`,
     );
@@ -631,7 +639,7 @@ const memoryPlugin = {
     // Helper: build add options
     function buildAddOptions(userIdOverride?: string, runId?: string): AddOptions {
       const opts: AddOptions = {
-        user_id: userIdOverride || cfg.userId,
+        user_id: effectiveUserId(userIdOverride),
         source: "OPENCLAW",
       };
       if (runId) opts.run_id = runId;
@@ -651,7 +659,7 @@ const memoryPlugin = {
       runId?: string,
     ): SearchOptions {
       const opts: SearchOptions = {
-        user_id: userIdOverride || cfg.userId,
+        user_id: effectiveUserId(userIdOverride),
         top_k: limit ?? cfg.topK,
         limit: limit ?? cfg.topK,
         threshold: cfg.searchThreshold,
@@ -943,7 +951,7 @@ const memoryPlugin = {
 
           try {
             let memories: MemoryItem[] = [];
-            const uid = userId || cfg.userId;
+            const uid = effectiveUserId(userId);
 
             if (scope === "session") {
               if (currentSessionId) {
@@ -1244,9 +1252,12 @@ const memoryPlugin = {
       api.on("before_agent_start", async (event, ctx) => {
         if (!event.prompt || event.prompt.length < 5) return;
 
-        // Track session ID
+        // Track session ID and agent ID
         const sessionId = (ctx as any)?.sessionKey ?? undefined;
-        if (sessionId) currentSessionId = sessionId;
+        if (sessionId) {
+          currentSessionId = sessionId;
+          currentAgentId = extractAgentId(sessionId);
+        }
 
         try {
           // Search long-term memories (user-scoped)
@@ -1311,9 +1322,12 @@ const memoryPlugin = {
           return;
         }
 
-        // Track session ID
+        // Track session ID and agent ID
         const sessionId = (ctx as any)?.sessionKey ?? undefined;
-        if (sessionId) currentSessionId = sessionId;
+        if (sessionId) {
+          currentSessionId = sessionId;
+          currentAgentId = extractAgentId(sessionId);
+        }
 
         try {
           // Extract messages, limiting to last 10

tests/vector_stores/test_qdrant.py

@@ -5,15 +5,9 @@ from unittest.mock import MagicMock
 from qdrant_client import QdrantClient
 from qdrant_client.models import (
     Distance,
-    FieldCondition,
     Filter,
-    MatchAny,
-    MatchExcept,
-    MatchText,
-    MatchValue,
     PointIdsList,
     PointStruct,
-    Range,
     VectorParams,
 )
 
@@ -304,433 +298,3 @@ class TestQdrant(unittest.TestCase):
 
     def tearDown(self):
         del self.qdrant
-
-
-class TestQdrantEnhancedFilters(unittest.TestCase):
-    """Tests for enhanced metadata filtering operators (issue #3975)."""
-
-    def setUp(self):
-        self.client_mock = MagicMock(spec=QdrantClient)
-        self.qdrant = Qdrant(
-            collection_name="test_collection",
-            embedding_model_dims=128,
-            client=self.client_mock,
-        )
-
-    # ------------------------------------------------------------------ #
-    # _build_field_condition                                               #
-    # ------------------------------------------------------------------ #
-
-    def test_simple_equality(self):
-        """Plain value maps to MatchValue."""
-        cond = self.qdrant._build_field_condition("category", "programming")
-        self.assertIsInstance(cond, FieldCondition)
-        self.assertEqual(cond.key, "category")
-        self.assertIsInstance(cond.match, MatchValue)
-        self.assertEqual(cond.match.value, "programming")
-
-    def test_eq_operator(self):
-        """{\"eq\": v} maps to MatchValue."""
-        cond = self.qdrant._build_field_condition("category", {"eq": "programming"})
-        self.assertIsInstance(cond.match, MatchValue)
-        self.assertEqual(cond.match.value, "programming")
-
-    def test_ne_operator(self):
-        """{\"ne\": v} maps to MatchExcept with a single-element list."""
-        cond = self.qdrant._build_field_condition("category", {"ne": "spam"})
-        self.assertIsInstance(cond.match, MatchExcept)
-        self.assertIn("spam", getattr(cond.match, "except_", None) or getattr(cond.match, "except"))
-
-    def test_in_operator(self):
-        """{\"in\": [...]} maps to MatchAny."""
-        cond = self.qdrant._build_field_condition("category", {"in": ["a", "b", "c"]})
-        self.assertIsInstance(cond.match, MatchAny)
-        self.assertEqual(cond.match.any, ["a", "b", "c"])
-
-    def test_nin_operator(self):
-        """{\"nin\": [...]} maps to MatchExcept."""
-        cond = self.qdrant._build_field_condition("status", {"nin": ["deleted", "banned"]})
-        self.assertIsInstance(cond.match, MatchExcept)
-        excluded = getattr(cond.match, "except_", None) or getattr(cond.match, "except")
-        self.assertIn("deleted", excluded)
-        self.assertIn("banned", excluded)
-
-    def test_contains_operator(self):
-        """{\"contains\": x} maps to MatchText."""
-        cond = self.qdrant._build_field_condition("bio", {"contains": "python"})
-        self.assertIsInstance(cond.match, MatchText)
-        self.assertEqual(cond.match.text, "python")
-
-    def test_icontains_operator(self):
-        """{\"icontains\": x} maps to MatchText (same as contains for Qdrant)."""
-        cond = self.qdrant._build_field_condition("bio", {"icontains": "Python"})
-        self.assertIsInstance(cond.match, MatchText)
-        self.assertEqual(cond.match.text, "Python")
-
-    def test_gt_operator(self):
-        """{\"gt\": v} maps to Range with gt only."""
-        cond = self.qdrant._build_field_condition("priority", {"gt": 5})
-        self.assertIsInstance(cond.range, Range)
-        self.assertEqual(cond.range.gt, 5)
-        self.assertIsNone(cond.range.gte)
-        self.assertIsNone(cond.range.lt)
-        self.assertIsNone(cond.range.lte)
-
-    def test_gte_operator(self):
-        """{\"gte\": v} maps to Range with gte only."""
-        cond = self.qdrant._build_field_condition("priority", {"gte": 5})
-        self.assertIsInstance(cond.range, Range)
-        self.assertEqual(cond.range.gte, 5)
-        self.assertIsNone(cond.range.gt)
-
-    def test_lt_operator(self):
-        """{\"lt\": v} maps to Range with lt only."""
-        cond = self.qdrant._build_field_condition("priority", {"lt": 10})
-        self.assertIsInstance(cond.range, Range)
-        self.assertEqual(cond.range.lt, 10)
-
-    def test_lte_operator(self):
-        """{\"lte\": v} maps to Range with lte only."""
-        cond = self.qdrant._build_field_condition("priority", {"lte": 10})
-        self.assertIsInstance(cond.range, Range)
-        self.assertEqual(cond.range.lte, 10)
-
-    def test_range_gte_lte(self):
-        """Combined {\"gte\": x, \"lte\": y} maps to Range with both bounds."""
-        cond = self.qdrant._build_field_condition("priority", {"gte": 5, "lte": 10})
-        self.assertIsInstance(cond.range, Range)
-        self.assertEqual(cond.range.gte, 5)
-        self.assertEqual(cond.range.lte, 10)
-
-    def test_range_gt_lt(self):
-        """Open interval {\"gt\": x, \"lt\": y} maps to Range with both bounds."""
-        cond = self.qdrant._build_field_condition("score", {"gt": 0.5, "lt": 0.9})
-        self.assertIsInstance(cond.range, Range)
-        self.assertEqual(cond.range.gt, 0.5)
-        self.assertEqual(cond.range.lt, 0.9)
-
-    # ------------------------------------------------------------------ #
-    # _create_filter — comparison and list operators                       #
-    # ------------------------------------------------------------------ #
-
-    def test_create_filter_eq(self):
-        result = self.qdrant._create_filter({"category": {"eq": "programming"}})
-        self.assertIsInstance(result, Filter)
-        self.assertEqual(len(result.must), 1)
-        self.assertIsInstance(result.must[0].match, MatchValue)
-
-    def test_create_filter_ne(self):
-        result = self.qdrant._create_filter({"category": {"ne": "spam"}})
-        self.assertIsInstance(result, Filter)
-        self.assertIsInstance(result.must[0].match, MatchExcept)
-
-    def test_create_filter_in(self):
-        result = self.qdrant._create_filter({"category": {"in": ["prog", "data"]}})
-        self.assertIsInstance(result, Filter)
-        self.assertIsInstance(result.must[0].match, MatchAny)
-        self.assertEqual(result.must[0].match.any, ["prog", "data"])
-
-    def test_create_filter_nin(self):
-        result = self.qdrant._create_filter({"status": {"nin": ["deleted", "banned"]}})
-        self.assertIsInstance(result, Filter)
-        self.assertIsInstance(result.must[0].match, MatchExcept)
-
-    def test_create_filter_gt(self):
-        result = self.qdrant._create_filter({"priority": {"gt": 7}})
-        self.assertIsInstance(result, Filter)
-        self.assertIsInstance(result.must[0].range, Range)
-        self.assertEqual(result.must[0].range.gt, 7)
-
-    def test_create_filter_gte_lte_range(self):
-        result = self.qdrant._create_filter({"priority": {"gte": 5, "lte": 9}})
-        self.assertIsInstance(result, Filter)
-        r = result.must[0].range
-        self.assertEqual(r.gte, 5)
-        self.assertEqual(r.lte, 9)
-
-    def test_create_filter_contains(self):
-        result = self.qdrant._create_filter({"bio": {"contains": "python"}})
-        self.assertIsInstance(result, Filter)
-        self.assertIsInstance(result.must[0].match, MatchText)
-
-    # ------------------------------------------------------------------ #
-    # _create_filter — logical operators                                   #
-    # ------------------------------------------------------------------ #
-
-    def test_and_operator(self):
-        """AND populates Filter.must with nested Filter objects."""
-        filters = {"AND": [{"category": "programming"}, {"priority": 10}]}
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        self.assertEqual(len(result.must), 2)
-        # Each item is a Filter that wraps a single FieldCondition
-        for item in result.must:
-            self.assertIsInstance(item, Filter)
-
-    def test_or_operator(self):
-        """OR populates Filter.should with nested Filter objects."""
-        filters = {"OR": [{"category": "programming"}, {"category": "data"}]}
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        self.assertEqual(len(result.should), 2)
-        self.assertIsNone(result.must)
-
-    def test_not_operator(self):
-        """NOT populates Filter.must_not with nested Filter objects."""
-        filters = {"NOT": [{"category": "spam"}]}
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        self.assertEqual(len(result.must_not), 1)
-        self.assertIsNone(result.must)
-        self.assertIsNone(result.should)
-
-    def test_mixed_field_and_and(self):
-        """Top-level field conditions and AND can coexist in must."""
-        filters = {
-            "user_id": "alice",
-            "AND": [{"priority": {"gte": 5}}, {"category": "programming"}],
-        }
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        # user_id FieldCondition + 2 nested AND Filters = 3 items in must
-        self.assertEqual(len(result.must), 3)
-
-    def test_nested_and_or(self):
-        """AND containing an OR sub-condition produces correct nesting."""
-        filters = {
-            "AND": [
-                {"OR": [{"category": "prog"}, {"category": "data"}]},
-                {"priority": {"gt": 3}},
-            ]
-        }
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        self.assertEqual(len(result.must), 2)
-        # First item is a Filter with should (the OR)
-        or_filter = result.must[0]
-        self.assertIsInstance(or_filter, Filter)
-        self.assertEqual(len(or_filter.should), 2)
-
-    # ------------------------------------------------------------------ #
-    # Edge cases                                                           #
-    # ------------------------------------------------------------------ #
-
-    def test_empty_filter_returns_none(self):
-        self.assertIsNone(self.qdrant._create_filter({}))
-        self.assertIsNone(self.qdrant._create_filter(None))
-
-    def test_backward_compat_simple_equality(self):
-        """Plain scalar equality still works as before."""
-        result = self.qdrant._create_filter({"user_id": "alice", "run_id": "r1"})
-        self.assertIsInstance(result, Filter)
-        keys = [c.key for c in result.must]
-        self.assertIn("user_id", keys)
-        self.assertIn("run_id", keys)
-
-    def test_backward_compat_gte_lte_range(self):
-        """Original gte+lte range filter still produces a Range condition."""
-        result = self.qdrant._create_filter({"count": {"gte": 5, "lte": 10}})
-        self.assertIsInstance(result, Filter)
-        self.assertIsInstance(result.must[0].range, Range)
-        self.assertEqual(result.must[0].range.gte, 5)
-        self.assertEqual(result.must[0].range.lte, 10)
-
-    def test_unknown_operator_raises_error(self):
-        """Unknown operator dict should raise ValueError, not ValidationError."""
-        with self.assertRaises(ValueError) as ctx:
-            self.qdrant._build_field_condition("field", {"unknown_op": "foo"})
-        self.assertIn("Unsupported", str(ctx.exception))
-
-    def test_mixed_range_and_non_range_raises_error(self):
-        """Mixing range ops with non-range ops should raise ValueError."""
-        with self.assertRaises(ValueError):
-            self.qdrant._build_field_condition("priority", {"gte": 5, "ne": 10})
-
-    def test_mixed_range_and_eq_raises_error(self):
-        """Mixing range ops with eq should raise ValueError."""
-        with self.assertRaises(ValueError):
-            self.qdrant._build_field_condition("score", {"gt": 0.5, "eq": 1.0})
-
-    def test_wildcard_returns_none(self):
-        """Wildcard '*' should return None (skip filter — match any)."""
-        result = self.qdrant._build_field_condition("category", "*")
-        self.assertIsNone(result)
-
-    def test_create_filter_with_wildcard_skips_it(self):
-        """Wildcard fields should be skipped in the final filter."""
-        result = self.qdrant._create_filter({"category": "*", "user_id": "alice"})
-        self.assertIsInstance(result, Filter)
-        self.assertEqual(len(result.must), 1)
-        self.assertEqual(result.must[0].key, "user_id")
-
-    def test_create_filter_only_wildcard_returns_none(self):
-        """Filter with only wildcard should return None."""
-        result = self.qdrant._create_filter({"category": "*"})
-        self.assertIsNone(result)
-
-    def test_and_with_non_list_raises_error(self):
-        """AND with non-list value should raise ValueError."""
-        with self.assertRaises(ValueError):
-            self.qdrant._create_filter({"AND": "not_a_list"})
-
-    def test_or_with_non_list_raises_error(self):
-        """OR with non-list value should raise ValueError."""
-        with self.assertRaises(ValueError):
-            self.qdrant._create_filter({"OR": {"category": "work"}})
-
-    def test_not_with_non_list_raises_error(self):
-        """NOT with non-list value should raise ValueError."""
-        with self.assertRaises(ValueError):
-            self.qdrant._create_filter({"NOT": "invalid"})
-
-    def test_empty_and_list(self):
-        """AND with empty list should return None."""
-        result = self.qdrant._create_filter({"AND": []})
-        self.assertIsNone(result)
-
-    def test_empty_or_list(self):
-        """OR with empty list should return None."""
-        result = self.qdrant._create_filter({"OR": []})
-        self.assertIsNone(result)
-
-    def test_empty_not_list(self):
-        """NOT with empty list should return None."""
-        result = self.qdrant._create_filter({"NOT": []})
-        self.assertIsNone(result)
-
-    def test_deeply_nested_logical(self):
-        """3-level nesting: AND > OR > NOT."""
-        filters = {
-            "AND": [
-                {
-                    "OR": [
-                        {"category": "work"},
-                        {"category": "personal"}
-                    ]
-                },
-                {"priority": {"gte": 5}},
-                {
-                    "NOT": [
-                        {"status": "archived"}
-                    ]
-                }
-            ]
-        }
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        self.assertEqual(len(result.must), 3)
-
-    def test_boolean_equality(self):
-        """Boolean values should work with MatchValue."""
-        cond = self.qdrant._build_field_condition("active", True)
-        self.assertIsInstance(cond.match, MatchValue)
-        self.assertEqual(cond.match.value, True)
-
-    def test_integer_equality(self):
-        """Integer values should work with MatchValue."""
-        cond = self.qdrant._build_field_condition("count", 42)
-        self.assertIsInstance(cond.match, MatchValue)
-        self.assertEqual(cond.match.value, 42)
-
-    def test_eq_with_boolean(self):
-        """eq operator with boolean should work."""
-        cond = self.qdrant._build_field_condition("active", {"eq": False})
-        self.assertIsInstance(cond.match, MatchValue)
-        self.assertEqual(cond.match.value, False)
-
-    def test_in_with_integers(self):
-        """in operator with integer list should use MatchAny."""
-        cond = self.qdrant._build_field_condition("priority", {"in": [1, 2, 3]})
-        self.assertIsInstance(cond.match, MatchAny)
-        self.assertEqual(cond.match.any, [1, 2, 3])
-
-    def test_wildcard_inside_and(self):
-        """Wildcard inside AND should be skipped, other conditions preserved."""
-        result = self.qdrant._create_filter({
-            "AND": [{"category": "*"}, {"user_id": "alice"}]
-        })
-        self.assertIsInstance(result, Filter)
-        # AND produces nested Filters; the wildcard sub-filter returns None and is skipped
-        # Only the user_id sub-filter remains
-        self.assertEqual(len(result.must), 1)
-
-    def test_empty_dict_value_raises_error(self):
-        """Empty dict as filter value should raise ValueError."""
-        with self.assertRaises(ValueError):
-            self.qdrant._build_field_condition("field", {})
-
-    def test_ne_alone_does_not_trigger_mixed_error(self):
-        """ne as sole operator should NOT trigger mixed-operator error (regression guard)."""
-        cond = self.qdrant._build_field_condition("status", {"ne": "deleted"})
-        self.assertIsInstance(cond.match, MatchExcept)
-
-    def test_eq_with_literal_star(self):
-        """eq operator with literal '*' should match the string '*', not wildcard."""
-        cond = self.qdrant._build_field_condition("category", {"eq": "*"})
-        self.assertIsInstance(cond.match, MatchValue)
-        self.assertEqual(cond.match.value, "*")
-
-    # ------------------------------------------------------------------ #
-    # $or / $not normalization (Memory._process_metadata_filters injects  #
-    # these keys alongside the original OR/NOT)                           #
-    # ------------------------------------------------------------------ #
-
-    def test_dollar_or_handled_as_or(self):
-        """$or injected by Memory middleware should be treated as OR."""
-        filters = {
-            "user_id": "alice",
-            "$or": [{"category": "programming"}, {"category": "data"}],
-        }
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        self.assertIsNotNone(result.should)
-        self.assertEqual(len(result.should), 2)
-
-    def test_dollar_not_handled_as_not(self):
-        """$not injected by Memory middleware should be treated as NOT."""
-        filters = {
-            "user_id": "alice",
-            "$not": [{"category": "spam"}],
-        }
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        self.assertIsNotNone(result.must_not)
-        self.assertEqual(len(result.must_not), 1)
-
-    def test_memory_search_or_shape(self):
-        """Simulate exact shape Memory.search() sends for OR filters.
-
-        effective_filters keeps the original OR key (via deepcopy of
-        input_filters) and _process_metadata_filters adds $or with the
-        same content.  _create_filter should deduplicate so only the
-        first occurrence (OR) is used — exactly 2 should entries.
-        """
-        filters = {
-            "OR": [{"category": "programming"}, {"category": "data"}],
-            "user_id": "test_user",
-            "$or": [{"category": "programming"}, {"category": "data"}],
-        }
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        self.assertIsNotNone(result.should)
-        # Deduplicated: OR wins, $or is skipped — exactly 2 entries
-        self.assertEqual(len(result.should), 2)
-
-    def test_memory_search_not_shape(self):
-        """Simulate exact shape Memory.search() sends for NOT filters.
-
-        Same deduplication as OR: NOT wins, $not is skipped.
-        """
-        filters = {
-            "NOT": [{"category": "spam"}],
-            "user_id": "test_user",
-            "$not": [{"category": "spam"}],
-        }
-        result = self.qdrant._create_filter(filters)
-        self.assertIsInstance(result, Filter)
-        self.assertIsNotNone(result.must_not)
-        # Deduplicated: NOT wins, $not is skipped — exactly 1 entry
-        self.assertEqual(len(result.must_not), 1)
-
-    def tearDown(self):
-        del self.qdrant