fixed qudrant search query

main.py

@@ -1,55 +1,79 @@
 # main.py
-from fastapi import FastAPI,status,Response,Request,Depends,HTTPException,UploadFile, File,BackgroundTasks
-from fastapi.responses import StreamingResponse,FileResponse
-from models import load_text_model,generate_text,load_audio_model,generate_audio,load_image_model, generate_image
+from fastapi import (
+    FastAPI,
+    status,
+    Response,
+    Request,
+    Depends,
+    HTTPException,
+    UploadFile,
+    File,
+    BackgroundTasks,
+)
+from fastapi.responses import StreamingResponse, FileResponse
+from models import (
+    load_text_model,
+    generate_text,
+    load_audio_model,
+    generate_audio,
+    load_image_model,
+    generate_image,
+)
 from schemas import VoicePresets
-from utils import audio_array_to_buffer,img_to_bytes
+from utils import audio_array_to_buffer, img_to_bytes
 from contextlib import asynccontextmanager
-from typing import AsyncIterator,Callable,Awaitable,Annotated
+from typing import AsyncIterator, Callable, Awaitable, Annotated
 from uuid import uuid4
 import time
 from datetime import datetime, timezone
 import csv
-from dependencies import get_urls_content,get_rag_content
-from schemas import TextModelResponse,TextModelRequest
+from dependencies import get_urls_content, get_rag_content
+from schemas import TextModelResponse, TextModelRequest
 import shutil, uuid
 from upload import save_file
 from rag import pdf_text_extractor, vector_service
+from scalar_fastapi import get_scalar_api_reference
 
+models = {}
 
-models = {} 
 
-@asynccontextmanager 
+@asynccontextmanager
 async def lifespan(_: FastAPI) -> AsyncIterator[None]:
-    # models["text2image"] = load_image_model() 
+    # models["text2image"] = load_image_model()
     # models["text"]=load_text_model()
-    yield 
-    models.clear() 
+    yield
+    models.clear()
+
 
 app = FastAPI(lifespan=lifespan)
 
 csv_header = [
-    "Request ID", "Datetime", "Endpoint Triggered", "Client IP Address",
-    "Response Time", "Status Code", "Successful"
+    "Request ID",
+    "Datetime",
+    "Endpoint Triggered",
+    "Client IP Address",
+    "Response Time",
+    "Status Code",
+    "Successful",
 ]
 
 
-@app.middleware("http") 
+@app.middleware("http")
 async def monitor_service(
     req: Request, call_next: Callable[[Request], Awaitable[Response]]
-) -> Response: 
-    request_id = uuid4().hex 
+) -> Response:
+    request_id = uuid4().hex
     request_datetime = datetime.now(timezone.utc).isoformat()
     start_time = time.perf_counter()
     response: Response = await call_next(req)
-    response_time = round(time.perf_counter() - start_time, 4) 
+    response_time = round(time.perf_counter() - start_time, 4)
     response.headers["X-Response-Time"] = str(response_time)
-    response.headers["X-API-Request-ID"] = request_id 
+    response.headers["X-API-Request-ID"] = request_id
     with open("usage.csv", "a", newline="") as file:
         writer = csv.writer(file)
         if file.tell() == 0:
             writer.writerow(csv_header)
