mem-brain-mcp 1.0.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

mem_brain_mcp/client.py

@@ -1,7 +1,7 @@
 """HTTP client for Mem-Brain API."""
 
 import logging
-from typing import List, Optional, Dict, Any
+from typing import List, Optional, Dict, Any, Union
 import httpx
 
 from mem_brain_mcp.config import settings
@@ -34,12 +34,7 @@ class APIClient:
             logger.debug("No authentication token configured for this client instance")
         return headers
 
-    async def _request(
-        self,
-        method: str,
-        endpoint: str,
-        **kwargs
-    ) -> Dict[str, Any]:
+    async def _request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
         """Make HTTP request to API.
 
         Args:
@@ -56,10 +51,12 @@ class APIClient:
         url = f"{self.base_url}/{endpoint.lstrip('/')}"
         headers = self._get_headers()
         headers.update(kwargs.pop("headers", {}))
-        
+
         # Debug logging for request details
         logger.debug(f"Making {method} request to: {url}")
-        logger.debug(f"Headers: {dict((k, v[:20] + '...' if k == 'Authorization' and len(v) > 20 else v) for k, v in headers.items())}")
+        logger.debug(
+            f"Headers: {dict((k, v[:20] + '...' if k == 'Authorization' and len(v) > 20 else v) for k, v in headers.items())}"
+        )
         if kwargs.get("json"):
             logger.debug(f"Request body: {kwargs.get('json')}")
         if kwargs.get("params"):
@@ -67,33 +64,29 @@ class APIClient:
 
         async with httpx.AsyncClient(timeout=30.0) as client:
             try:
-                response = await client.request(
-                    method=method,
-                    url=url,
-                    headers=headers,
-                    **kwargs
-                )
+                response = await client.request(method=method, url=url, headers=headers, **kwargs)
                 logger.debug(f"Response status: {response.status_code}")
                 logger.debug(f"Response headers: {dict(response.headers)}")
-                
+
                 try:
                     response.raise_for_status()
                     result = response.json()
-                    logger.debug(f"Response data keys: {list(result.keys()) if isinstance(result, dict) else 'N/A'}")
+                    logger.debug(
+                        f"Response data keys: {list(result.keys()) if isinstance(result, dict) else 'N/A'}"
+                    )
                     return result
                 except httpx.HTTPStatusError as e:
                     error_detail = e.response.text if e.response else "No response body"
-                    logger.error(f"API request failed: {e.request.method} {e.request.url} - {e.response.status_code}: {error_detail}")
+                    logger.error(
+                        f"API request failed: {e.request.method} {e.request.url} - {e.response.status_code}: {error_detail}"
+                    )
                     raise
             except httpx.RequestError as e:
                 logger.error(f"Request error: {type(e).__name__}: {str(e)}")
                 raise
 
     async def add_memory(
-        self,
-        content: str,
-        tags: Optional[List[str]] = None,
-        category: Optional[str] = None
+        self, content: str, tags: Optional[List[str]] = None, category: Optional[str] = None
     ) -> Dict[str, Any]:
         """Add a new memory.
 
@@ -114,26 +107,24 @@ class APIClient:
         return await self._request("POST", "/memories", json=data)
 
     async def search_memories(
-        self,
-        query: str,
-        k: int = 5
+        self, query: str, k: int = 5, keyword_filter: Optional[Union[str, List[str]]] = None
     ) -> Dict[str, Any]:
         """Search memories using semantic similarity.
 
         Args:
             query: Search query string
             k: Number of results to return (1-100)
+            keyword_filter: Optional keyword/tag filter (regex supported)
 
         Returns:
             Search results
         """
         data = {"query": query, "k": k}
+        if keyword_filter:
+            data["keyword_filter"] = keyword_filter
         return await self._request("POST", "/memories/search", json=data)
 
-    async def get_memories(
-        self,
-        memory_ids: List[str]
-    ) -> Dict[str, Any]:
+    async def get_memories(self, memory_ids: List[str]) -> Dict[str, Any]:
         """Retrieve multiple memories by ID.
 
         Args:
@@ -146,10 +137,7 @@ class APIClient:
         return await self._request("POST", "/memories/batch", json=data)
 
     async def update_memory(
-        self,
-        memory_id: str,
-        content: Optional[str] = None,
-        tags: Optional[List[str]] = None
+        self, memory_id: str, content: Optional[str] = None, tags: Optional[List[str]] = None
     ) -> Dict[str, Any]:
         """Update an existing memory.
 
@@ -173,7 +161,7 @@ class APIClient:
         self,
         memory_id: Optional[str] = None,
         tags: Optional[str] = None,
-        category: Optional[str] = None
+        category: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Delete memories by ID or filter.
 
@@ -195,11 +183,7 @@ class APIClient:
 
         return await self._request("DELETE", "/memories/bulk", params=params)
 
-    async def unlink_memories(
-        self,
-        memory_id_1: str,
-        memory_id_2: str
-    ) -> Dict[str, Any]:
+    async def unlink_memories(self, memory_id_1: str, memory_id_2: str) -> Dict[str, Any]:
         """Remove link between two memories.
 
         Args:
@@ -209,10 +193,7 @@ class APIClient:
         Returns:
             Unlink response
         """
-        data = {
-            "memory_id_1": memory_id_1,
-            "memory_id_2": memory_id_2
-        }
+        data = {"memory_id_1": memory_id_1, "memory_id_2": memory_id_2}
         return await self._request("POST", "/memories/unlink", json=data)
 
     async def get_stats(self) -> Dict[str, Any]:
@@ -224,11 +205,7 @@ class APIClient:
         logger.debug("get_stats() called - making request to /stats endpoint")
         return await self._request("GET", "/stats")
 
-    async def find_path(
-        self,
-        from_id: str,
-        to_id: str
-    ) -> Dict[str, Any]:
+    async def find_path(self, from_id: str, to_id: str) -> Dict[str, Any]:
         """Find shortest path between two memories.
 
         Args:
@@ -241,11 +218,7 @@ class APIClient:
         params = {"from_id": from_id, "to_id": to_id}
         return await self._request("GET", "/graph/path", params=params)
 
-    async def get_neighborhood(
-        self,
-        memory_id: str,
-        hops: int = 2
-    ) -> Dict[str, Any]:
+    async def get_neighborhood(self, memory_id: str, hops: int = 2) -> Dict[str, Any]:
         """Get all memories within N hops of a given memory.
 
         Args:
@@ -257,4 +230,3 @@ class APIClient:
         """
         params = {"memory_id": memory_id, "hops": hops}
         return await self._request("GET", "/graph/neighborhood", params=params)
-