From aa7742c5adabf05376b02ed450962658e023e1a5 Mon Sep 17 00:00:00 2001 From: Pratik Narola Date: Tue, 2 Sep 2025 17:28:41 +0000 Subject: [PATCH] Added support for run id agent id --- backend/mem0_manager.py | 54 ++++++++++++++++++++++------------------- 1 file changed, 29 insertions(+), 25 deletions(-) diff --git a/backend/mem0_manager.py b/backend/mem0_manager.py index 4dc618a..194e53a 100644 --- a/backend/mem0_manager.py +++ b/backend/mem0_manager.py @@ -32,10 +32,10 @@ class Mem0Manager: "embedder": { "provider": "ollama", "config": { - "model": "hf.co/Qwen/Qwen3-Embedding-0.6B-GGUF:Q8_0", + "model": "hf.co/Qwen/Qwen3-Embedding-8B-GGUF:Q8_0", # "api_key": settings.embedder_api_key, "ollama_base_url": "http://host.docker.internal:11434", - "embedding_dims": 1024 + "embedding_dims": 4096 } }, "vector_store": { @@ -46,7 +46,7 @@ class Mem0Manager: "password": settings.postgres_password, "host": settings.postgres_host, "port": settings.postgres_port, - "embedding_model_dims": 1024 + "embedding_model_dims": 4096 } }, "graph_store": { @@ -69,7 +69,6 @@ class Mem0Manager: # Pure passthrough methods - no custom logic - @timed("add_memories") async def add_memories( self, @@ -91,12 +90,9 @@ class Mem0Manager: # Direct Mem0 add with metadata support combined_metadata = metadata or {} - if agent_id: - combined_metadata["agent_id"] = agent_id - if run_id: - combined_metadata["run_id"] = run_id - - result = self.memory.add(formatted_messages, user_id=user_id, metadata=combined_metadata if combined_metadata else None) + result = self.memory.add(formatted_messages, user_id=user_id, + agent_id=agent_id, run_id=run_id, + metadata=combined_metadata if combined_metadata else None) return { "added_memories": result if isinstance(result, list) else [result], @@ -115,19 +111,19 @@ class Mem0Manager: limit: int = 5, threshold: Optional[float] = None, filters: Optional[Dict[str, Any]] = None, - keyword_search: bool = False, - rerank: bool = False, - filter_memories: bool = False, + # keyword_search: bool = False, + # rerank: bool = False, + # filter_memories: bool = False, agent_id: Optional[str] = None, run_id: Optional[str] = None ) -> Dict[str, Any]: - """Search memories - native Mem0 pattern (5 lines vs 70).""" + """Search memories - native Mem0 pattern""" try: # Minimal empty query protection for API compatibility if not query or query.strip() == "": return {"memories": [], "total_count": 0, "query": query, "note": "Empty query provided, no results returned. Use a specific query to search memories."} # Direct Mem0 search - trust native handling - result = self.memory.search(query=query, user_id=user_id, limit=limit) + result = self.memory.search(query=query, user_id=user_id, agent_id=agent_id, run_id=run_id, limit=limit, threshold=threshold, filters=filters) return {"memories": result.get("results", []), "total_count": len(result.get("results", [])), "query": query} except Exception as e: logger.error(f"Error searching memories: {e}") @@ -144,7 +140,7 @@ class Mem0Manager: """Get all memories for a user - native Mem0 pattern.""" try: # Direct Mem0 get_all call - trust native parameter handling - result = self.memory.get_all(user_id=user_id, limit=limit) + result = self.memory.get_all(user_id=user_id, limit=limit, agent_id=agent_id, run_id=run_id, filters=filters) return result.get("results", []) except Exception as e: logger.error(f"Error getting user memories: {e}") @@ -176,8 +172,8 @@ class Mem0Manager: except Exception as e: logger.error(f"Error deleting memory: {e}") raise e - - async def delete_user_memories(self, user_id: str) -> Dict[str, Any]: + + async def delete_user_memories(self, user_id: Optional[str]) -> Dict[str, Any]: """Delete all user memories - pure Mem0 passthrough.""" try: self.memory.delete_all(user_id=user_id) @@ -198,14 +194,16 @@ class Mem0Manager: except Exception as e: logger.error(f"Error getting memory history: {e}") raise e - - - async def get_graph_relationships(self, user_id: str) -> Dict[str, Any]: + + + async def get_graph_relationships(self, user_id: Optional[str], agent_id: Optional[str], run_id: Optional[str]) -> Dict[str, Any]: """Get graph relationships - using correct Mem0 get_all() method.""" try: # Use get_all() to retrieve memories with graph relationships result = self.memory.get_all( user_id=user_id, + agent_id=agent_id, + run_id=run_id, limit=50 ) @@ -231,6 +229,8 @@ class Mem0Manager: "relationships": relationships, "entities": entities, "user_id": user_id, + "agent_id": agent_id, + "run_id": run_id, "total_memories": len(result.get("results", [])), "total_relationships": len(relationships) } @@ -242,6 +242,8 @@ class Mem0Manager: "relationships": [], "entities": [], "user_id": user_id, + "agent_id": agent_id, + "run_id": run_id, "total_memories": 0, "total_relationships": 0, "error": str(e) @@ -251,14 +253,16 @@ class Mem0Manager: async def chat_with_memory( self, message: str, - user_id: str = "default", - context: Optional[List[Dict[str, str]]] = None, - metadata: Optional[Dict[str, Any]] = None + user_id: Optional[str] = None, + agent_id: Optional[str] = None, + run_id: Optional[str] = None, + # context: Optional[List[Dict[str, str]]] = None, + # metadata: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: """Chat with memory - native Mem0 pattern (15 lines vs 95).""" try: # Retrieve relevant memories using direct Mem0 search - search_result = self.memory.search(query=message, user_id=user_id, limit=3) + search_result = self.memory.search(query=message, user_id=user_id, agent_id=agent_id, run_id=run_id, limit=10, threshold=0.3) relevant_memories = search_result.get("results", []) memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories)