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

mem_brain_mcp/__init__.py

@@ -1,4 +1,4 @@
 """Mem-Brain MCP Server - Exposes Mem-Brain API as MCP tools."""
 
-__version__ = "1.0.5"
+__version__ = "1.0.6"
 

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:
@@ -57,26 +52,41 @@ class APIClient:
         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())}"
+        )
+        if kwargs.get("json"):
+            logger.debug(f"Request body: {kwargs.get('json')}")
+        if kwargs.get("params"):
+            logger.debug(f"Request params: {kwargs.get('params')}")
+
         async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.request(
-                method=method,
-                url=url,
-                headers=headers,
-                **kwargs
-            )
             try:
-                response.raise_for_status()
-                return response.json()
-            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}")
+                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'}"
+                    )
+                    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}"
+                    )
+                    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.
 
@@ -97,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:
@@ -129,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.
 
@@ -156,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.
 
@@ -178,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:
@@ -192,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]:
@@ -204,13 +202,10 @@ class APIClient:
         Returns:
             Statistics response
         """
+        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:
@@ -223,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:
@@ -239,4 +230,3 @@ class APIClient:
         """
         params = {"memory_id": memory_id, "hops": hops}
         return await self._request("GET", "/graph/neighborhood", params=params)
-