feat(qdrant): epic 4 - complete qdrant semantic cache implementation (tasks #61-77)

app/cache/qdrant_client.py

@@ -0,0 +1,118 @@
+"""
+Qdrant client connection manager.
+
+Sandi Metz Principles:
+- Single Responsibility: Qdrant connection management
+- Small methods: Each operation isolated
+- Dependency Injection: Configuration injected
+"""
+
+from typing import Optional
+
+from qdrant_client import AsyncQdrantClient
+from qdrant_client.http.exceptions import UnexpectedResponse
+
+from app.config import config
+from app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+async def create_qdrant_client() -> AsyncQdrantClient:
+    """
+    Create Qdrant async client connection.
+
+    Returns:
+        Qdrant async client
+
+    Raises:
+        ConnectionError: If connection fails
+    """
+    try:
+        client = AsyncQdrantClient(
+            host=config.qdrant_host,
+            port=config.qdrant_port,
+            timeout=30.0,
+        )
+
+        # Test connection
+        await client.get_collections()
+
+        logger.info(
+            "Qdrant client connected",
+            host=config.qdrant_host,
+            port=config.qdrant_port,
+        )
+
+        return client
+
+    except Exception as e:
+        logger.error("Qdrant connection failed", error=str(e))
+        raise ConnectionError(f"Failed to connect to Qdrant: {e}")
+
+
+class QdrantConnectionManager:
+    """
+    Manages Qdrant client connection lifecycle.
+
+    Handles connection pooling and health checks.
+    """
+
+    def __init__(self):
+        """Initialize connection manager."""
+        self._client: Optional[AsyncQdrantClient] = None
+
+    async def get_client(self) -> AsyncQdrantClient:
+        """
+        Get or create Qdrant client.
+
+        Returns:
+            Qdrant async client
+
+        Raises:
+            ConnectionError: If connection fails
+        """
+        if self._client is None:
+            self._client = await create_qdrant_client()
+        return self._client
+
+    async def close(self) -> None:
+        """Close Qdrant client connection."""
+        if self._client is not None:
+            try:
+                await self._client.close()
+                logger.info("Qdrant client closed")
+            except Exception as e:
+                logger.error("Failed to close Qdrant client", error=str(e))
+            finally:
+                self._client = None
+
+    async def health_check(self) -> bool:
+        """
+        Check Qdrant server health.
+
+        Returns:
+            True if healthy, False otherwise
+        """
+        try:
+            client = await self.get_client()
+            await client.get_collections()
+            return True
+        except Exception as e:
+            logger.error("Qdrant health check failed", error=str(e))
+            return False
+
+    async def reconnect(self) -> bool:
+        """
+        Reconnect to Qdrant server.
+
+        Returns:
+            True if reconnected successfully
+        """
+        try:
+            await self.close()
+            self._client = await create_qdrant_client()
+            return True
+        except Exception as e:
+            logger.error("Qdrant reconnection failed", error=str(e))
+            return False

app/cache/qdrant_collection.py

@@ -0,0 +1,167 @@
+"""
+Qdrant collection initialization and management.
+
+Sandi Metz Principles:
+- Single Responsibility: Collection setup and validation
+- Small methods: Each operation isolated
+- Dependency Injection: Repository injected
+"""
+
+from typing import Optional
+
+from qdrant_client.models import Distance
+
+from app.repositories.qdrant_repository import QdrantRepository
+from app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class QdrantCollectionManager:
+    """
+    Manages Qdrant collection initialization.
+
+    Ensures collection exists and is properly configured.
+    """
+
+    def __init__(self, repository: QdrantRepository):
+        """
+        Initialize collection manager.
+
+        Args:
+            repository: Qdrant repository
+        """
+        self._repository = repository
+
+    async def initialize(
+        self, distance: Distance = Distance.COSINE, recreate: bool = False
+    ) -> bool:
+        """
+        Initialize collection for vector storage.
+
+        Args:
+            distance: Distance metric for similarity
+            recreate: Whether to recreate existing collection
+
+        Returns:
+            True if initialized successfully
+        """
+        try:
+            if recreate:
+                await self._recreate_collection(distance)
+                return True
+
+            return await self._ensure_collection_exists(distance)
+
+        except Exception as e:
+            logger.error("Collection initialization failed", error=str(e))
+            return False
+
+    async def _ensure_collection_exists(self, distance: Distance) -> bool:
+        """
+        Ensure collection exists.
+
+        Args:
+            distance: Distance metric
+
+        Returns:
+            True if exists or created
+        """
+        exists = await self._repository.collection_exists()
+
+        if exists:
+            logger.info("Collection verified")
+            return True
+
+        return await self._repository.create_collection(distance)
+
+    async def _recreate_collection(self, distance: Distance) -> bool:
+        """
+        Recreate collection (delete and create).
+
+        Args:
+            distance: Distance metric
+
+        Returns:
+            True if recreated successfully
+        """
+        logger.warning("Recreating collection - all data will be lost")
+
+        # Delete if exists
+        exists = await self._repository.collection_exists()
+        if exists:
+            await self._repository.delete_collection()
+
+        # Create new collection
+        return await self._repository.create_collection(distance)
+
+    async def validate_collection(self) -> dict[str, bool]:
+        """
+        Validate collection configuration.
+
+        Returns:
+            Validation results dict
+        """
+        results = {
+            "exists": False,
+            "accessible": False,
+            "configured": False,
+        }
+
+        try:
+            # Check existence
+            results["exists"] = await self._repository.collection_exists()
+            if not results["exists"]:
+                return results
+
+            # Check accessibility
+            results["accessible"] = await self._repository.ping()
+            if not results["accessible"]:
+                return results
+
+            # Check configuration
+            info = await self._repository.get_collection_info()
+            results["configured"] = info is not None
+
+            return results
+
+        except Exception as e:
+            logger.error("Collection validation failed", error=str(e))
+            return results
+
+    async def get_status(self) -> Optional[dict]:
+        """
+        Get collection status and statistics.
+
+        Returns:
+            Status dict if successful
+        """
+        try:
+            validation = await self.validate_collection()
+            if not validation["exists"]:
+                return {
+                    "status": "not_initialized",
+                    "message": "Collection does not exist",
+                }
+
+            info = await self._repository.get_collection_info()
+            if not info:
+                return {
+                    "status": "error",
+                    "message": "Failed to get collection info",
+                }
+
+            return {
+                "status": "ready",
+                "vectors_count": info["vectors_count"],
+                "points_count": info["points_count"],
+                "collection_status": info["status"],
+                "config": info["config"],
+            }
+
+        except Exception as e:
+            logger.error("Get status failed", error=str(e))
+            return {
+                "status": "error",
+                "message": str(e),
+            }