new code added

app.py

@@ -50,100 +50,100 @@ class PDFSearchApp:
             return f"Uploaded and extracted {len(pages)} pages"
         except Exception as e:  # Handle errors during processing
             return f"Error processing PDF: {str(e)}"
-    def search_documents(self, state, query, num_results=3):  # Set num_results to return more pages
-        """
-        Search for a query within indexed PDF documents and return multiple matching pages.
-
-        Args:
-            state (dict): Session state containing user-specific data.
-            query (str): The user's search query.
-            num_results (int): Number of top results to return (default is 3).
-
-        Returns:
-            tuple: (list of image paths, RAG response) or an error message if no match is found.
-        """
-        print(f"Searching for query: {query}")
-        id = generate_uuid(state)  # Get unique user ID
+    # def search_documents(self, state, query, num_results=3):  # Set num_results to return more pages
+    #     """
+    #     Search for a query within indexed PDF documents and return multiple matching pages.
+
+    #     Args:
+    #         state (dict): Session state containing user-specific data.
+    #         query (str): The user's search query.
+    #         num_results (int): Number of top results to return (default is 3).
+
+    #     Returns:
+    #         tuple: (list of image paths, RAG response) or an error message if no match is found.
+    #     """
+    #     print(f"Searching for query: {query}")
+    #     id = generate_uuid(state)  # Get unique user ID
 
-        # Check if the document has been indexed
-        if not self.indexed_docs.get(id, False):
-            print("Please index documents first")
-            return "Please index documents first", None
+    #     # Check if the document has been indexed
+    #     if not self.indexed_docs.get(id, False):
+    #         print("Please index documents first")
+    #         return "Please index documents first", None
 
-        # Check if a query was provided
-        if not query:
-            print("Please enter a search query")
-            return "Please enter a search query", None
+    #     # Check if a query was provided
+    #     if not query:
+    #         print("Please enter a search query")
+    #         return "Please enter a search query", None
 
-        try:
-            # Initialize Middleware for searching
-            middleware = Middleware(id, create_collection=False)
+    #     try:
+    #         # Initialize Middleware for searching
+    #         middleware = Middleware(id, create_collection=False)
 
-            # Perform the search and retrieve the top results
-            search_results = middleware.search([query])  # Returns multiple matches
+    #         # Perform the search and retrieve the top results
+    #         search_results = middleware.search([query])  # Returns multiple matches
 
-            # Check if there are valid search results
-            if not search_results or not search_results[0]:
-                print("No relevant matches found in the PDF")
-                return "No relevant matches found in the PDF", None
+    #         # Check if there are valid search results
+    #         if not search_results or not search_results[0]:
+    #             print("No relevant matches found in the PDF")
+    #             return "No relevant matches found in the PDF", None
 
-            # Extract multiple matching pages (up to num_results)
-            image_paths = []
-            for i in range(min(len(search_results[0]), num_results)):  # Limit to num_results
-                page_num = search_results[0][i][1] + 1  # Convert zero-based index to one-based
-                img_path = f"pages/{id}/page_{page_num}.png"
-                image_paths.append(img_path)
+    #         # Extract multiple matching pages (up to num_results)
+    #         image_paths = []
+    #         for i in range(min(len(search_results[0]), num_results)):  # Limit to num_results
+    #             page_num = search_results[0][i][1] + 1  # Convert zero-based index to one-based
+    #             img_path = f"pages/{id}/page_{page_num}.png"
+    #             image_paths.append(img_path)
 
-            print(f"Retrieved image paths: {image_paths}")
+    #         print(f"Retrieved image paths: {image_paths}")
 
-            # Get an answer from the RAG model using multiple images
-            rag_response = rag.get_answer_from_gemini(query, image_paths)
+    #         # Get an answer from the RAG model using multiple images
+    #         rag_response = rag.get_answer_from_gemini(query, image_paths)
 
-            return image_paths, rag_response  # Return multiple image paths and RAG response
+    #         return image_paths, rag_response  # Return multiple image paths and RAG response
 
