Merge pull request #54 from whyhow-ai/37-bug-graceful-exit-error-message-for-wrong-or-incomplete-qdrant-env-settings

37 bug graceful exit error message for wrong or incomplete qdrant env settings

Author: tomsmoker

backend/CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Added support for queries without source data in vector database
 - Graceful failure of triple export when no chunks are found
+- Tested Qdrant vector database service
 
 ### Changed
 

backend/src/app/schemas/query_api.py

@@ -2,7 +2,7 @@
 
 from typing import Any, List, Optional, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 from app.models.query_core import Chunk, FormatType, Rule
 
@@ -23,10 +23,7 @@ class QueryRequestSchema(BaseModel):
     document_id: str
     prompt: QueryPromptSchema
 
-    class Config:
-        """Pydantic configuration."""
-
-        extra = "allow"
+    model_config = ConfigDict(extra="allow")
 
 
 class VectorResponseSchema(BaseModel):

backend/src/app/services/vector_db/base.py

@@ -82,15 +82,20 @@ async def ensure_collection_exists(self) -> None:
     async def get_embeddings(
         self, texts: Union[str, List[str]]
     ) -> List[List[float]]:
-        """Get embeddings for the given text(s) using the LLM service."""
+        """Get embeddings for the given text(s) using the embedding service."""
         if isinstance(texts, str):
             texts = [texts]
         return await self.embedding_service.get_embeddings(texts)
 
+    async def get_single_embedding(self, text: str) -> List[float]:
+        """Get a single embedding for the given text."""
+        embeddings = await self.get_embeddings(text)
+        return embeddings[0]
+
     async def prepare_chunks(
         self, document_id: str, chunks: List[Document]
     ) -> List[Dict[str, Any]]:
-        """Prepare chunks for insertion into the Milvus database."""
+        """Prepare chunks for insertion into the vector database."""
         logger.info(f"Preparing {len(chunks)} chunks")
 
         # Clean the chunks

backend/src/app/services/vector_db/milvus_service.py

@@ -155,9 +155,8 @@ async def vector_search(
         # Search for each query
         for query in queries:
             logger.info("Generating embedding.")
-
-            # Embed the query
-            embedded_query = await self.get_embeddings(query)
+            # Use get_single_embedding but wrap result in list for Milvus
+            embedded_query = [await self.get_single_embedding(query)]
 
             logger.info("Searching...")
 
@@ -323,7 +322,7 @@ def count_keywords(text: str, keywords: List[str]) -> int:
             )
 
         # Embed the query
-        embedded_query = await self.get_embeddings(query)
+        embedded_query = [await self.get_single_embedding(query)]
 
         try:
             # First, let's check if there are any vectors for this document_id

backend/src/app/services/vector_db/qdrant_service.py

@@ -75,7 +75,7 @@ async def vector_search(
 
         for query in queries:
             logger.info("Generating embedding.")
-            embedded_query = await self.get_embeddings(query)
+            embedded_query = await self.get_single_embedding(query)
             logger.info("Searching...")
 
             query_response = self.client.query_points(
@@ -162,7 +162,7 @@ def count_keywords(text: str, keywords: List[str]) -> int:
                 reverse=True,
             )
 
-        embedded_query = await self.get_embeddings(query)
+        embedded_query = await self.get_single_embedding(query)
         logger.info("Running semantic similarity search.")
 
         semantic_response = self.client.query_points(
@@ -194,8 +194,6 @@ def count_keywords(text: str, keywords: List[str]) -> int:
             combined_chunks, key=lambda chunk: chunk["chunk_number"]
         )
 
-        # Optionally, for each chunk, retrieve neighbouring chunks to ensure full context is retrieved
-
         # Eliminate duplicate chunks
         seen_chunks = set()
         formatted_output = []

backend/tests/test_service_vector_db_milvus.py

@@ -13,7 +13,7 @@ def __init__(self, embedding_service, llm_service, settings):
         self.embedding_service = embedding_service
         self.llm_service = llm_service
         self.settings = settings
-        self.client = Mock()  # Use regular Mock instead of AsyncMock
+        self.client = Mock()
 
         # Set up synchronous return values
         self.client.has_collection.return_value = True
@@ -36,12 +36,17 @@ async def upsert_vectors(self, vectors):
         }
 
     async def vector_search(self, queries, document_id):
+        # Mock using get_single_embedding
+        for query in queries:
+            _ = await self.get_single_embedding(query)
         return VectorResponseSchema(message="success", chunks=[])
 
     async def keyword_search(self, query, document_id, keywords):
         return VectorResponseSchema(message="success", chunks=[])
 
     async def hybrid_search(self, query, document_id, rules):
+        # Mock using get_single_embedding
+        _ = await self.get_single_embedding(query)
         return VectorResponseSchema(
             message="Query processed successfully.", chunks=[]
         )
@@ -107,3 +112,27 @@ async def test_delete_document(vector_db_service):
 
     assert result["status"] == "success"
     assert result["message"] == "Document deleted successfully."
