Delete old qdrant_retriever.py

app/infrastructure/external/qdrant_retriever.py

@@ -1,133 +0,0 @@
-"""
-Infrastructure - Qdrant Vector Store
-"""
-from typing import Dict, List, Optional
-from uuid import UUID
-
-from qdrant_client import AsyncQdrantClient
-from qdrant_client.models import Distance, PointStruct, VectorParams, Filter, FieldCondition, MatchValue
-
-from app.domain.interfaces import IRetriever, RetrievalResult
-
-
-class QdrantRetriever(IRetriever):
-    """Qdrant vector store implementation"""
-
-    def __init__(
-        self,
-        url: str,
-        collection_name: str,
-        vector_size: int = 384,
-        api_key: Optional[str] = None,
-    ):
-        self.url = url
-        self.collection_name = collection_name
-        self.vector_size = vector_size
-        
-        # Handle in-memory mode
-        if url.startswith("memory://"):
-            self.client = AsyncQdrantClient(location=":memory:")
-        else:
-            self.client = AsyncQdrantClient(url=url, api_key=api_key)
-
-    async def initialize_collection(self) -> None:
-        """Initialize Qdrant collection"""
-        collections = await self.client.get_collections()
-        collection_names = [c.name for c in collections.collections]
-
-        if self.collection_name not in collection_names:
-            await self.client.create_collection(
-                collection_name=self.collection_name,
-                vectors_config=VectorParams(size=self.vector_size, distance=Distance.COSINE),
-            )
-
-    async def search(
-        self,
-        query: str,
-        top_k: int = 10,
-        filters: Optional[dict] = None,
-        min_score: float = 0.0,
-    ) -> List[RetrievalResult]:
-        """Search for relevant documents"""
-        # Note: This requires embedding the query first
-        # In practice, this would be called with query_vector
-        raise NotImplementedError("Use search_by_vector instead")
-
-    async def search_by_vector(
-        self,
-        query_vector: List[float],
-        top_k: int = 10,
-        filters: Optional[dict] = None,
-        min_score: float = 0.0,
-    ) -> List[RetrievalResult]:
-        """Search by pre-computed vector"""
-
-        # Build filter
-        qdrant_filter = None
-        if filters:
-            conditions = []
-            for key, value in filters.items():
-                conditions.append(
-                    FieldCondition(key=key, match=MatchValue(value=value))
-                )
-            if conditions:
-                qdrant_filter = Filter(must=conditions)
-
-        # Search
-        search_result = await self.client.search(
-            collection_name=self.collection_name,
-            query_vector=query_vector,
-            limit=top_k,
-            query_filter=qdrant_filter,
-            score_threshold=min_score,
-        )
-
-        # Convert to RetrievalResult
-        results = []
-        for hit in search_result:
-            payload = hit.payload or {}
-            results.append(
-                RetrievalResult(
-                    content=payload.get("content", ""),
-                    score=hit.score,
-                    document_id=payload.get("document_id", ""),
-                    chunk_index=payload.get("chunk_index", 0),
-                    metadata=payload.get("metadata", {}),
-                )
-            )
-
-        return results
-
-    async def hybrid_search(
-        self,
-        query: str,
-        top_k: int = 10,
-        alpha: float = 0.5,
-        filters: Optional[dict] = None,
-    ) -> List[RetrievalResult]:
-        """Hybrid search (dense + sparse)"""
-        # TODO: Implement hybrid search with BM25
-        raise NotImplementedError("Hybrid search not yet implemented")
-
-    async def add_documents(
-        self,
-        vectors: List[List[float]],
-        documents: List[Dict],
-        ids: Optional[List[str]] = None,
-    ) -> None:
-        """Add documents to collection"""
-        points = []
-        for i, (vector, doc) in enumerate(zip(vectors, documents)):
-            point_id = ids[i] if ids else str(UUID(int=i))
-            points.append(
-                PointStruct(
-                    id=point_id,
-                    vector=vector,
-                    payload=doc,
-                )
-            )
-
-        await self.client.upsert(
-            collection_name=self.collection_name,
-            points=points,
-        )