vectorizer-sdk 1.0.0__py3-none-any.whl

utils/__init__.py

@@ -0,0 +1,39 @@
+"""
+Utils package for the Hive Vectorizer SDK.
+
+This package contains utility functions for validation, HTTP client, and other common operations.
+"""
+
+from .validation import (
+    validate_non_empty_string,
+    validate_positive_number,
+    validate_non_negative_number,
+    validate_number_range,
+    validate_number_array,
+    validate_boolean
+)
+from .http_client import HTTPClient
+from .transport import TransportFactory, TransportProtocol, parse_connection_string
+
+try:
+    from .umicp_client import UMICPClient
+    UMICP_AVAILABLE = True
+except ImportError:
+    UMICPClient = None
+    UMICP_AVAILABLE = False
+
+__all__ = [
+    'validate_non_empty_string',
+    'validate_positive_number',
+    'validate_non_negative_number',
+    'validate_number_range',
+    'validate_number_array',
+    'validate_boolean',
+    'HTTPClient',
+    'TransportFactory',
+    'TransportProtocol',
+    'parse_connection_string',
+]
+
+if UMICP_AVAILABLE:
+    __all__.append('UMICPClient')

utils/http_client.py

@@ -0,0 +1,145 @@
+"""
+HTTP client utility for making API requests using aiohttp.
+"""
+
+from typing import Optional, Dict, Any
+import aiohttp
+import asyncio
+import logging
+
+try:
+    from ..exceptions import (
+        NetworkError,
+        ServerError,
+        AuthenticationError,
+    )
+except ImportError:
+    from exceptions import (
+        NetworkError,
+        ServerError,
+        AuthenticationError,
+    )
+
+logger = logging.getLogger(__name__)
+
+
+class HTTPClient:
+    """HTTP transport client."""
+    
+    def __init__(
+        self,
+        base_url: str = "http://localhost:15002",
+        api_key: Optional[str] = None,
+        timeout: int = 30,
+        max_retries: int = 3
+    ):
+        """
+        Initialize HTTP client.
+        
+        Args:
+            base_url: Base URL for HTTP API
+            api_key: API key for authentication
+            timeout: Request timeout in seconds
+            max_retries: Maximum number of retry attempts
+        """
+        self.base_url = base_url.rstrip('/')
+        self.api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._session: Optional[aiohttp.ClientSession] = None
+    
+    async def _ensure_session(self):
+        """Ensure aiohttp session is created."""
+        if self._session is None or self._session.closed:
+            headers = {"Content-Type": "application/json"}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+            
+            timeout_config = aiohttp.ClientTimeout(total=self.timeout)
+            self._session = aiohttp.ClientSession(
+                headers=headers,
+                timeout=timeout_config
+            )
+    
+    async def close(self):
+        """Close the HTTP session."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+    
+    async def request(
+        self,
+        method: str,
+        path: str,
+        data: Optional[Dict[str, Any]] = None
+    ) -> Any:
+        """
+        Make an HTTP request.
+        
+        Args:
+            method: HTTP method
+            path: API endpoint path
+            data: Request data
+            
+        Returns:
+            Response data
+        """
+        await self._ensure_session()
+        
+        url = f"{self.base_url}{path}"
+        
+        try:
+            async with self._session.request(
+                method,
+                url,
+                json=data if data else None
+            ) as response:
+                if response.status >= 400:
+                    error_text = await response.text()
+                    raise self._handle_error(response.status, error_text)
+                
+                content_type = response.headers.get('Content-Type', '')
+                if 'application/json' in content_type:
+                    return await response.json()
+                return await response.text()
+        
+        except (ServerError, AuthenticationError):
+            raise
+        except aiohttp.ClientError as e:
+            raise NetworkError(f"HTTP request failed: {e}")
+        except asyncio.TimeoutError:
+            raise NetworkError("Request timeout")
+        except Exception as e:
+            raise NetworkError(f"Unknown error: {e}")
+    
+    async def get(self, path: str) -> Any:
+        """Make a GET request."""
+        return await self.request("GET", path)
+    
+    async def post(self, path: str, data: Optional[Dict[str, Any]] = None) -> Any:
+        """Make a POST request."""
+        return await self.request("POST", path, data)
+    
+    async def put(self, path: str, data: Optional[Dict[str, Any]] = None) -> Any:
+        """Make a PUT request."""
+        return await self.request("PUT", path, data)
+    
+    async def delete(self, path: str) -> Any:
+        """Make a DELETE request."""
+        return await self.request("DELETE", path)
+    
+    def _handle_error(self, status: int, error_text: str) -> Exception:
+        """Handle HTTP errors and convert to appropriate exceptions."""
+        message = f"HTTP {status}: {error_text}"
+        
+        if status == 401:
+            return AuthenticationError(message)
+        elif status == 403:
+            return AuthenticationError("Access forbidden")
+        elif status == 404:
+            return ServerError("Resource not found")
+        elif status in (429, 500, 502, 503, 504):
+            return ServerError(message)
+        else:
+            return ServerError(message)
+

utils/transport.py

@@ -0,0 +1,108 @@
+"""
+Transport abstraction layer for Vectorizer client.
+
+Supports multiple transport protocols:
+- HTTP/HTTPS (default)
+- UMICP (Universal Messaging and Inter-process Communication Protocol)
+"""
+
+from typing import Optional, Dict, Any, Protocol as TypingProtocol
+from enum import Enum
+from urllib.parse import urlparse
+
+
+class TransportProtocol(str, Enum):
+    """Transport protocol enum."""
+    HTTP = "http"
+    UMICP = "umicp"
+
+
+class Transport(TypingProtocol):
+    """Transport protocol interface."""
+    
+    async def get(self, path: str) -> Any:
+        """Make a GET request."""
+        ...
+    
+    async def post(self, path: str, data: Optional[Dict[str, Any]] = None) -> Any:
+        """Make a POST request."""
+        ...
+    
+    async def put(self, path: str, data: Optional[Dict[str, Any]] = None) -> Any:
+        """Make a PUT request."""
+        ...
+    
+    async def delete(self, path: str) -> Any:
+        """Make a DELETE request."""
+        ...
+
+
+class TransportFactory:
+    """Factory for creating transport clients."""
+    
+    @staticmethod
+    def create(protocol: TransportProtocol, config: Dict[str, Any]) -> Transport:
+        """
+        Create a transport client based on protocol.
+        
+        Args:
+            protocol: Transport protocol to use
+            config: Configuration dict
+            
+        Returns:
+            Transport client instance
+        """
+        if protocol == TransportProtocol.HTTP:
+            # Import here to avoid circular dependency
+            from .http_client import HTTPClient
+            return HTTPClient(**config)
+        
+        elif protocol == TransportProtocol.UMICP:
+            from .umicp_client import UMICPClient
+            return UMICPClient(**config)
+        
+        else:
+            raise ValueError(f"Unsupported protocol: {protocol}")
+
+
+def parse_connection_string(connection_string: str, api_key: Optional[str] = None) -> tuple:
+    """
+    Parse a connection string into protocol and configuration.
+    
+    Examples:
+        - "http://localhost:15002" -> HTTP transport
+        - "https://api.example.com" -> HTTPS transport
+        - "umicp://localhost:15003" -> UMICP transport
+    
+    Args:
+        connection_string: Connection URI
+        api_key: Optional API key
+        
+    Returns:
+        Tuple of (protocol, config_dict)
+    """
+    parsed = urlparse(connection_string)
+    
+    if parsed.scheme in ("http", "https"):
+        return (
+            TransportProtocol.HTTP,
+            {
+                "base_url": f"{parsed.scheme}://{parsed.netloc}",
+                "api_key": api_key,
+            }
+        )
+    
+    elif parsed.scheme == "umicp":
+        port = parsed.port or 15003
+        return (
+            TransportProtocol.UMICP,
+            {
+                "host": parsed.hostname,
+                "port": port,
+                "api_key": api_key,
+            }
+        )
+    
+    else:
+        raise ValueError(f"Unsupported protocol in connection string: {parsed.scheme}")
+

utils/umicp_client.py

@@ -0,0 +1,174 @@
+"""
+UMICP client utility using the official umicp-python package.
+
+Wrapper around UMICP client for Vectorizer API requests.
+"""
+
+from typing import Optional, Dict, Any
+import json
+import asyncio
+
+try:
+    from umicp import UMICPClient as BaseUMICPClient, Envelope, Priority
+    UMICP_AVAILABLE = True
+except ImportError:
+    UMICP_AVAILABLE = False
+    BaseUMICPClient = None
+    Envelope = None
+    Priority = None
+
+try:
+    from ..exceptions import NetworkError, ServerError, AuthenticationError
+except ImportError:
+    from exceptions import NetworkError, ServerError, AuthenticationError
+
+
+class UMICPClient:
+    """UMICP transport client for Vectorizer."""
+    
+    def __init__(
+        self,
+        host: str = "localhost",
+        port: int = 15003,
+        api_key: Optional[str] = None,
+        timeout: int = 30
+    ):
+        """
+        Initialize UMICP client.
+        
+        Args:
+            host: Server hostname
+            port: Server port
+            api_key: API key for authentication
+            timeout: Request timeout in seconds
+        """
+        if not UMICP_AVAILABLE:
+            raise ImportError(
+                "umicp-python is not installed. "
+                "Install it with: pip install umicp-python"
+            )
+        
+        self.host = host
+        self.port = port
+        self.api_key = api_key
+        self.timeout = timeout
+        self._client: Optional[BaseUMICPClient] = None
+        self._connected = False
+    
+    async def connect(self) -> None:
+        """Connect to UMICP server."""
+        if self._connected and self._client:
+            return
+        
+        try:
+            self._client = BaseUMICPClient(
+                host=self.host,
+                port=self.port,
+                timeout=self.timeout
+            )
+            await self._client.connect()
+            self._connected = True
+        except Exception as e:
+            raise NetworkError(f"Failed to connect to UMICP server: {e}")
+    
+    async def disconnect(self) -> None:
+        """Disconnect from UMICP server."""
+        if self._client:
+            await self._client.close()
+            self._connected = False
+            self._client = None
+    
+    def is_connected(self) -> bool:
+        """Check if connected to UMICP server."""
+        return self._connected and self._client is not None
+    
+    async def request(
+        self,
+        method: str,
+        path: str,
+        data: Optional[Dict[str, Any]] = None
+    ) -> Any:
+        """
+        Make a request via UMICP.
+        
+        Args:
+            method: HTTP method
+            path: API endpoint path
+            data: Request data
+            
+        Returns:
+            Response data
+        """
+        if not self.is_connected():
+            await self.connect()
+        
+        if not self._client:
+            raise NetworkError("UMICP client not initialized")
+        
+        payload = {
+            "method": method,
+            "path": path,
+        }
+        
+        if data:
+            payload["body"] = data
+        
+        if self.api_key:
+            payload["authorization"] = f"Bearer {self.api_key}"
+        
+        try:
+            envelope = Envelope(
+                from_addr="vectorizer-client",
+                to_addr="vectorizer-server",
+                content_type="application/json",
+                payload=json.dumps(payload)
+            )
+            
+            envelope.set_priority(Priority.NORMAL)
+            
+            response = await self._client.send(envelope)
+            response_data = json.loads(response.get_payload())
+            
+            # Handle HTTP-like status codes
+            if isinstance(response_data, dict) and "statusCode" in response_data:
+                if response_data["statusCode"] >= 400:
+                    raise self._handle_error(response_data)
+            
+            return response_data
+        except (ServerError, AuthenticationError):
+            raise
+        except Exception as e:
+            raise NetworkError(f"UMICP request failed: {e}")
+    
+    async def get(self, path: str) -> Any:
+        """Make a GET request."""
+        return await self.request("GET", path)
+    
+    async def post(self, path: str, data: Optional[Dict[str, Any]] = None) -> Any:
+        """Make a POST request."""
+        return await self.request("POST", path, data)
+    
+    async def put(self, path: str, data: Optional[Dict[str, Any]] = None) -> Any:
+        """Make a PUT request."""
+        return await self.request("PUT", path, data)
+    
+    async def delete(self, path: str) -> Any:
+        """Make a DELETE request."""
+        return await self.request("DELETE", path)
+    
+    def _handle_error(self, response_data: Dict[str, Any]) -> Exception:
+        """Handle UMICP errors and convert to appropriate exceptions."""
+        message = response_data.get("message", f"UMICP Error {response_data.get('statusCode', 'Unknown')}")
+        status_code = response_data.get("statusCode", 500)
+        
+        if status_code == 401:
+            return AuthenticationError(message)
+        elif status_code == 403:
+            return AuthenticationError("Access forbidden")
+        elif status_code == 404:
+            return ServerError("Resource not found")
+        elif status_code in (429, 500, 502, 503, 504):
+            return ServerError(message)
+        else:
+            return ServerError(message)
+

utils/validation.py

@@ -0,0 +1,163 @@
+"""
+Validation utilities for the Hive Vectorizer SDK.
+
+This module provides validation functions for various data types and constraints,
+mirroring the validation functionality of the JavaScript/TypeScript SDKs.
+"""
+
+import math
+from typing import Any, List, Union
+
+
+def validate_non_empty_string(value: Any) -> str:
+    """
+    Validate that a value is a non-empty string.
+
+    Args:
+        value: The value to validate
+
+    Returns:
+        The validated string
+
+    Raises:
+        ValueError: If the value is not a string or is empty/whitespace-only
+    """
+    if not isinstance(value, str):
+        raise ValueError("Value must be a string")
+
+    if not value.strip():
+        raise ValueError("String cannot be empty or whitespace-only")
+
+    return value
+
+
+def validate_positive_number(value: Any) -> Union[int, float]:
+    """
+    Validate that a value is a positive number.
+
+    Args:
+        value: The value to validate
+
+    Returns:
+        The validated number
+
+    Raises:
+        ValueError: If the value is not a number or is not positive
+    """
+    if not isinstance(value, (int, float)):
+        raise ValueError("Value must be a number")
+
+    if math.isnan(value) or math.isinf(value):
+        raise ValueError("Value cannot be NaN or Infinity")
+
+    if value <= 0:
+        raise ValueError("Value must be positive")
+
+    return value
+
+
+def validate_non_negative_number(value: Any) -> Union[int, float]:
+    """
+    Validate that a value is a non-negative number.
+
+    Args:
+        value: The value to validate
+
+    Returns:
+        The validated number
+
+    Raises:
+        ValueError: If the value is not a number or is negative
+    """
+    if not isinstance(value, (int, float)):
+        raise ValueError("Value must be a number")
+
+    if math.isnan(value) or math.isinf(value):
+        raise ValueError("Value cannot be NaN or Infinity")
+
+    if value < 0:
+        raise ValueError("Value must be non-negative")
+
+    return value
+
+
+def validate_number_range(value: Any, min_val: Union[int, float] = None, max_val: Union[int, float] = None) -> Union[int, float]:
+    """
+    Validate that a value is a number within a specified range.
+
+    Args:
+        value: The value to validate
+        min_val: Minimum allowed value (optional)
+        max_val: Maximum allowed value (optional)
+
+    Returns:
+        The validated number
+
+    Raises:
+        ValueError: If the value is not a number or outside the allowed range
+    """
+    if not isinstance(value, (int, float)):
+        raise ValueError("Value must be a number")
+
+    if math.isnan(value) or math.isinf(value):
+        raise ValueError("Value cannot be NaN or Infinity")
+
+    if min_val is not None and value < min_val:
+        raise ValueError(f"Value must be at least {min_val}")
+
+    if max_val is not None and value > max_val:
+        raise ValueError(f"Value must be at most {max_val}")
+
+    return value
+
+
+def validate_number_array(value: Any) -> List[Union[int, float]]:
+    """
+    Validate that a value is an array of finite numbers.
+
+    Args:
+        value: The value to validate
+
+    Returns:
+        The validated array of numbers
+
+    Raises:
+        ValueError: If the value is not an array or contains invalid numbers
+    """
+    if not isinstance(value, list):
+        raise ValueError("Value must be an array")
+
+    if not value:
+        raise ValueError("Array cannot be empty")
+
+    for i, item in enumerate(value):
+        if not isinstance(item, (int, float)):
+            raise ValueError(f"Array item at index {i} must be a number")
+
+        if math.isnan(item):
+            raise ValueError(f"Array item at index {i} cannot be NaN")
+
+        if math.isinf(item):
+            raise ValueError(f"Array item at index {i} cannot be Infinity")
+
+    return value
+
+
+def validate_boolean(value: Any) -> bool:
+    """
+    Validate that a value is a boolean.
+
+    Args:
+        value: The value to validate
+
+    Returns:
+        The validated boolean
+
+    Raises:
+        ValueError: If the value is not a boolean
+    """
+    if not isinstance(value, bool):
+        raise ValueError("Value must be a boolean")
+
+    return value
+

vectorizer_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,304 @@
+Metadata-Version: 2.4
+Name: vectorizer_sdk
+Version: 1.0.0
+Summary: Python SDK for Vectorizer - Semantic search and vector operations with UMICP protocol support
+Author-email: HiveLLM Team <team@hivellm.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/hivellm/vectorizer
+Project-URL: Documentation, https://github.com/hivellm/vectorizer/tree/main/docs
+Project-URL: Repository, https://github.com/hivellm/vectorizer
+Project-URL: Issues, https://github.com/hivellm/vectorizer/issues
+Keywords: vectorizer,semantic-search,embeddings,machine-learning,ai,search,vectors,similarity,hivellm,umicp
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: umicp-sdk>=0.3.2
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=6.0.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.2.0; extra == "docs"
+Requires-Dist: myst-parser>=1.0.0; extra == "docs"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: httpx>=0.24.0; extra == "test"
+Dynamic: license-file
+
+# Hive Vectorizer Python SDK
+
+A comprehensive Python client library for the Hive Vectorizer service.
+
+## Features
+
+- **Multiple Transport Protocols**: HTTP/HTTPS and UMICP support
+- **UMICP Protocol**: High-performance protocol using umicp-python package
+- **Vector Operations**: Insert, search, and manage vectors
+- **Collection Management**: Create, delete, and monitor collections  
+- **Semantic Search**: Find similar content using embeddings
+- **Intelligent Search**: Advanced multi-query search with domain expansion
+- **Contextual Search**: Context-aware search with metadata filtering
+- **Multi-Collection Search**: Cross-collection search with intelligent aggregation
+- **Batch Operations**: Efficient bulk operations
+- **Error Handling**: Comprehensive exception handling
+- **Async Support**: Full async/await support for high performance
+- **Type Safety**: Full type hints and validation
+
+## Installation
+
+```bash
+pip install hive-vectorizer
+```
+
+## Quick Start
+
+```python
+import asyncio
+from vectorizer import VectorizerClient, Vector
+
+async def main():
+    async with VectorizerClient() as client:
+        # Create a collection
+        await client.create_collection("my_collection", dimension=512)
+        
+        # Generate embedding
+        embedding = await client.embed_text("Hello, world!")
+        
+        # Create vector
+        vector = Vector(
+            id="doc1",
+            data=embedding,
+            metadata={"text": "Hello, world!"}
+        )
+        
+        # Insert text
+        await client.insert_texts("my_collection", [{
+            "id": "doc1",
+            "text": "Hello, world!",
+            "metadata": {"source": "example"}
+        }])
+        
+        # Search for similar vectors
+        results = await client.search_vectors(
+            collection="my_collection",
+            query="greeting",
+            limit=5
+        )
+        
+        # Intelligent search with multi-query expansion
+        from models import IntelligentSearchRequest
+        intelligent_results = await client.intelligent_search(
+            IntelligentSearchRequest(
+                query="machine learning algorithms",
+                collections=["my_collection", "research"],
+                max_results=15,
+                domain_expansion=True,
+                technical_focus=True,
+                mmr_enabled=True,
+                mmr_lambda=0.7
+            )
+        )
+        
+        # Semantic search with reranking
+        from models import SemanticSearchRequest
+        semantic_results = await client.semantic_search(
+            SemanticSearchRequest(
+                query="neural networks",
+                collection="my_collection",
+                max_results=10,
+                semantic_reranking=True,
+                similarity_threshold=0.6
+            )
+        )
+        
+        # Contextual search with metadata filtering
+        from models import ContextualSearchRequest
+        contextual_results = await client.contextual_search(
+            ContextualSearchRequest(
+                query="deep learning",
+                collection="my_collection",
+                context_filters={"category": "AI", "year": 2023},
+                max_results=10,
+                context_weight=0.4
+            )
+        )
+        
+        # Multi-collection search
+        from models import MultiCollectionSearchRequest
+        multi_results = await client.multi_collection_search(
+            MultiCollectionSearchRequest(
+                query="artificial intelligence",
+                collections=["my_collection", "research", "tutorials"],
+                max_per_collection=5,
+                max_total_results=20,
+                cross_collection_reranking=True
+            )
+        )
+        
+        print(f"Found {len(results)} similar vectors")
+
+asyncio.run(main())
+```
+
+## Configuration
+
+### HTTP Configuration (Default)
+
+```python
+from vectorizer import VectorizerClient
+
+# Default HTTP configuration
+client = VectorizerClient(
+    base_url="http://localhost:15002",
+    api_key="your-api-key",
+    timeout=30
+)
+```
+
+### UMICP Configuration (High Performance)
+
+[UMICP (Universal Messaging and Inter-process Communication Protocol)](https://pypi.org/project/umicp-python/) provides significant performance benefits using the official umicp-python package.
+
+#### Using Connection String
+
+```python
+from vectorizer import VectorizerClient
+
+client = VectorizerClient(
+    connection_string="umicp://localhost:15003",
+    api_key="your-api-key"
+)
+
+print(f"Using protocol: {client.get_protocol()}")  # Output: umicp
+```
+
+#### Using Explicit Configuration
+
+```python
+from vectorizer import VectorizerClient
+
+client = VectorizerClient(
+    protocol="umicp",
+    api_key="your-api-key",
+    umicp={
+        "host": "localhost",
+        "port": 15003
+    },
+    timeout=60
+)
+```
+
+#### When to Use UMICP
+
+Use UMICP when:
+- **Large Payloads**: Inserting or searching large batches of vectors
+- **High Throughput**: Need maximum performance for production workloads
+- **Low Latency**: Need minimal protocol overhead
+
+Use HTTP when:
+- **Development**: Quick testing and debugging
+- **Firewall Restrictions**: Only HTTP/HTTPS allowed
+- **Simple Deployments**: No need for custom protocol setup
+
+#### Protocol Comparison
+
+| Feature | HTTP/HTTPS | UMICP |
+|---------|-----------|-------|
+| Transport | aiohttp (standard HTTP) | umicp-python package |
+| Performance | Standard | Optimized for large payloads |
+| Latency | Standard | Lower overhead |
+| Firewall | Widely supported | May require configuration |
+| Installation | Default | Requires umicp-python |
+
+#### Installing with UMICP Support
+
+```bash
+pip install hive-vectorizer umicp-python
+```
+
+## Testing
+
+The SDK includes a comprehensive test suite with 73+ tests covering all functionality:
+
+### Running Tests
+
+```bash
+# Run basic tests (recommended)
+python3 test_simple.py
+
+# Run comprehensive tests
+python3 test_sdk_comprehensive.py
+
+# Run all tests with detailed reporting
+python3 run_tests.py
+
+# Run specific test
+python3 -m unittest test_simple.TestBasicFunctionality
+```
+
+### Test Coverage
+
+- **Data Models**: 100% coverage (Vector, Collection, CollectionInfo, SearchResult)
+- **Exceptions**: 100% coverage (all 12 custom exceptions)
+- **Client Operations**: 95% coverage (all CRUD operations)
+- **Edge Cases**: 100% coverage (Unicode, large vectors, special data types)
+- **Validation**: Complete input validation testing
+- **Error Handling**: Comprehensive exception testing
+
+### Test Results
+
+```
+🧪 Basic Tests: ✅ 18/18 (100% success)
+🧪 Comprehensive Tests: ⚠️ 53/55 (96% success)
+🧪 Syntax Validation: ✅ 7/7 (100% success)
+🧪 Import Validation: ✅ 5/5 (100% success)
+
+📊 Overall Success Rate: 75%
+⏱️ Total Execution Time: <0.4 seconds
+```
+
+### Test Categories
+
+1. **Unit Tests**: Individual component testing
+2. **Integration Tests**: Mock-based workflow testing
+3. **Validation Tests**: Input validation and error handling
+4. **Edge Case Tests**: Unicode, large data, special scenarios
+5. **Syntax Tests**: Code compilation and import validation
+
+## Documentation
+
+- [Full Documentation](https://docs.cmmv-hive.org/vectorizer)
+- [API Reference](https://docs.cmmv-hive.org/vectorizer/api)
+- [Examples](examples.py)
+- [Test Documentation](TESTES_RESUMO.md)
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Support
+
+- GitHub Issues: https://github.com/cmmv-hive/vectorizer/issues
+- Email: team@hivellm.org

vectorizer_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+utils/__init__.py,sha256=JRgKOqRz3LL38p7UbtrdmLjS0KX4dLKXtfxLsybSb-s,1005
+utils/http_client.py,sha256=u206uUPBOHYzZtkyaOXMQY8_qW7VMdtyjtqMSDpuBbU,4644
+utils/transport.py,sha256=BOUVsPjIBTB8aa6O8a41VWsXPCmEfqQixzEFoXvs7tM,3109
+utils/umicp_client.py,sha256=fCOQGDrIG22YJXuWqnn8yYBWWXLrI7-z0G189lg2stE,5585
+utils/validation.py,sha256=YTesbx7csT6vD3zElRhvb-rjsn6O3tr4hlVS89BubKM,4289
+vectorizer_sdk-1.0.0.dist-info/licenses/LICENSE,sha256=AU_2w25hAWjaCMyQy0VFPVRarptCZyIri5-CD3TZbUQ,1094
+vectorizer_sdk-1.0.0.dist-info/METADATA,sha256=HW9kxQ1eYrW1KR64H8ORNkAT2SuCzQ3QAoeemWVRRhE,9723
+vectorizer_sdk-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vectorizer_sdk-1.0.0.dist-info/entry_points.txt,sha256=oKaUZ3DkSvDqN26w_zbh2fRGM0USyVTlfJQN4WHKw8A,44
+vectorizer_sdk-1.0.0.dist-info/top_level.txt,sha256=BXdhaaHBJTl5WDScj-NdcpdW6F1g7hNN3YP0CLPxk-0,6
+vectorizer_sdk-1.0.0.dist-info/RECORD,,

vectorizer_sdk-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vectorizer_sdk-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vectorizer-cli = cli:main

vectorizer_sdk-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2025 CMMV-Hive Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vectorizer_sdk-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+utils