+
+
+@pytest.mark.asyncio
+async def test_get_single_embedding(vector_db_service):
+    # Reset the mock before the test
+    vector_db_service.embedding_service.get_embeddings.reset_mock()
+
+    # Mock the embedding service to return a known value
+    vector_db_service.embedding_service.get_embeddings.return_value = [
+        [0.1, 0.2, 0.3]
+    ]
+
+    # Test getting a single embedding
+    result = await vector_db_service.get_single_embedding("test text")
+
+    # Verify the result
+    assert isinstance(result, list)
+    assert len(result) == 3  # Length of our mock embedding
+    assert result == [0.1, 0.2, 0.3]
+
+    # Verify the embedding service was called correctly
+    vector_db_service.embedding_service.get_embeddings.assert_called_once_with(
+        ["test text"]
+    )

backend/tests/test_service_vector_db_qdrant.py

@@ -0,0 +1,157 @@
+from unittest.mock import Mock, patch
+
+import pytest
+
+from app.schemas.query_api import VectorResponseSchema
+from app.services.vector_db.qdrant_service import QdrantService
+
+
+@pytest.fixture
+def mock_qdrant_client():
+    with patch("app.services.vector_db.qdrant_service.QdrantClient") as mock:
+        client = Mock()
+        # Set up mock responses
+        client.collection_exists.return_value = True
+        client.upsert.return_value = None
+
+        # Use a simple Mock instead of Qdrant models
+        response_mock = Mock()
+        response_mock.points = [
+            Mock(
+                payload={
+                    "text": "test text",
+                    "page_number": 1,
+                    "chunk_number": 1,
+                    "document_id": "test_doc",
+                }
+            )
+        ]
+        client.query_points.return_value = response_mock
+
+        client.delete.return_value = None
+        mock.return_value = client
+        yield client
+
+
+@pytest.fixture
+def qdrant_service(
+    mock_embeddings_service,
+    mock_llm_service,
+    test_settings,
+    mock_qdrant_client,
+):
+    service = QdrantService(
+        embedding_service=mock_embeddings_service,
+        llm_service=mock_llm_service,
+        settings=test_settings,
+    )
+    # Override the client with our mock
+    service.client = mock_qdrant_client
+    return service
+
+
+@pytest.mark.asyncio
+async def test_ensure_collection_exists(qdrant_service):
+    await qdrant_service.ensure_collection_exists()
+    assert qdrant_service.client.collection_exists.called
+
+
+@pytest.mark.asyncio
+async def test_upsert_vectors(qdrant_service):
+    vectors = [
+        {
+            "id": "1",
+            "vector": [0.1, 0.2],
+            "text": "test",
+            "page_number": 1,
+            "chunk_number": 1,
+            "document_id": "doc1",
+        }
+    ]
+
+    result = await qdrant_service.upsert_vectors(vectors)
+
+    assert "message" in result
+    assert qdrant_service.client.upsert.called
+
+
+@pytest.mark.asyncio
+async def test_vector_search(qdrant_service, mock_embeddings_service):
+    mock_embeddings_service.get_embeddings.return_value = [[0.1, 0.2]]
+
+    result = await qdrant_service.vector_search(["test query"], "test_doc")
+
+    assert isinstance(result, VectorResponseSchema)
+    assert result.message == "Query processed successfully."
+    assert qdrant_service.client.query_points.called
+
+
+@pytest.mark.asyncio
+async def test_hybrid_search(qdrant_service, mock_embeddings_service):
+    mock_embeddings_service.get_embeddings.return_value = [[0.1, 0.2]]
+
+    with patch.object(
+        qdrant_service,
+        "extract_keywords",
+        return_value=["keyword1", "keyword2"],
+    ):
+        result = await qdrant_service.hybrid_search(
+            "test query", "test_doc", []
+        )
+
+        assert isinstance(result, VectorResponseSchema)
+        assert result.message == "Query processed successfully."
+        assert qdrant_service.client.query_points.called
+
+
+@pytest.mark.asyncio
+async def test_decomposed_search(qdrant_service, mock_llm_service):
+    mock_llm_service.decompose_query.return_value = {
+        "sub-queries": ["query1", "query2"]
+    }
+
+    result = await qdrant_service.decomposed_search(
+        "test query", "test_doc", []
+    )
+
+    assert "sub_queries" in result
+    assert "chunks" in result
+
+
+@pytest.mark.asyncio
+async def test_delete_document(qdrant_service):
+    result = await qdrant_service.delete_document("test_doc")
+
+    assert result["status"] == "success"
+    assert result["message"] == "Document deleted successfully."
+    assert qdrant_service.client.delete.called
+
+
+@pytest.mark.asyncio
+async def test_keyword_search_not_implemented(qdrant_service):
+    with pytest.raises(NotImplementedError):
+        await qdrant_service.keyword_search("query", "doc_id", ["keyword"])
+
+
+@pytest.mark.asyncio
+async def test_get_single_embedding(qdrant_service):
+    # Reset the mock before the test
+    qdrant_service.embedding_service.get_embeddings.reset_mock()
+
+    # Mock the embedding service to return a known value
+    qdrant_service.embedding_service.get_embeddings.return_value = [
+        [0.1, 0.2, 0.3]
+    ]
+
+    # Test getting a single embedding
+    result = await qdrant_service.get_single_embedding("test text")
+
+    # Verify the result
+    assert isinstance(result, list)
+    assert len(result) == 3
+    assert result == [0.1, 0.2, 0.3]
+
+    # Verify the embedding service was called correctly
+    qdrant_service.embedding_service.get_embeddings.assert_called_once_with(
+        ["test text"]
+    )