Update app.py

app.py

@@ -8,8 +8,12 @@ from langchain.vectorstores import FAISS
 from langchain.schema import Document
 from duckduckgo_search import DDGS
 
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
 # Environment variables and configurations
 huggingface_token = os.environ.get("HUGGINGFACE_TOKEN")
+logging.info("Environment variable for HuggingFace token retrieved.")
 
 MODELS = [
     "mistralai/Mistral-7B-Instruct-v0.3",
@@ -18,20 +22,31 @@ MODELS = [
     "meta-llama/Meta-Llama-3.1-8B-Instruct",
     "meta-llama/Meta-Llama-3.1-70B-Instruct"
 ]
+logging.info(f"Models list initialized with {len(MODELS)} models.")
 
 def get_embeddings():
+    logging.info("Loading HuggingFace embeddings model.")
     return HuggingFaceEmbeddings(model_name="sentence-transformers/stsb-roberta-large")
 
 def duckduckgo_search(query):
-    with DDGS() as ddgs:
-        results = ddgs.text(query, max_results=10)
-    return results
+    logging.info(f"Initiating DuckDuckGo search for query: {query}")
+    try:
+        with DDGS() as ddgs:
+            results = ddgs.text(query, max_results=10)
+        logging.info(f"Search completed, found {len(results)} results.")
+        return results
+    except Exception as e:
+        logging.error(f"Error during DuckDuckGo search: {str(e)}")
+        return []
 
 async def rephrase_query(query, history, model):
-    system_message = """You are an AI assistant tasked with analyzing and rephrasing user queries. Your goal is to determine if a query is unique or related to the previous conversation, and then rephrase it appropriately for web search. Keep the rephrased query succinct and in a web search query format.
+    logging.info("Rephrasing query based on history and model.")
+    system_message = """You are an AI assistant tasked with analyzing and rephrasing user queries. 
+    Your goal is to determine whether the query is unique or related to the previous conversation, and then rephrase it appropriately for web search. 
+    The rephrased query should be succinct and optimized for search engines.
 
-    If the query is unique, rephrase it to be more specific and searchable.
-    If the query is related to the previous conversation, incorporate relevant context from the previous response.
+    If the query is unique (i.e., unrelated to the conversation), rephrase it to make it more specific and searchable.
+    If the query is related to the previous conversation, incorporate relevant context from the conversation to enhance search relevance.
 
     Provide your analysis in the following format:
     <analysis>Your reasoning about whether the query is unique or related</analysis>
@@ -47,12 +62,14 @@ async def rephrase_query(query, history, model):
     client = InferenceClient(model, token=huggingface_token)
     
     try:
+        logging.info(f"Sending rephrase request to model {model}.")
         response = await asyncio.to_thread(
             client.text_generation,
             prompt=f"{system_message}\n\n{user_message}",
             max_new_tokens=150,
             temperature=0.2,
         )
+        logging.info("Rephrase response received.")
         
         # Extract the rephrased query from the response
         analysis_start = response.find("<analysis>")
@@ -63,36 +80,43 @@ async def rephrase_query(query, history, model):
         if analysis_start != -1 and analysis_end != -1 and rephrased_start != -1 and rephrased_end != -1:
             analysis = response[analysis_start + 10:analysis_end].strip()
             rephrased_query = response[rephrased_start + 17:rephrased_end].strip()
+            logging.info(f"Rephrased query: {rephrased_query}")
             return analysis, rephrased_query
         else:
-            logging.error("Failed to parse the rephrase response")
+            logging.error("Failed to parse the rephrase response.")
             return None, query
     except Exception as e:
         logging.error(f"Error in rephrase_query: {str(e)}")
         return None, query
 
 def create_web_search_vectors(search_results):
+    logging.info(f"Creating web search vectors from {len(search_results)} search results.")
     embed = get_embeddings()
     documents = []
     for result in search_results:
         if 'body' in result:
             content = f"{result['title']}\n{result['body']}\nSource: {result['href']}"
             documents.append(Document(page_content=content, metadata={"source": result['href']}))
+    logging.info(f"{len(documents)} documents created for FAISS vectorization.")
     return FAISS.from_documents(documents, embed)
 
 async def get_response_with_search(query, model, use_embeddings, num_calls=3, temperature=0.2):
+    logging.info(f"Performing web search for query: {query}")
     search_results = duckduckgo_search(query)
     
     if not search_results:
+        logging.warning("No web search results found.")
         yield "No web search results available. Please try again.", ""
         return
 
     if use_embeddings:
+        logging.info("Using embeddings to retrieve relevant documents.")
         web_search_database = create_web_search_vectors(search_results)
         retriever = web_search_database.as_retriever(search_kwargs={"k": 5})
         relevant_docs = retriever.get_relevant_documents(query)
         context = "\n".join([doc.page_content for doc in relevant_docs])
     else:
+        logging.info("Using raw search results for context.")
         context = "\n".join([f"{result['title']}\n{result['body']}\nSource: {result['href']}" for result in search_results])
 
     system_message = """ You are a world-class AI system, capable of complex reasoning and reflection. 
@@ -108,12 +132,12 @@ async def get_response_with_search(query, model, use_embeddings, num_calls=3, te
 Write a detailed and complete research document that fulfills the following user request: '{query}'
 After writing the document, please provide a list of sources used in your response."""
 
-    # Use Hugging Face API
     client = InferenceClient(model, token=huggingface_token)
     full_response = ""
     
     try:
         for _ in range(num_calls):
+            logging.info(f"Sending request to model with {num_calls} API calls and temperature {temperature}.")
             for response in client.chat_completion(
                 messages=[
                     {"role": "system", "content": system_message},
@@ -138,7 +162,7 @@ After writing the document, please provide a list of sources used in your respon
         yield f"An error occurred while processing your request: {str(e)}", ""
 
     if not full_response:
-        logging.warning("No response generated from the model")
+        logging.warning("No response generated from the model.")
         yield "No response generated from the model.", ""
 
 async def respond(message, history, model, temperature, num_calls, use_embeddings):
@@ -159,6 +183,7 @@ async def respond(message, history, model, temperature, num_calls, use_embedding
             response = f"{main_content}\n\n{sources}"
             yield response
     except asyncio.CancelledError:
+        logging.warning("Operation cancelled by user.")
         yield "The operation was cancelled. Please try again."
     except Exception as e:
         logging.error(f"Error in respond function: {str(e)}")
@@ -178,6 +203,7 @@ css = """
 
 # Gradio interface setup
 def create_gradio_interface():
+    logging.info("Setting up Gradio interface.")
     custom_placeholder = "Enter your question here for web search."
 
     demo = gr.ChatInterface(
@@ -220,8 +246,10 @@ def create_gradio_interface():
         7. Use the provided examples or ask your own questions.
         """)
 
+    logging.info("Gradio interface ready.")
     return demo
 
 if __name__ == "__main__":
+    logging.info("Launching Gradio application.")
     demo = create_gradio_interface()
     demo.launch(share=True)