mem-brain-mcp 1.0.4__tar.gz → 1.0.6__tar.gz

{mem_brain_mcp-1.0.4 → mem_brain_mcp-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mem-brain-mcp
-Version: 1.0.4
+Version: 1.0.6
 Summary: MCP Server for Mem-Brain API - Exposes memory operations as MCP tools
 Keywords: ai,claude,cursor,llm,mcp,memory,model-context-protocol
 Classifier: Development Status :: 4 - Beta

{mem_brain_mcp-1.0.4 → mem_brain_mcp-1.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mem-brain-mcp"
-version = "1.0.4"
+version = "1.0.6"
 description = "MCP Server for Mem-Brain API - Exposes memory operations as MCP tools"
 readme = "README.md"
 requires-python = ">=3.10,<3.14"

{mem_brain_mcp-1.0.4 → mem_brain_mcp-1.0.6}/src/mem_brain_mcp/__init__.py

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

{mem_brain_mcp-1.0.4 → mem_brain_mcp-1.0.6}/src/mem_brain_mcp/client.py

@@ -56,20 +56,37 @@ 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())}")
+        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(
@@ -204,6 +221,7 @@ 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(

{mem_brain_mcp-1.0.4 → mem_brain_mcp-1.0.6}/src/mem_brain_mcp/server.py

@@ -13,6 +13,7 @@ from starlette.responses import JSONResponse
 
 from mem_brain_mcp.client import APIClient
 from mem_brain_mcp.config import settings
+from mem_brain_mcp import __version__
 
 # The comprehensive agent instructions (embedded for MCP distribution)
 AGENT_INSTRUCTIONS = """You are an intelligent assistant with a persistent, evolving memory graph.
@@ -143,12 +144,17 @@ async def _get_api_client() -> APIClient:
     """Get API client with per-request JWT token."""
     token = _get_request_token()
     if token:
-        return APIClient(api_key=token)  # api_key parameter now holds JWT token
+        logger.debug(f"Using JWT token from request headers: {token[:20]}...")
+        client = APIClient(api_key=token)  # api_key parameter now holds JWT token
+        logger.debug(f"API client created with base_url: {client.base_url}")
+        return client
     # Fallback to config API key (for single-user scenarios)
     if settings.api_key:
         logger.debug("Using config API key as fallback")
+        logger.debug(f"API client (fallback) base_url: {api_client.base_url}")
         return api_client  # Global instance
     # No token available
+    logger.error("No authentication token available - neither from headers nor config")
     raise ToolError("No authentication token provided. Please login using the login tool or configure your JWT token in your MCP client headers.")
 
 
@@ -1166,8 +1172,11 @@ async def get_stats(_placeholder: Optional[bool] = None) -> str:
     # The function actually takes no parameters, but some MCP clients incorrectly require one
     try:
         logger.info("get_stats called")
+        logger.debug(f"get_stats called with _placeholder={_placeholder} (ignored)")
         client = await _get_api_client()
+        logger.debug(f"API client initialized with base_url: {client.base_url}")
         result = await client.get_stats()
+        logger.debug(f"get_stats result received: {list(result.keys()) if isinstance(result, dict) else 'N/A'}")
         top_tags = ', '.join([f"{tag}({count})" for tag, count in result.get('top_tags', [])[:10]])
         return f"""Memory System Statistics:
 Total Memories: {result.get('total_memories', 0)}
@@ -1490,10 +1499,24 @@ async def health_check(request: Request) -> JSONResponse:
     )
 
 
+def _mask_api_url(url: str) -> str:
+    """Mask the API URL, showing only the first 1/4 and hiding the rest."""
+    if not url:
+        return "Not set"
+    # Show first 1/4 of the URL, mask the rest
+    url_length = len(url)
+    visible_length = max(1, url_length // 4)
+    if visible_length >= url_length:
+        return url
+    visible_part = url[:visible_length]
+    masked_part = "*" * (url_length - visible_length)
+    return f"{visible_part}{masked_part}"
+
+
 def run_server():
     """Run the FastMCP server with HTTP transport."""
-    logger.info(f"Starting Mem-Brain MCP Server on {settings.mcp_server_host}:{settings.mcp_server_port}")
-    logger.info(f"API URL: {settings.api_url}")
+    logger.info(f"Starting Mem-Brain MCP Server v{__version__} on {settings.mcp_server_host}:{settings.mcp_server_port}")
+    logger.info(f"API URL: {_mask_api_url(settings.api_url)}")
     logger.info(f"API Key: {'***' if settings.api_key else 'Not set'}")
     
     # Configure CORS for browser-based and MCP clients