new_version_changes3.0

app.py

@@ -10,6 +10,7 @@ from dotenv import load_dotenv
 import os
 import torch
 from utils.auth_x import x_api_key_auth
+import time
 
 # Load environment variables from .env file
 load_dotenv()
@@ -25,6 +26,8 @@ hf_home_dir = os.environ["HF_HOME"]
 if not os.path.exists(hf_home_dir):
     os.makedirs(hf_home_dir)
 
+collection_name = os.getenv('QDRANT_COLLECTION_NAME')
+logging.info(f"Collection name: {collection_name}")
 # Setup logging using Python's standard logging library
 logging.basicConfig(level=logging.INFO)
 
@@ -76,14 +79,17 @@ def embed_text(text):
 class SearchDocumentsRequest(BaseModel):
     query: str
     limit: int = 3
+    file_id: str = None
 
 class GenerateRAGRequest(BaseModel):
     search_query: str
+    file_id: str = None
 
 class XApiKeyRequest(BaseModel):
     organization_id: str
     user_id: str
     search_query: str  
+    file_id: str = None
 
 
 @app.get("/")
@@ -97,7 +103,7 @@ async def search_documents(
     credentials: tuple = Depends(token_required)
 ):
     customer_id, user_id = credentials
-
+    start_time = time.time()
     if not customer_id or not user_id:
         logging.error("Failed to extract customer_id or user_id from the JWT token.")
         raise HTTPException(status_code=401, detail="Invalid token: missing customer_id or user_id")