-        except Exception as e:
-            # Handle and log any errors that occur
-            print(f"Error during search: {e}")
-            return f"Error during search: {str(e)}", None
+    #     except Exception as e:
+    #         # Handle and log any errors that occur
+    #         print(f"Error during search: {e}")
+    #         return f"Error during search: {str(e)}", None
 
 
-    # # Function to handle search queries within indexed PDFs
-    # def search_documents(self, state, query, num_results=1):
-    #     print(f"Searching for query: {query}")
-    #     id = generate_uuid(state)  # Get unique user ID
+    # Function to handle search queries within indexed PDFs
+    def search_documents(self, state, query, num_results=1):
+        print(f"Searching for query: {query}")
+        id = generate_uuid(state)  # Get unique user ID
 
-    #     # Check if the document has been indexed
-    #     if not self.indexed_docs.get(id, False):
-    #         print("Please index documents first")
-    #         return "Please index documents first", "--"
+        # Check if the document has been indexed
+        if not self.indexed_docs.get(id, False):
+            print("Please index documents first")
+            return "Please index documents first", "--"
 
-    #     # Check if a query was provided
-    #     if not query:
-    #         print("Please enter a search query")
-    #         return "Please enter a search query", "--"
+        # Check if a query was provided
+        if not query:
+            print("Please enter a search query")
+            return "Please enter a search query", "--"
 
-    #     try:
-    #         # Initialize Middleware for searching
-    #         middleware = Middleware(id, create_collection=False)
+        try:
+            # Initialize Middleware for searching
+            middleware = Middleware(id, create_collection=False)
 
-    #         # Perform the search and retrieve the top result
-    #         search_results = middleware.search([query])[0]
+            # Perform the search and retrieve the top result
+            search_results = middleware.search([query])[0]
 
-    #         # Extract the page number from the search results
-    #         page_num = search_results[0][1] + 1
+            # Extract the page number from the search results
+            page_num = search_results[0][1] + 1
 
-    #         print(f"Retrieved page number: {page_num}")
+            print(f"Retrieved page number: {page_num}")
 
-    #         # Construct the image path for the retrieved page
-    #         img_path = f"pages/{id}/page_{page_num}.png"
-    #         print(f"Retrieved image path: {img_path}")
+            # Construct the image path for the retrieved page
+            img_path = f"pages/{id}/page_{page_num}.png"
+            print(f"Retrieved image path: {img_path}")
 
-    #         # Get an answer from the RAG model using the query and associated image
-    #         rag_response = rag.get_answer_from_gemini(query, [img_path])
+            # Get an answer from the RAG model using the query and associated image
+            rag_response = rag.get_answer_from_gemini(query, [img_path])
 
-    #         return img_path, rag_response
-    #     except Exception as e:  # Handle errors during the search process
-    #         return f"Error during search: {str(e)}", "--"
+            return img_path, rag_response
+        except Exception as e:  # Handle errors during the search process
+            return f"Error during search: {str(e)}", "--"
     
 
 # Function to create the Gradio user interface

rag.py

@@ -12,46 +12,46 @@ class Rag:
     based on user queries and associated images.
     """
 
-    # def get_answer_from_gemini(self, query: str, imagePaths: List[str]) -> str:
-    #     """
-    #     Query the Gemini model with a text query and associated images.
+    def get_answer_from_gemini(self, query: str, imagePaths: List[str]) -> str:
+        """
+        Query the Gemini model with a text query and associated images.
 
-    #     Args:
-    #         query (str): The user's query.
-    #         imagePaths (List[str]): List of file paths to images.
+        Args:
+            query (str): The user's query.
+            imagePaths (List[str]): List of file paths to images.
 
-    #     Returns:
-    #         str: The response text from the Gemini model.
-    #     """
-    #     print(f"Querying Gemini for query={query}, imagePaths={imagePaths}")
+        Returns:
+            str: The response text from the Gemini model.
+        """
+        print(f"Querying Gemini for query={query}, imagePaths={imagePaths}")
 
-    #     try:
-    #         # Configure the Gemini API client using the API key from environment variables
-    #         genai.configure(api_key=os.environ['GEMINI_API_KEY'])
+        try:
+            # Configure the Gemini API client using the API key from environment variables
+            genai.configure(api_key=os.environ['GEMINI_API_KEY'])
 
-    #         # Initialize the Gemini generative model
-    #         model = genai.GenerativeModel('gemini-1.5-flash')
+            # Initialize the Gemini generative model
+            model = genai.GenerativeModel('gemini-1.5-flash')
 
-    #         # Load images from the given paths
-    #         images = [Image.open(path) for path in imagePaths]
+            # Load images from the given paths
+            images = [Image.open(path) for path in imagePaths]
 
-    #         # Start a new chat session
-    #         chat = model.start_chat()
+            # Start a new chat session
+            chat = model.start_chat()
 
-    #         # Send the query and images to the model
-    #         response = chat.send_message([*images, query])
+            # Send the query and images to the model
+            response = chat.send_message([*images, query])
 
-    #         # Extract the response text
-    #         answer = response.text
+            # Extract the response text
+            answer = response.text
 
-    #         print(answer)  # Log the answer
+            print(answer)  # Log the answer
 
-    #         return answer
+            return answer
         
-    #     except Exception as e:
-    #         # Handle and log any errors that occur
-    #         print(f"An error occurred while querying Gemini: {e}")
-    #         return f"Error: {str(e)}"
+        except Exception as e:
+            # Handle and log any errors that occur
+            print(f"An error occurred while querying Gemini: {e}")
+            return f"Error: {str(e)}"
 
     def get_answer_from_openai(self, query: str, imagesPaths: List[str]) -> str:
         """