-        writer.writerow( 
+        writer.writerow(
             [
                 request_id,
                 request_datetime,
@@ -63,21 +87,24 @@ async def monitor_service(
     return response
 
 
-
-
-# app = FastAPI() 
+# app = FastAPI()
 @app.get("/")
 def root_controller():
     return {"status": "healthy"}
 
-@app.post("/generate/text") 
-async def serve_language_model_controller(request: Request,
-    body: TextModelRequest ,
-    urls_content: str = Depends(get_urls_content), rag_content: str = Depends(get_rag_content)) -> TextModelResponse: 
-    prompt = body.prompt + " " + urls_content +rag_content
-    output =  generate_text(models["text"], prompt, body.temperature)
+
+@app.post("/generate/text")
+async def serve_language_model_controller(
+    request: Request,
+    body: TextModelRequest,
+    urls_content: str = Depends(get_urls_content),
+    rag_content: str = Depends(get_rag_content),
+) -> TextModelResponse:
+    prompt = body.prompt + " " + urls_content + rag_content
+    output = generate_text(models["text"], prompt, body.temperature)
     return TextModelResponse(content=output, ip=request.client.host)
 
+
 @app.get("/logs")
 def get_logs():
     # return FileResponse("usage.csv", media_type='text/csv', filename="usage.csv")
@@ -89,14 +116,15 @@ def get_logs():
         temp_file,
         media_type="text/csv",
         filename="logs.csv",
-        headers={"Content-Disposition": "attachment; filename=logs.csv"}
+        headers={"Content-Disposition": "attachment; filename=logs.csv"},
     )
 
+
 @app.get(
     "/generate/audio",
     responses={status.HTTP_200_OK: {"content": {"audio/wav": {}}}},
     response_class=StreamingResponse,
-) 
+)
 def serve_text_to_audio_model_controller(
     prompt: str,
     preset: VoicePresets = "v2/en_speaker_1",
@@ -108,14 +136,22 @@ def serve_text_to_audio_model_controller(
     )
 
 
-@app.get("/generate/image",
-         responses={status.HTTP_200_OK: {"content": {"image/png": {}}}}, 
-         response_class=Response) 
+@app.get(
+    "/generate/image",
+    responses={status.HTTP_200_OK: {"content": {"image/png": {}}}},
+    response_class=Response,
+)
 def serve_text_to_image_model_controller(prompt: str):
     # pipe = load_image_model()
-    # output = generate_image(pipe, prompt) 
+    # output = generate_image(pipe, prompt)
     output = generate_image(models["text2image"], prompt)
-    return Response(content=img_to_bytes(output), media_type="image/png") 
+    return Response(content=img_to_bytes(output), media_type="image/png")
+
+
+@app.get("/scalar")
+def get_scalar_docs():
+    return get_scalar_api_reference(openapi_url=app.openapi_url, title=app.title)
+
 
 # @app.post("/upload")
 # async def file_upload_controller(
@@ -139,13 +175,13 @@ def serve_text_to_image_model_controller(prompt: str):
 @app.post("/upload")
 async def file_upload_controller(
     file: Annotated[UploadFile, File(description="A file read as UploadFile")],
-    bg_text_processor: BackgroundTasks, 
+    bg_text_processor: BackgroundTasks,
 ):
-    ... # Raise an HTTPException if data upload is not a PDF file
+    ...  # Raise an HTTPException if data upload is not a PDF file
     try:
         filepath = await save_file(file)
-        bg_text_processor.add_task(pdf_text_extractor, filepath) 
-        bg_text_processor.add_task( 
+        bg_text_processor.add_task(pdf_text_extractor, filepath)
+        bg_text_processor.add_task(
             vector_service.store_file_content_in_db,
             filepath.replace("pdf", "txt"),
             512,

rag/repository.py

@@ -3,27 +3,26 @@ from qdrant_client import AsyncQdrantClient
 from qdrant_client.http import models
 from qdrant_client.http.models import ScoredPoint
 
-class VectorRepository: 
-    def __init__(self, host: str = "https://ahmed-eisa-qdrant-db.hf.space", port: int = 6333) -> None:
+
+class VectorRepository:
+    def __init__(
+        self, host: str = "https://ahmed-eisa-qdrant-db.hf.space", port: int = 6333
+    ) -> None:
         # self.db_client = AsyncQdrantClient(host=host, port=port)
         self.db_client = AsyncQdrantClient(
-                url="https://e8342d34-1b50-48e3-95e2-d4eacd0755eb.us-east4-0.gcp.cloud.qdrant.io:6333", 
-                api_key="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.Q6rLdYDzVyr10B4AdYJHcPp9pCqWG7yhQ-NNmfWZqg8",
-                )
-    async def create_collection(self, collection_name: str, size: int) -> bool: 
-        vectors_config = models.VectorParams(
-            size=size, distance=models.Distance.COSINE 
+            url="https://e8342d34-1b50-48e3-95e2-d4eacd0755eb.us-east4-0.gcp.cloud.qdrant.io:6333",
+            api_key="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.Q6rLdYDzVyr10B4AdYJHcPp9pCqWG7yhQ-NNmfWZqg8",
         )
+
+    async def create_collection(self, collection_name: str, size: int) -> bool:
+        vectors_config = models.VectorParams(size=size, distance=models.Distance.COSINE)
         response = await self.db_client.get_collections()
 
         collection_exists = any(
-            collection.name == collection_name
-            for collection in response.collections
+            collection.name == collection_name for collection in response.collections
         )
-        if collection_exists: 
-            logger.debug(
-                f"Collection {collection_name} already exists - recreating it"
-            )
+        if collection_exists:
+            logger.debug(f"Collection {collection_name} already exists - recreating it")
             await self.db_client.delete_collection(collection_name)
             return await self.db_client.create_collection(
                 collection_name,
@@ -73,15 +72,15 @@ class VectorRepository:
         collection_name: str,
         query_vector: list[float],
         retrieval_limit: int,
-        score_threshold: float, 
+        score_threshold: float,
     ) -> list[ScoredPoint]:
         logger.debug(
             f"Searching for relevant items in the {collection_name} collection"
         )
         response = await self.db_client.query_points(
             collection_name=collection_name,
-            vector=query_vector,
+            query=query_vector,
             limit=retrieval_limit,
             score_threshold=score_threshold,
         )
-        return response.points
+        return response.points