@@ -109,17 +115,19 @@ async def search_documents(
         # Encode the query using the custom embedding function
         query_embedding = embed_text(body.query)
         print(body.query)
-        collection_name = "embed"  # Use the collection name where the embeddings are stored    
-
+        #collection_name = "embed"  # Use the collection name where the embeddings are stored    
         logging.info("Performing search using the precomputed embeddings")
+        if body.file_id:
+            hits, error = searcher.search_documents(collection_name, query_embedding, user_id, body.limit, file_id=body.file_id)
         # Perform search using the precomputed embeddings
         hits, error = searcher.search_documents(collection_name, query_embedding, user_id, body.limit)
         
         if error:
             logging.error(f"Search documents error: {error}")
             raise HTTPException(status_code=500, detail=error)
-
-        return hits
+        end_time = time.time()
+        time_taken = end_time - start_time
+        return hits, time_taken
     except Exception as e:
         logging.error(f"Unexpected error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
@@ -131,31 +139,41 @@ async def generate_rag_response_api(
     credentials: tuple = Depends(token_required)
 ):
     customer_id, user_id = credentials
-
+    start_time = time.time()
     if not customer_id or not user_id:
         logging.error("Failed to extract customer_id or user_id from the JWT token.")
         raise HTTPException(status_code=401, detail="Invalid token: missing customer_id or user_id")
 
     logging.info("Received request to generate RAG response")
+    
     try:
+        search_time = time.time()
         logging.info("Starting document search")
-
         # Encode the query using the custom embedding function
         query_embedding = embed_text(body.search_query)
         print(body.search_query)
-        collection_name = "embed"  # Use the collection name where the embeddings are stored   
+        #collection_name = "embed"  # Use the collection name where the embeddings are stored   
         # Perform search using the precomputed embeddings
-        hits, error = searcher.search_documents(collection_name, query_embedding, user_id)
+        if body.file_id:
+            hits, error = searcher.search_documents(collection_name, query_embedding, user_id, file_id=body.file_id)
+        else:
+            hits, error = searcher.search_documents(collection_name, query_embedding, user_id)
         
         if error:
             logging.error(f"Search documents error: {error}")
             raise HTTPException(status_code=500, detail=error)
 
         logging.info("Generating RAG response")
-
+        end_search_time = time.time()
+        search_time_taken = end_search_time - search_time
+        rag_start_time = time.time()
         # Generate the RAG response using the retrieved documents
         response, error = generate_rag_response(hits, body.search_query)
-        
+        rag_end_time = time.time()
+        rag_time_taken = rag_end_time - rag_start_time
+        end_time= time.time()
+        total_time = end_time - start_time
+        logging.info(f"Search time: {search_time_taken}, RAG time: {rag_time_taken}, Total time: {total_time}")
         if error:
             logging.error(f"Generate RAG response error: {error}")
             raise HTTPException(status_code=500, detail=error)
@@ -172,9 +190,11 @@ async def search_documents_x_api_key(
 ):
     if not authorized:
         raise HTTPException(status_code=401, detail="Unauthorized")
-
+    start_time = time.time()
     organization_id = body.organization_id
     user_id = body.user_id
+    file_id = body.file_id
+
     logging.info(f'search query {body.search_query}')
     logging.info(f"organization_id: {organization_id}, user_id: {user_id}")
     logging.info("Received request to search documents with x-api-key auth")
@@ -183,16 +203,18 @@ async def search_documents_x_api_key(
 
         # Encode the query using the custom embedding function
         query_embedding = embed_text(body.search_query)
-        collection_name = "embed"  # Use the collection name where the embeddings are stored   
+        #collection_name = "embed"  # Use the collection name where the embeddings are stored   
 
         # Perform search using the precomputed embeddings
-        hits, error = searcher.search_documents(collection_name, query_embedding, user_id, limit=3)
+        hits, error = searcher.search_documents(collection_name, query_embedding, user_id, limit=3, file_id=file_id)
         
         if error:
             logging.error(f"Search documents error: {error}")
             raise HTTPException(status_code=500, detail=error)
 
         logging.info(f"Document search completed with {len(hits)} hits")
+        end_time = time.time()
+        logging.info(f"Time taken: {end_time - start_time}")
         return hits
     except Exception as e:
         logging.error(f"Unexpected error: {e}")
@@ -206,9 +228,10 @@ async def generate_rag_response_x_api_key(
     # Assuming x_api_key_auth validates the key
     if not authorized:
         raise HTTPException(status_code=401, detail="Unauthorized")
-
+    start_time = time.time()
     organization_id = body.organization_id
     user_id = body.user_id
+    file_id = body.file_id
 
     logging.info(f'search query {body.search_query}')
     logging.info(f"organization_id: {organization_id}, user_id: {user_id}")
@@ -218,10 +241,10 @@ async def generate_rag_response_x_api_key(
 
         # Encode the query using the custom embedding function
         query_embedding = embed_text(body.search_query)
-        collection_name = "embed"  # Use the collection name where the embeddings are stored   
+        #collection_name = "embed"  # Use the collection name where the embeddings are stored   
 
         # Perform search using the precomputed embeddings
-        hits, error = searcher.search_documents(collection_name, query_embedding, user_id)
+        hits, error = searcher.search_documents(collection_name, query_embedding, user_id, file_id=file_id)
         
         if error:
             logging.error(f"Search documents error: {error}")
@@ -235,7 +258,8 @@ async def generate_rag_response_x_api_key(
         if error:
             logging.error(f"Generate RAG response error: {error}")
             raise HTTPException(status_code=500, detail=error)
-
+        end_time = time.time()
+        logging.info(f"Time taken: {end_time - start_time}")
         return {"response": response}
     except Exception as e:
         logging.error(f"Unexpected error: {e}")

services/openai_service.py

@@ -28,7 +28,7 @@ def generate_rag_response(json_output, user_query):
 
     # Create the context for the prompt
     context = "\n".join(context_texts)
-    prompt = f"Based on the given context, answer the user query: {user_query}\nContext:\n{context}"
+    prompt = f"Based on the given context, answer the user query: {user_query}\nContext:\n{context} and Employ references to the ID of articles provided [ID], ensuring their relevance to the query. The referencing should always be in the format of [1][2]... etc. </instructions> "
 
     main_prompt = [
         {"role": "system", "content": "You are a helpful assistant."},
@@ -39,7 +39,7 @@ def generate_rag_response(json_output, user_query):
         # Create a chat completion request
         chat_completion = client.chat.completions.create(
             messages=main_prompt,
-            model="gpt-35-turbo",  # Use the gpt-4o-mini model
+            model="urdu-llama",  # Use the gpt-4o-mini model
             max_tokens=2000,  # Limit the maximum number of tokens in the response    
             temperature=0.5  
         )

services/qdrant_searcher.py

@@ -3,12 +3,13 @@ import torch
 import numpy as np
 from qdrant_client import QdrantClient
 from qdrant_client.http.models import Filter, FieldCondition
+from collections import defaultdict
 
 class QdrantSearcher:
     def __init__(self, qdrant_url, access_token):
         self.client = QdrantClient(url=qdrant_url, api_key=access_token)
 
-    def search_documents(self, collection_name, query_embedding, user_id, limit=3,similarity_threshold=0.6):
+    def search_documents(self, collection_name, query_embedding, user_id, limit=3,similarity_threshold=0.6, file_id=None):
         logging.info("Starting document search")
 
         # Ensure the query_embedding is in the correct format (flat list of floats)
@@ -23,8 +24,13 @@ class QdrantSearcher:
         if not all(isinstance(x, float) for x in query_embedding):
             raise ValueError("All elements in query_embedding must be of type float")
 
+        filter_conditions = [FieldCondition(key="user_id", match={"value": user_id})]
+
+        if file_id:
+            filter_conditions.append(FieldCondition(key="file_id", match={"value": file_id}))
+
         # Filter by user_id
-        query_filter = Filter(must=[FieldCondition(key="user_id", match={"value": user_id})])
+        query_filter = Filter(must=filter_conditions)
         logging.info(f"Performing search using the precomputed embeddings for user_id: {user_id}")
         try:
             hits = self.client.search(
@@ -49,6 +55,7 @@ class QdrantSearcher:
                 "id": hit.id,
                 "score": hit.score,
                 "file_id": hit.payload.get('file_id'),
+                "file_name": hit.payload.get('file_name'),
                 "organization_id": hit.payload.get('organization_id'),
                 "chunk_index": hit.payload.get('chunk_index'),
                 "chunk_text": hit.payload.get('chunk_text'),
@@ -59,3 +66,59 @@ class QdrantSearcher:
         logging.info(f"Document search completed with {len(hits_list)} hits")
         logging.info(f"Hits: {hits_list}")
         return hits_list, None
+    
+    def search_documents_grouped(self, collection_name, query_embedding, user_id, limit=60, similarity_threshold=0.6, file_id=None):
+        logging.info("Starting grouped document search")
+
+        if isinstance(query_embedding, torch.Tensor):
+            query_embedding = query_embedding.detach().numpy().flatten().tolist()
+        elif isinstance(query_embedding, np.ndarray):
+            query_embedding = query_embedding.flatten().tolist()
+        else:
+            raise ValueError("query_embedding must be a torch.Tensor or numpy.ndarray")
+
+        if not all(isinstance(x, float) for x in query_embedding):
+            raise ValueError("All elements in query_embedding must be of type float")
+        #query_filter = Filter(must=[FieldCondition(key="user_id", match={"value": user_id})])
+        filter_conditions = [FieldCondition(key="user_id", match={"value": user_id})]
+
+        if file_id:
+            filter_conditions.append(FieldCondition(key="file_id", match={"value": file_id}))
+
+        # Filter by user_id
+        query_filter = Filter(must=filter_conditions)
+        logging.info(f"Performing grouped search using the precomputed embeddings for user_id: {user_id}")
+        try:
+            hits = self.client.search(
+                collection_name=collection_name,
+                query_vector=query_embedding,
+                limit=limit,
+                query_filter=query_filter
+            )
+        except Exception as e:
+            logging.error(f"Error during Qdrant search: {e}")
+            return None, str(e)
+        
+        #filtered_hits = [hit for hit in hits if hit.score >= similarity_threshold]
+
+        if not hits:
+            logging.info("No documents found for the given query")
+            return None, "No documents found for the given query."
+        
+        # Group hits by filename and calculate average score 
+        grouped_hits = defaultdict(list)
+        for hit in hits:
+            grouped_hits[hit.payload.get('file_name')].append(hit.score)
+
+        grouped_results = []
+        for file_name, scores in grouped_hits.items():
+            average_score = sum(scores) / len(scores)
+            grouped_results.append({
+                "file_name": file_name,
+                "average_score": average_score
+            })
+
+        logging.info(f"Grouped search completed with {len(grouped_results)} results")
+        logging.info(f"Grouped Hits: {grouped_results}")
+        return grouped_results, None
+