@@ -95,54 +95,54 @@ class Rag:
             # Handle and log any errors that occur
             print(f"An error occurred while querying OpenAI: {e}")
             return None
-    def get_answer_from_gemini(self, query: str, imagePaths: List[str]) -> str:
-        """
-        Query the Gemini model with a text query and associated images.
+    # def get_answer_from_gemini(self, query: str, imagePaths: List[str]) -> str:
+    #     """
+    #     Query the Gemini model with a text query and associated images.
 
-        Args:
-            query (str): The user's query.
-            imagePaths (List[str]): List of file paths to images.
+    #     Args:
+    #         query (str): The user's query.
+    #         imagePaths (List[str]): List of file paths to images.
 
-        Returns:
-            str: The response text from the Gemini model.
-        """
-        print(f"Querying Gemini for query={query}, imagePaths={imagePaths}")
+    #     Returns:
+    #         str: The response text from the Gemini model.
+    #     """
+    #     print(f"Querying Gemini for query={query}, imagePaths={imagePaths}")
 
-        try:
-            # Configure the Gemini API client using the API key from environment variables
-            genai.configure(api_key=os.environ['GEMINI_API_KEY'])
+    #     try:
+    #         # Configure the Gemini API client using the API key from environment variables
+    #         genai.configure(api_key=os.environ['GEMINI_API_KEY'])
 
-            # Initialize the Gemini generative model
-            model = genai.GenerativeModel('gemini-1.5-flash')
+    #         # Initialize the Gemini generative model
+    #         model = genai.GenerativeModel('gemini-1.5-flash')
 
-            # Load images from the given paths (skip missing files)
-            images = []
-            for path in imagePaths:
-                if os.path.exists(path):
-                    images.append(Image.open(path))
-                else:
-                    print(f"Warning: Image not found {path}, skipping.")
+    #         # Load images from the given paths (skip missing files)
+    #         images = []
+    #         for path in imagePaths:
+    #             if os.path.exists(path):
+    #                 images.append(Image.open(path))
+    #             else:
+    #                 print(f"Warning: Image not found {path}, skipping.")
 
-            # Start a new chat session
-            chat = model.start_chat()
+    #         # Start a new chat session
+    #         chat = model.start_chat()
 
-            # Construct the input for the model (handle cases with and without images)
-            input_data = [query] if not images else [*images, query]
+    #         # Construct the input for the model (handle cases with and without images)
+    #         input_data = [query] if not images else [*images, query]
 
-            # Send the query (and images, if any) to the model
-            response = chat.send_message(input_data)
+    #         # Send the query (and images, if any) to the model
+    #         response = chat.send_message(input_data)
 
-            # Extract the response text
-            answer = response.text
+    #         # Extract the response text
+    #         answer = response.text
 
-            print(answer)  # Log the answer
+    #         print(answer)  # Log the answer
 
-            return answer
+    #         return answer
 
-        except Exception as e:
-            # Handle and log any errors that occur
-            print(f"An error occurred while querying Gemini: {e}")
-            return f"Error: {str(e)}"
+    #     except Exception as e:
+    #         # Handle and log any errors that occur
+    #         print(f"An error occurred while querying Gemini: {e}")
+    #         return f"Error: {str(e)}"
 
     def __get_openai_api_payload(self, query: str, imagesPaths: List[str]) -> dict:
         """