hanzo-mcp 0.8.11__py3-none-any.whl → 0.9.0__py3-none-any.whl

hanzo_mcp/tools/vector/project_manager.py

@@ -153,9 +153,7 @@ class ProjectVectorManager:
 
         return None
 
-    def get_vector_store(
-        self, project_info: Optional[ProjectInfo] = None
-    ) -> InfinityVectorStore:
+    def get_vector_store(self, project_info: Optional[ProjectInfo] = None) -> InfinityVectorStore:
         """Get vector store for a project or global store.
 
         Args:
@@ -178,9 +176,7 @@ class ProjectVectorManager:
 
         if project_key not in self.vector_stores:
             # Get index path based on configuration
-            index_path = self.index_config.get_index_path(
-                "vector", str(project_info.root_path)
-            )
+            index_path = self.index_config.get_index_path("vector", str(project_info.root_path))
             index_path.mkdir(parents=True, exist_ok=True)
 
             self.vector_stores[project_key] = InfinityVectorStore(
@@ -270,9 +266,7 @@ class ProjectVectorManager:
             search_tasks.append(
                 asyncio.get_event_loop().run_in_executor(
                     self.executor,
-                    lambda: global_store.search(
-                        query, limit_per_project, score_threshold
-                    ),
+                    lambda: global_store.search(query, limit_per_project, score_threshold),
                 )
             )
             project_names.append("global")
@@ -287,9 +281,7 @@ class ProjectVectorManager:
             search_tasks.append(
                 asyncio.get_event_loop().run_in_executor(
                     self.executor,
-                    lambda vs=vector_store: vs.search(
-                        query, limit_per_project, score_threshold
-                    ),
+                    lambda vs=vector_store: vs.search(query, limit_per_project, score_threshold),
                 )
             )
             project_names.append(project_info.name)

hanzo_mcp/tools/vector/unified_vector.py

@@ -0,0 +1,384 @@
+"""Unified vector tool that consolidates all vector/semantic search functionality."""
+
+import asyncio
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional, final, override
+
+import httpx
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+
+logger = logging.getLogger(__name__)
+
+# Try to import LanceDB and hanzo-memory dependencies
+try:
+    import lancedb
+    from hanzo_memory.db.lancedb_client import get_lancedb_client
+    from hanzo_memory.services.memory import get_memory_service
+    from hanzo_memory.models.memory import Memory
+    LANCEDB_AVAILABLE = True
+except ImportError:
+    LANCEDB_AVAILABLE = False
+
+
+class HanzoNodeClient:
+    """Client for communicating with hanzo-node."""
+    
+    def __init__(self, base_url: str = "http://localhost:3690"):
+        """Initialize hanzo-node client."""
+        self.base_url = base_url
+        self.client = httpx.AsyncClient(timeout=30.0)
+        
+    async def is_available(self) -> bool:
+        """Check if hanzo-node is running and available."""
+        try:
+            response = await self.client.get(f"{self.base_url}/health")
+            return response.status_code == 200
+        except Exception:
+            return False
+            
+    async def search_vectors(self, query: str, limit: int = 10, **kwargs) -> List[Dict[str, Any]]:
+        """Search vectors using hanzo-node."""
+        try:
+            payload = {
+                "query": query,
+                "limit": limit,
+                **kwargs
+            }
+            response = await self.client.post(f"{self.base_url}/api/v1/search", json=payload)
+            response.raise_for_status()
+            return response.json().get("results", [])
+        except Exception as e:
+            logger.error(f"Error searching vectors via hanzo-node: {e}")
+            return []
+            
+    async def index_content(self, content: str, metadata: Optional[Dict] = None) -> bool:
+        """Index content using hanzo-node."""
+        try:
+            payload = {
+                "content": content,
+                "metadata": metadata or {}
+            }
+            response = await self.client.post(f"{self.base_url}/api/v1/index", json=payload)
+            response.raise_for_status()
+            return True
+        except Exception as e:
+            logger.error(f"Error indexing content via hanzo-node: {e}")
+            return False
+
+
+@final
+class UnifiedVectorTool(BaseTool):
+    """Unified vector tool that consolidates all vector/semantic search functionality.
+    
+    This tool provides a single interface for vector operations that:
+    1. Detects if hanzo-node is running on localhost:3690
+    2. Uses hanzo-node for vector operations if available
+    3. Falls back to embedded LanceDB if hanzo-node is not available
+    4. Provides semantic search, indexing, and memory operations
+    """
+    
+    def __init__(self, user_id: str = "default", project_id: str = "default"):
+        """Initialize unified vector tool."""
+        self.user_id = user_id
+        self.project_id = project_id
+        self.hanzo_node = HanzoNodeClient()
+        
+        # Initialize LanceDB fallback if available
+        if LANCEDB_AVAILABLE:
+            self.lancedb_client = get_lancedb_client()
+            self.memory_service = get_memory_service()
+        else:
+            self.lancedb_client = None
+            self.memory_service = None
+            
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "vector"
+        
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Unified vector search and semantic operations.
+
+This tool provides comprehensive vector/semantic search capabilities:
+- Semantic search across indexed content
+- Content indexing for future search
+- Memory storage and retrieval
+- Knowledge base operations
+
+The tool automatically detects if hanzo-node is available and uses it for 
+optimal performance, falling back to embedded LanceDB if needed.
+
+Examples:
+vector(action="search", query="error handling in Python", limit=5)
+vector(action="index", content="Important project documentation", metadata={"type": "docs"})
+vector(action="memory_create", content="User prefers TypeScript over JavaScript")
+vector(action="memory_search", query="user preferences")
+vector(action="status")  # Check backend status
+"""
+
+    async def _detect_backend(self) -> str:
+        """Detect which backend to use."""
+        if await self.hanzo_node.is_available():
+            return "hanzo-node"
+        elif LANCEDB_AVAILABLE:
+            return "lancedb"
+        else:
+            return "none"
+            
+    async def _search_hanzo_node(self, query: str, limit: int, **kwargs) -> List[Dict[str, Any]]:
+        """Search using hanzo-node."""
+        return await self.hanzo_node.search_vectors(query, limit, **kwargs)
+        
+    async def _search_lancedb(self, query: str, limit: int, project_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Search using embedded LanceDB."""
+        if not self.memory_service:
+            return []
+            
+        try:
+            # Use hanzo-memory service for search
+            results = self.memory_service.search_memories(
+                user_id=self.user_id,
+                query=query,
+                project_id=project_id or self.project_id,
+                limit=limit
+            )
+            
+            # Convert to standard format
+            formatted_results = []
+            for result in results:
+                formatted_results.append({
+                    "content": result.content,
+                    "score": getattr(result, "similarity_score", 0.0),
+                    "metadata": getattr(result, "metadata", {}),
+                    "id": result.memory_id
+                })
+            return formatted_results
+        except Exception as e:
+            logger.error(f"Error searching LanceDB: {e}")
+            return []
+            
+    async def _index_hanzo_node(self, content: str, metadata: Optional[Dict] = None) -> bool:
+        """Index content using hanzo-node."""
+        return await self.hanzo_node.index_content(content, metadata)
+        
+    async def _index_lancedb(self, content: str, metadata: Optional[Dict] = None) -> bool:
+        """Index content using embedded LanceDB."""
+        if not self.memory_service:
+            return False
+            
+        try:
+            self.memory_service.create_memory(
+                user_id=self.user_id,
+                project_id=self.project_id,
+                content=content,
+                metadata=metadata or {}
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Error indexing to LanceDB: {e}")
+            return False
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        action: str,
+        query: Optional[str] = None,
+        content: Optional[str] = None,
+        limit: int = 10,
+        project_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> str:
+        """Execute vector operations.
+        
+        Args:
+            ctx: MCP context
+            action: Action to perform (search, index, memory_create, memory_search, status)
+            query: Search query (for search actions)
+            content: Content to index or store (for index/create actions)
+            limit: Maximum results to return
+            project_id: Project ID (defaults to tool's project_id)
+            metadata: Additional metadata
+            **kwargs: Additional action-specific parameters
+            
+        Returns:
+            Formatted results or status message
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+        
+        # Detect backend
+        backend = await self._detect_backend()
+        await tool_ctx.info(f"Using backend: {backend}")
+        
+        if action == "status":
+            return await self._handle_status(tool_ctx, backend)
+        elif action == "search":
+            return await self._handle_search(tool_ctx, backend, query, limit, project_id, **kwargs)
+        elif action == "index":
+            return await self._handle_index(tool_ctx, backend, content, metadata)
+        elif action == "memory_create":
+            return await self._handle_memory_create(tool_ctx, content, metadata)
+        elif action == "memory_search":
+            return await self._handle_memory_search(tool_ctx, query, limit, project_id)
+        else:
+            return f"Unknown action: {action}. Available actions: search, index, memory_create, memory_search, status"
+            
+    async def _handle_status(self, tool_ctx, backend: str) -> str:
+        """Handle status check."""
+        status_info = [f"Vector backend: {backend}"]
+        
+        if backend == "hanzo-node":
+            try:
+                node_available = await self.hanzo_node.is_available()
+                status_info.append(f"Hanzo-node available: {node_available}")
+                status_info.append(f"Hanzo-node URL: {self.hanzo_node.base_url}")
+            except Exception as e:
+                status_info.append(f"Hanzo-node error: {e}")
+                
+        if backend == "lancedb" or backend == "hanzo-node":
+            status_info.append(f"LanceDB available: {LANCEDB_AVAILABLE}")
+            if LANCEDB_AVAILABLE and self.lancedb_client:
+                try:
+                    # Check LanceDB status
+                    db_path = Path(self.lancedb_client.db_path)
+                    status_info.append(f"LanceDB path: {db_path}")
+                    status_info.append(f"LanceDB exists: {db_path.exists()}")
+                    if db_path.exists():
+                        status_info.append(f"Table count: {len(self.lancedb_client.db.table_names())}")
+                except Exception as e:
+                    status_info.append(f"LanceDB error: {e}")
+                    
+        if backend == "none":
+            status_info.append("No vector backend available. Install hanzo-memory or start hanzo-node.")
+            
+        return "\n".join(status_info)
+        
+    async def _handle_search(self, tool_ctx, backend: str, query: Optional[str], limit: int, project_id: Optional[str], **kwargs) -> str:
+        """Handle search operations."""
+        if not query:
+            return "Error: Query is required for search action"
+            
+        await tool_ctx.info(f"Searching for: {query} (limit: {limit})")
+        
+        if backend == "hanzo-node":
+            results = await self._search_hanzo_node(query, limit, **kwargs)
+        elif backend == "lancedb":
+            results = await self._search_lancedb(query, limit, project_id)
+        else:
+            return "Error: No vector backend available"
+            
+        if not results:
+            return f"No results found for query: {query}"
+            
+        # Format results
+        formatted = [f"Found {len(results)} results for '{query}':\n"]
+        for i, result in enumerate(results, 1):
+            content = result.get("content", "")
+            score = result.get("score", 0.0)
+            formatted.append(f"{i}. {content} (score: {score:.3f})")
+            
+        return "\n".join(formatted)
+        
+    async def _handle_index(self, tool_ctx, backend: str, content: Optional[str], metadata: Optional[Dict]) -> str:
+        """Handle indexing operations."""
+        if not content:
+            return "Error: Content is required for index action"
+            
+        await tool_ctx.info(f"Indexing content: {content[:100]}...")
+        
+        if backend == "hanzo-node":
+            success = await self._index_hanzo_node(content, metadata)
+        elif backend == "lancedb":
+            success = await self._index_lancedb(content, metadata)
+        else:
+            return "Error: No vector backend available"
+            
+        if success:
+            return f"Successfully indexed content (backend: {backend})"
+        else:
+            return f"Failed to index content (backend: {backend})"
+            
+    async def _handle_memory_create(self, tool_ctx, content: Optional[str], metadata: Optional[Dict]) -> str:
+        """Handle memory creation."""
+        if not content:
+            return "Error: Content is required for memory_create action"
+            
+        if not self.memory_service:
+            return "Error: Memory service not available"
+            
+        try:
+            memory = self.memory_service.create_memory(
+                user_id=self.user_id,
+                project_id=self.project_id,
+                content=content,
+                metadata=metadata or {}
+            )
+            return f"Created memory: {memory.memory_id}"
+        except Exception as e:
+            return f"Error creating memory: {e}"
+            
+    async def _handle_memory_search(self, tool_ctx, query: Optional[str], limit: int, project_id: Optional[str]) -> str:
+        """Handle memory search."""
+        if not query:
+            return "Error: Query is required for memory_search action"
+            
+        if not self.memory_service:
+            return "Error: Memory service not available"
+            
+        try:
+            results = self.memory_service.search_memories(
+                user_id=self.user_id,
+                query=query,
+                project_id=project_id or self.project_id,
+                limit=limit
+            )
+            
+            if not results:
+                return f"No memories found for query: {query}"
+                
+            formatted = [f"Found {len(results)} memories for '{query}':\n"]
+            for i, memory in enumerate(results, 1):
+                score = getattr(memory, "similarity_score", 0.0)
+                formatted.append(f"{i}. {memory.content} (score: {score:.3f})")
+                
+            return "\n".join(formatted)
+        except Exception as e:
+            return f"Error searching memories: {e}"
+
+    @override
+    def register(self, mcp_server: FastMCP) -> None:
+        """Register this tool with the MCP server."""
+        tool_self = self
+        
+        @mcp_server.tool(name=self.name, description=self.description)
+        async def vector(
+            ctx: MCPContext,
+            action: str,
+            query: Optional[str] = None,
+            content: Optional[str] = None,
+            limit: int = 10,
+            project_id: Optional[str] = None,
+            metadata: Optional[Dict[str, Any]] = None,
+        ) -> str:
+            return await tool_self.call(
+                ctx,
+                action=action,
+                query=query,
+                content=content,
+                limit=limit,
+                project_id=project_id,
+                metadata=metadata,
+            )

hanzo_mcp/tools/vector/vector.py

@@ -249,9 +249,7 @@ vector --action clear --path ./old_code
             output.append(f"Chunks created: {stats.get('chunks_created', 0)}")
             if stats.get("git_commits"):
                 output.append(f"Git commits indexed: {stats['git_commits']}")
-            output.append(
-                f"Total documents: {project.get_stats().get('total_documents', 0)}"
-            )
+            output.append(f"Total documents: {project.get_stats().get('total_documents', 0)}")
 
             return "\n".join(output)
 
@@ -283,9 +281,7 @@ vector --action clear --path ./old_code
             if stats.get("projects"):
                 output.append(f"\nProjects indexed: {len(stats['projects'])}")
                 for proj in stats["projects"]:
-                    output.append(
-                        f"  - {proj['name']}: {proj['documents']} docs, {proj['size_mb']:.1f} MB"
-                    )
+                    output.append(f"  - {proj['name']}: {proj['documents']} docs, {proj['size_mb']:.1f} MB")
 
             return "\n".join(output)
 

hanzo_mcp/tools/vector/vector_index.py

@@ -90,18 +90,18 @@ directories alongside them. Use this to build searchable knowledge bases per pro
                     return f"Error: File does not exist: {file_path}"
 
                 # Index file using project-aware manager
-                doc_ids, project_info = (
-                    self.project_manager.add_file_to_appropriate_store(
-                        file_path=file_path,
-                        chunk_size=chunk_size,
-                        chunk_overlap=chunk_overlap,
-                        metadata=metadata,
-                    )
+                doc_ids, project_info = self.project_manager.add_file_to_appropriate_store(
+                    file_path=file_path,
+                    chunk_size=chunk_size,
+                    chunk_overlap=chunk_overlap,
+                    metadata=metadata,
                 )
 
                 file_name = Path(file_path).name
                 if project_info:
-                    return f"Successfully indexed {file_name} with {len(doc_ids)} chunks in project '{project_info.name}'"
+                    return (
+                        f"Successfully indexed {file_name} with {len(doc_ids)} chunks in project '{project_info.name}'"
+                    )
                 else:
                     return f"Successfully indexed {file_name} with {len(doc_ids)} chunks in global database"
 

hanzo_mcp/tools/vector/vector_search.py

@@ -135,9 +135,7 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                             break
 
                     if project_info:
-                        vector_store = self.project_manager.get_vector_store(
-                            project_info
-                        )
+                        vector_store = self.project_manager.get_vector_store(project_info)
                         results = vector_store.search(
                             query=query,
                             limit=limit,
@@ -145,9 +143,7 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                         )
                         for result in results:
                             result.document.metadata = result.document.metadata or {}
-                            result.document.metadata["search_project"] = (
-                                project_info.name
-                            )
+                            result.document.metadata["search_project"] = project_info.name
                     else:
                         return f"Project '{search_scope}' not found"
                 else:
@@ -155,14 +151,10 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                     import os
 
                     current_dir = os.getcwd()
-                    project_info = self.project_manager.get_project_for_path(
-                        current_dir
-                    )
+                    project_info = self.project_manager.get_project_for_path(current_dir)
 
                     if project_info:
-                        vector_store = self.project_manager.get_vector_store(
-                            project_info
-                        )
+                        vector_store = self.project_manager.get_vector_store(project_info)
                         results = vector_store.search(
                             query=query,
                             limit=limit,
@@ -170,9 +162,7 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                         )
                         for result in results:
                             result.document.metadata = result.document.metadata or {}
-                            result.document.metadata["search_project"] = (
-                                project_info.name
-                            )
+                            result.document.metadata["search_project"] = project_info.name
                     else:
                         # Fall back to global store
                         global_store = self.project_manager._get_global_store()
@@ -190,9 +180,7 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
 
             # Filter by file if requested
             if file_filter:
-                results = [
-                    r for r in results if file_filter in (r.document.file_path or "")
-                ]
+                results = [r for r in results if file_filter in (r.document.file_path or "")]
 
             # Format results
             output_lines = [f"Found {len(results)} results for query: '{query}'\n"]
@@ -220,9 +208,7 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                         if k not in ["chunk_number", "total_chunks", "search_project"]
                     }
                     if relevant_metadata:
-                        output_lines.append(
-                            f"Metadata: {json.dumps(relevant_metadata, indent=2)}"
-                        )
+                        output_lines.append(f"Metadata: {json.dumps(relevant_metadata, indent=2)}")
 
                 # Add content if requested
                 if include_content:

{hanzo_mcp-0.8.11.dist-info → hanzo_mcp-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.8.11
+Version: 0.9.0
 Summary: The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others.
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT
@@ -34,7 +34,7 @@ Requires-Dist: ffind>=1.3.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
-Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: ruff>=0.13.0; extra == "dev"
 Requires-Dist: black>=23.3.0; extra == "dev"
 Requires-Dist: sphinx>=8.0.0; extra == "dev"
 Requires-Dist: sphinx-rtd-theme>=3.0.0; extra == "dev"