Update app.py

app.py

@@ -1,27 +1,10 @@
 import os
 import json
-import re
+import logging
 import gradio as gr
-import requests
 from duckduckgo_search import DDGS
 from typing import List, Dict
-from pydantic import BaseModel, Field
-from tempfile import NamedTemporaryFile
-from langchain_community.vectorstores import FAISS
-from langchain_core.vectorstores import VectorStore
-from langchain_core.documents import Document
-from langchain_community.document_loaders import PyPDFLoader
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from llama_parse import LlamaParse
-from huggingface_hub import InferenceClient
-import inspect
-import logging
-import shutil
-import pandas as pd
-from docx import Document as DocxDocument
-import google.generativeai as genai
-
-
+from pydantic import BaseModel
 from huggingface_hub import InferenceClient
 
 # Set up basic configuration for logging
@@ -29,272 +12,16 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 
 # Environment variables and configurations
 huggingface_token = os.environ.get("HUGGINGFACE_TOKEN")
-llama_cloud_api_key = os.environ.get("LLAMA_CLOUD_API_KEY")
-ACCOUNT_ID = os.environ.get("CLOUDFARE_ACCOUNT_ID")
-API_TOKEN = os.environ.get("CLOUDFLARE_AUTH_TOKEN")
-API_BASE_URL = "https://api.cloudflare.com/client/v4/accounts/a17f03e0f049ccae0c15cdcf3b9737ce/ai/run/"
-
-print(f"ACCOUNT_ID: {ACCOUNT_ID}")
-print(f"CLOUDFLARE_AUTH_TOKEN: {API_TOKEN[:5]}..." if API_TOKEN else "Not set")
-
 
 MODELS = [
     "mistralai/Mistral-7B-Instruct-v0.3",
     "mistralai/Mixtral-8x7B-Instruct-v0.1",
-    "@cf/meta/llama-3.1-8b-instruct",
-    "mistralai/Mistral-Nemo-Instruct-2407",
-    "mistralai/Mathstral-7B-v0.1",
-    "meta-llama/Meta-Llama-3.1-8B-Instruct",
-    "meta-llama/Meta-Llama-3.1-70B-Instruct",
-    "mattshumer/Reflection-Llama-3.1-70B",
-    "gemini-1.5-flash",
     "duckduckgo/gpt-4o-mini",
     "duckduckgo/claude-3-haiku",
     "duckduckgo/llama-3.1-70b",
     "duckduckgo/mixtral-8x7b"
 ]
 
-# Initialize LlamaParse
-llama_parser = LlamaParse(
-    api_key=llama_cloud_api_key,
-    result_type="markdown",
-    num_workers=4,
-    verbose=True,
-    language="en",
-)
-
-def load_office_document(file: NamedTemporaryFile) -> List[Document]:
-    file_extension = os.path.splitext(file.name)[1].lower()
-    documents = []
-    
-    if file_extension in ['.xlsx', '.xls']:
-        df = pd.read_excel(file.name)
-        for _, row in df.iterrows():
-            content = ' '.join(str(cell) for cell in row if pd.notna(cell))
-            documents.append(Document(page_content=content, metadata={"source": file.name}))
-    elif file_extension == '.docx':
-        doc = Document(file.name)
-        for para in doc.paragraphs:
-            if para.text.strip():
-                documents.append(Document(page_content=para.text, metadata={"source": file.name}))
-    
-    return documents
-
-def load_document(file: NamedTemporaryFile, parser: str = "llamaparse") -> List[Document]:
-    """Loads and splits the document into pages."""
-    if parser == "pypdf":
-        loader = PyPDFLoader(file.name)
-        return loader.load_and_split()
-    elif parser == "llamaparse":
-        try:
-            documents = llama_parser.load_data(file.name)
-            return [Document(page_content=doc.text, metadata={"source": file.name}) for doc in documents]
-        except Exception as e:
-            print(f"Error using Llama Parse: {str(e)}")
-            print("Falling back to PyPDF parser")
-            loader = PyPDFLoader(file.name)
-            return loader.load_and_split()
-    else:
-        raise ValueError("Invalid parser specified. Use 'pypdf' or 'llamaparse'.")
-
-def get_embeddings():
-    return HuggingFaceEmbeddings(model_name="avsolatorio/GIST-Embedding-v0")
-
-# Add this at the beginning of your script, after imports
-DOCUMENTS_FILE = "uploaded_documents.json"
-
-def load_documents():
-    if os.path.exists(DOCUMENTS_FILE):
-        with open(DOCUMENTS_FILE, "r") as f:
-            return json.load(f)
-    return []
-
-def save_documents(documents):
-    with open(DOCUMENTS_FILE, "w") as f:
-        json.dump(documents, f)
-
-# Replace the global uploaded_documents with this
-uploaded_documents = load_documents()
-
-# Modify the update_vectors function
-def update_vectors(files, parser):
-    global uploaded_documents
-    logging.info(f"Entering update_vectors with {len(files)} files and parser: {parser}")
-
-    if not files:
-        logging.warning("No files provided for update_vectors")
-        return "Please upload at least one file.", display_documents()
-
-    embed = get_embeddings()
-    total_chunks = 0
-
-    all_data = []
-    for file in files:
-        logging.info(f"Processing file: {file.name}")
-        try:
-            file_extension = os.path.splitext(file.name)[1].lower()
-            
-            if file_extension in ['.xlsx', '.xls', '.docx']:
-                if parser != "office":
-                    logging.warning(f"Using office parser for {file.name} regardless of selected parser")
-                data = load_office_document(file)
-            elif file_extension == '.pdf':
-                if parser == "office":
-                    logging.warning(f"Cannot use office parser for PDF file {file.name}. Using llamaparse.")
-                    data = load_document(file, "llamaparse")
-                else:
-                    data = load_document(file, parser)
-            else:
-                logging.warning(f"Unsupported file type: {file_extension}")
-                continue
-            
-            if not data:
-                logging.warning(f"No chunks loaded from {file.name}")
-                continue
-            logging.info(f"Loaded {len(data)} chunks from {file.name}")
-            all_data.extend(data)
-            total_chunks += len(data)
-            if not any(doc["name"] == file.name for doc in uploaded_documents):
-                uploaded_documents.append({"name": file.name, "selected": True})
-                logging.info(f"Added new document to uploaded_documents: {file.name}")
-            else:
-                logging.info(f"Document already exists in uploaded_documents: {file.name}")
-        except Exception as e:
-            logging.error(f"Error processing file {file.name}: {str(e)}")
-
-    logging.info(f"Total chunks processed: {total_chunks}")
-
-    if not all_data:
-        logging.warning("No valid data extracted from uploaded files")
-        return "No valid data could be extracted from the uploaded files. Please check the file contents and try again.", display_documents()
-
-    try:
-        # Update the appropriate vector store based on file type
-        pdf_data = [doc for doc in all_data if doc.metadata["source"].lower().endswith('.pdf')]
-        office_data = [doc for doc in all_data if not doc.metadata["source"].lower().endswith('.pdf')]
-
-        if pdf_data:
-            if os.path.exists("faiss_database"):
-                pdf_database = FAISS.load_local("faiss_database", embed, allow_dangerous_deserialization=True)
-                pdf_database.add_documents(pdf_data)
-            else:
-                pdf_database = FAISS.from_documents(pdf_data, embed)
-            pdf_database.save_local("faiss_database")
-            logging.info("PDF FAISS database updated and saved")
-
-        if office_data:
-            if os.path.exists("office_faiss_database"):
-                office_database = FAISS.load_local("office_faiss_database", embed, allow_dangerous_deserialization=True)
-                office_database.add_documents(office_data)
-            else:
-                office_database = FAISS.from_documents(office_data, embed)
-            office_database.save_local("office_faiss_database")
-            logging.info("Office FAISS database updated and saved")
-
-    except Exception as e:
-        logging.error(f"Error updating FAISS database: {str(e)}")
-        return f"Error updating vector store: {str(e)}", display_documents()
-
-    # Save the updated list of documents
-    save_documents(uploaded_documents)
-
-    # Return a tuple with the status message and the updated document list
-    return f"Vector store updated successfully. Processed {total_chunks} chunks from {len(files)} files.", display_documents()
-
-
-def delete_documents(selected_docs):
-    global uploaded_documents
-    
-    if not selected_docs:
-        return "No documents selected for deletion.", display_documents()
-    
-    embed = get_embeddings()
-    database = FAISS.load_local("faiss_database", embed, allow_dangerous_deserialization=True)
-    
-    deleted_docs = []
-    docs_to_keep = []
-    for doc in database.docstore._dict.values():
-        if doc.metadata.get("source") not in selected_docs:
-            docs_to_keep.append(doc)
-        else:
-            deleted_docs.append(doc.metadata.get("source", "Unknown"))
-    
-    # Print debugging information
-    logging.info(f"Total documents before deletion: {len(database.docstore._dict)}")
-    logging.info(f"Documents to keep: {len(docs_to_keep)}")
-    logging.info(f"Documents to delete: {len(deleted_docs)}")
-    
-    if not docs_to_keep:
-        # If all documents are deleted, remove the FAISS database directory
-        if os.path.exists("faiss_database"):
-            shutil.rmtree("faiss_database")
-        logging.info("All documents deleted. Removed FAISS database directory.")
-    else:
-        # Create new FAISS index with remaining documents
-        new_database = FAISS.from_documents(docs_to_keep, embed)
-        new_database.save_local("faiss_database")
-        logging.info(f"Created new FAISS index with {len(docs_to_keep)} documents.")
-    
-    # Update uploaded_documents list
-    uploaded_documents = [doc for doc in uploaded_documents if doc["name"] not in deleted_docs]
-    save_documents(uploaded_documents)
-    
-    return f"Deleted documents: {', '.join(deleted_docs)}", display_documents()
-
-def chatbot_interface(message, history, model, temperature, num_calls):
-    if not message.strip():
-        return "", history
-
-    history = history + [(message, "")]
-
-    try:
-        for response in respond(message, history, model, temperature, num_calls):
-            history[-1] = (message, response)
-            yield history
-    except gr.CancelledError:
-        yield history
-    except Exception as e:
-        logging.error(f"Unexpected error in chatbot_interface: {str(e)}")
-        history[-1] = (message, f"An unexpected error occurred: {str(e)}")
-        yield history
-
-def retry_last_response(history, model, temperature, num_calls):
-    if not history:
-        return history
-    
-    last_user_msg = history[-1][0]
-    history = history[:-1]  # Remove the last response
-    
-    return chatbot_interface(last_user_msg, history, model, temperature, num_calls)
-
-def truncate_context(context, max_length=16000):
-    """Truncate the context to a maximum length."""
-    if len(context) <= max_length:
-        return context
-    return context[:max_length] + "..."
-
-def get_response_from_duckduckgo(query, model, context, num_calls=1, temperature=0.2):
-    logging.info(f"Using DuckDuckGo chat with model: {model}")
-    ddg_model = model.split('/')[-1]  # Extract the model name from the full string
-    
-    # Truncate the context to avoid exceeding input limits
-    truncated_context = truncate_context(context)
-    
-    full_response = ""
-    for _ in range(num_calls):
-        try:
-            # Include truncated context in the query
-            contextualized_query = f"Using the following context:\n{truncated_context}\n\nUser question: {query}"
-            results = DDGS().chat(contextualized_query, model=ddg_model)
-            full_response += results + "\n"
-            logging.info(f"DuckDuckGo API response received. Length: {len(results)}")
-        except Exception as e:
-            logging.error(f"Error in generating response from DuckDuckGo: {str(e)}")
-            yield f"An error occurred with the {model} model: {str(e)}. Please try again."
-            return
-
-    yield full_response.strip()
-
 class ConversationManager:
     def __init__(self):
         self.history = []
@@ -360,233 +87,9 @@ def summarize_web_results(query: str, search_results: List[Dict[str, str]], conv
     except Exception as e:
         return f"An error occurred during summarization: {str(e)}"
 
-def get_response_from_gemini(query, model, selected_docs, file_type, num_calls=1, temperature=0.2):
-    # Configure the Gemini API
-    genai.configure(api_key=os.environ["GEMINI_API_KEY"])
-
-    # Define the model
-    gemini_model = genai.GenerativeModel(
-        model_name="gemini-1.5-flash",
-        generation_config={
-            "temperature": temperature,
-            "top_p": 1,
-            "top_k": 1,
-            "max_output_tokens": 20000,
-        },
-    )
-
-    if file_type == "excel":
-        # Excel functionality remains the same
-
-        system_instruction = """You are a highly specialized Python programmer with deep expertise in data analysis and visualization using Excel spreadsheets. 
-        Your primary goal is to generate accurate and efficient Python code to perform calculations or create visualizations based on the user's requests. 
-        Strictly use the data provided to write code that identifies key metrics, trends, and significant details relevant to the query. 
-        Do not make assumptions or include any information that is not explicitly supported by the dataset. 
-        If the user requests a calculation, provide the appropriate Python code to execute it, and if a visualization is needed, generate code using the matplotlib library to create the chart.
-        Based on the following data extracted from Excel spreadsheets:\n{context}\n\nPlease provide the Python code needed to execute the following task: '{query}'. 
-        Ensure that the code is derived directly from the dataset. 
-        If a chart is requested, use the matplotlib library to generate the appropriate visualization."""
-        
-        full_prompt = f"{system_instruction}\n\nContext:\n{selected_docs}\n\nUser query: {query}"
-        
-    elif file_type == "pdf":
-        # PDF functionality similar to get_response_from_pdf
-        embed = get_embeddings()
-        if os.path.exists("faiss_database"):
-            database = FAISS.load_local("faiss_database", embed, allow_dangerous_deserialization=True)
-        else:
-            yield "No documents available. Please upload PDF documents to answer questions."
-            return
-
-        # Pre-filter the documents
-        filtered_docs = [doc for doc_id, doc in database.docstore._dict.items() 
-                         if isinstance(doc, Document) and doc.metadata.get("source") in selected_docs]
-
-        if not filtered_docs:
-            yield "No relevant information found in the selected documents. Please try selecting different documents or rephrasing your query."
-            return
-
-        # Create a new FAISS index with only the selected documents
-        filtered_db = FAISS.from_documents(filtered_docs, embed)
-        
-        retriever = filtered_db.as_retriever(search_kwargs={"k": 10})
-        relevant_docs = retriever.get_relevant_documents(query)
-
-        context_str = "\n".join([doc.page_content for doc in relevant_docs])
-    
-        system_instruction = """You are a highly specialized financial analyst assistant with expertise in analyzing and summarizing financial documents. 
-        Your goal is to provide accurate, detailed, and precise summaries based on the context provided. 
-        Avoid making assumptions or adding information that is not explicitly supported by the context from the PDF documents.      
-        Using the following context from the PDF documents:\n{context_str}\n\nPlease generate a step-by-step reasoning before arriving at a comprehensive and accurate summary addressing the following question: '{query}'. 
-        Ensure your response is strictly based on the provided context, highlighting key financial metrics, trends, and significant details relevant to the query. 
-        Avoid any speculative or unverified information."""
-
-        full_prompt = f"{system_instruction}\n\nContext:\n{context_str}\n\nUser query: {query}\n\nPlease generate a step-by-step reasoning before arriving at a comprehensive and accurate summary addressing the question. Ensure your response is strictly based on the provided context, highlighting key metrics, trends, and significant details relevant to the query. Avoid any speculative or unverified information."
-
-    else:
-        raise ValueError("Invalid file type. Use 'excel' or 'pdf'.")
-
-    full_response = ""
-    for _ in range(num_calls):
-        try:
-            # Generate content with streaming enabled
-            response = gemini_model.generate_content(full_prompt, stream=True)
-            for chunk in response:
-                if chunk.text:
-                    full_response += chunk.text
-                    yield full_response  # Yield the accumulated response so far
-        except Exception as e:
-            yield f"An error occurred with the Gemini model: {str(e)}. Please try again."
-
-    if not full_response:
-        yield "No response generated from the Gemini model."
-
-def get_response_from_excel(query, model, context, num_calls=3, temperature=0.2):
-    logging.info(f"Getting response from Excel using model: {model}")
-    
-    messages = [
-    {"role": "system", "content": "You are a highly specialized Python programmer with deep expertise in data analysis and visualization using Excel spreadsheets. Your primary goal is to generate accurate and efficient Python code to perform calculations or create visualizations based on the user's requests. Strictly use the data provided to write code that identifies key metrics, trends, and significant details relevant to the query. Do not make assumptions or include any information that is not explicitly supported by the dataset. If the user requests a calculation, provide the appropriate Python code to execute it, and if a visualization is needed, generate code using the matplotlib library to create the chart."},
-    {"role": "user", "content": f"Based on the following data extracted from Excel spreadsheets:\n{context}\n\nPlease provide the Python code needed to execute the following task: '{query}'. Ensure that the code is derived directly from the dataset. If a chart is requested, use the matplotlib library to generate the appropriate visualization."}
-    ]
-
-    if model.startswith("duckduckgo/"):
-        # Use DuckDuckGo chat with context
-        return get_response_from_duckduckgo(query, model, context, num_calls, temperature)
-    elif model == "@cf/meta/llama-3.1-8b-instruct":
-        # Use Cloudflare API
-        return get_response_from_cloudflare(prompt="", context=context, query=query, num_calls=num_calls, temperature=temperature, search_type="excel")
-    else:
-        # Use Hugging Face API
-        client = InferenceClient(model, token=huggingface_token)
-
-        response = ""
-        for i in range(num_calls):
-            logging.info(f"API call {i+1}/{num_calls}")
-            for message in client.chat_completion(
-                messages=messages,
-                max_tokens=20000,
-                temperature=temperature,
-                stream=True,
-                top_p=0.2,
-            ):
-                if message.choices and message.choices[0].delta and message.choices[0].delta.content:
-                    chunk = message.choices[0].delta.content
-                    response += chunk
-                    yield response  # Yield partial response
-
-        logging.info("Finished generating response for Excel data")
-
-def truncate_context(context, max_chars=10000):
-    """Truncate context to a maximum number of characters."""
-    if len(context) <= max_chars:
-        return context
-    return context[:max_chars] + "..."
-
-def get_response_from_llama(query, model, selected_docs, file_type, num_calls=1, temperature=0.2):
-    logging.info(f"Getting response from Llama using model: {model}")
-    
-    # Initialize the Hugging Face client
-    client = InferenceClient(model, token=huggingface_token)
-    
-    if file_type == "excel":
-        # Excel functionality
-        system_instruction = """You are a highly specialized Python programmer with deep expertise in data analysis and visualization using Excel spreadsheets. 
-        Your primary goal is to generate accurate and efficient Python code to perform calculations or create visualizations based on the user's requests. 
-        Strictly use the data provided to write code that identifies key metrics, trends, and significant details relevant to the query. 
-        Do not make assumptions or include any information that is not explicitly supported by the dataset. 
-        If the user requests a calculation, provide the appropriate Python code to execute it, and if a visualization is needed, generate code using the matplotlib library to create the chart."""
-        
-        # Get the context from selected Excel documents
-        embed = get_embeddings()
-        office_database = FAISS.load_local("office_faiss_database", embed, allow_dangerous_deserialization=True)
-        retriever = office_database.as_retriever(search_kwargs={"k": 20})
-        relevant_docs = retriever.get_relevant_documents(query)
-        context = "\n".join([doc.page_content for doc in relevant_docs if doc.metadata["source"] in selected_docs])
-        
-        # Truncate context
-        context = truncate_context(context)
-        
-        messages = [
-            {"role": "system", "content": system_instruction},
-            {"role": "user", "content": f"Based on the following data extracted from Excel spreadsheets:\n{context}\n\nPlease provide the Python code needed to execute the following task: '{query}'. Ensure that the code is derived directly from the dataset. If a chart is requested, use the matplotlib library to generate the appropriate visualization."}
-        ]
-        
-    elif file_type == "pdf":
-        # PDF functionality
-        embed = get_embeddings()
-        pdf_database = FAISS.load_local("faiss_database", embed, allow_dangerous_deserialization=True)
-        
-        retriever = pdf_database.as_retriever(search_kwargs={"k": 10})
-        relevant_docs = retriever.get_relevant_documents(query)
-        
-        context_str = "\n".join([doc.page_content for doc in relevant_docs if doc.metadata["source"] in selected_docs])
-    
-        # Truncate context
-        context_str = truncate_context(context_str)
-    
-        system_instruction = """You are an AI assistant designed to provide detailed, step-by-step responses. Your outputs should follow this structure:
-
-        1. Begin with a <thinking> section. Everything in this section is invisible to the user.
-        2. Inside the thinking section:
-            a. Briefly analyze the question and outline your approach.
-            b. Present a clear plan of steps to solve the problem.
-            c. Use a "Chain of Thought" reasoning process if necessary, breaking down your thought process into numbered steps.
-        3. Include a <reflection> section for each idea where you:
-            a. Review your reasoning.
-            b. Check for potential errors or oversights.
-            c. Confirm or adjust your conclusion if necessary.
-        4. Be sure to close all reflection sections.
-        5. Close the thinking section with </thinking>.
-        6. Provide your final answer in an <output> section.
-  
-        Always use these tags in your responses. Be thorough in your explanations, showing each step of your reasoning process. Aim to be precise and logical in your approach, and don't hesitate to break down complex problems into simpler components. Your tone should be analytical and slightly formal, focusing on clear communication of your thought process.
-  
-        Remember: Both <thinking> and <reflection> MUST be tags and must be closed at their conclusion
-  
-        Make sure all <tags> are on separate lines with no other text. Do not include other text on a line containing a tag."""
-
-        messages = [
-            {"role": "system", "content": system_instruction},
-            {"role": "user", "content": f"Using the following context from the PDF documents:\n{context_str}\n\nPlease generate a step-by-step reasoning before arriving at a comprehensive and accurate summary addressing the following question: '{query}'. Ensure your response is strictly based on the provided context, highlighting key metrics, trends, and significant details relevant to the query. Avoid any speculative or unverified information."}
-        ]
-
-    else:
-        raise ValueError("Invalid file type. Use 'excel' or 'pdf'.")
-
-    full_response = ""
-    for _ in range(num_calls):
-        try:
-            # Generate content with streaming enabled
-            for response in client.chat_completion(
-                messages=messages,  # Pass messages in the required format
-                max_tokens=3000,  # Reduced to ensure we stay within token limits
-                temperature=temperature,
-                stream=True,
-                top_p=0.9,
-            ):
-                # Check the structure of the response object
-                if isinstance(response, dict) and "choices" in response:
-                    for choice in response["choices"]:
-                        if "delta" in choice and "content" in choice["delta"]:
-                            chunk = choice["delta"]["content"]
-                            full_response += chunk
-                            yield full_response  # Yield the accumulated response so far
-                else:
-                    logging.error("Unexpected response format or missing attributes in the response object.")
-                    break
-        except Exception as e:
-            logging.error(f"Error during API call: {str(e)}")
-            yield f"An error occurred with the Llama model: {str(e)}. Please try again."
-
-    if not full_response:
-        logging.warning("No response generated from the Llama model")
-        yield "No response generated from the Llama model."
-    
-# Modify the existing respond function to handle both PDF and web search
-def respond(message, history, model, temperature, num_calls, use_web_search, selected_docs):
+def respond(message, history, model, temperature, num_calls, use_web_search):
     logging.info(f"User Query: {message}")
     logging.info(f"Model Used: {model}")
-    logging.info(f"Selected Documents: {selected_docs}")
     logging.info(f"Use Web Search: {use_web_search}")
 
     if use_web_search:
@@ -612,243 +115,7 @@ def respond(message, history, model, temperature, num_calls, use_web_search, sel
         else:
             yield "Unable to generate a response. Please try a different query."
     else:
-        try:
-            embed = get_embeddings()
-            pdf_database = None
-            office_database = None
-
-            if os.path.exists("faiss_database"):
-                pdf_database = FAISS.load_local("faiss_database", embed, allow_dangerous_deserialization=True)
-
-            if os.path.exists("office_faiss_database"):
-                office_database = FAISS.load_local("office_faiss_database", embed, allow_dangerous_deserialization=True)
-
-            if not pdf_database and not office_database:
-                yield "No documents available. Please upload documents to answer questions."
-                return
-
-            all_relevant_docs = []
-            if pdf_database:
-                pdf_retriever = pdf_database.as_retriever(search_kwargs={"k": 10})
-                all_relevant_docs.extend(pdf_retriever.get_relevant_documents(message))
-
-            if office_database:
-                office_retriever = office_database.as_retriever(search_kwargs={"k": 10})
-                all_relevant_docs.extend(office_retriever.get_relevant_documents(message))
-
-            relevant_docs = [doc for doc in all_relevant_docs if doc.metadata["source"] in selected_docs]
-
-            if not relevant_docs:
-                yield "No relevant information found in the selected documents. Please try selecting different documents or rephrasing your query."
-                return
-
-            # Separate Excel documents from others
-            excel_docs = [doc for doc in relevant_docs if doc.metadata["source"].lower().endswith(('.xlsx', '.xls'))]
-            other_docs = [doc for doc in relevant_docs if not doc.metadata["source"].lower().endswith(('.xlsx', '.xls'))]
-
-            excel_context = "\n".join([doc.page_content for doc in excel_docs])
-            other_context = "\n".join([doc.page_content for doc in other_docs])
-
-            logging.info(f"Excel context length: {len(excel_context)}")
-            logging.info(f"Other context length: {len(other_context)}")
-
-            # Process Excel documents
-            if excel_docs:
-                file_type = "excel"
-                if model == "gemini-1.5-flash":
-                    for chunk in get_response_from_gemini(message, model, selected_docs, file_type, num_calls, temperature):
-                        yield chunk
-                elif "llama" in model.lower():
-                    for chunk in get_response_from_llama(message, model, selected_docs, file_type, num_calls, temperature):
-                        yield chunk
-                else:
-                    for response in get_response_from_excel(message, model, excel_context, num_calls, temperature):
-                        yield response
-
-            # Process other documents (PDF, Word)
-            if other_docs:
-                file_type = "pdf"
-                if model == "gemini-1.5-flash":
-                    for chunk in get_response_from_gemini(message, model, selected_docs, file_type, num_calls, temperature):
-                        yield chunk
-                elif model == "@cf/meta/llama-3.1-8b-instruct":
-                    for response in get_response_from_cloudflare(prompt="", context=other_context, query=message, num_calls=num_calls, temperature=temperature, search_type="document"):
-                        yield response
-                elif "llama" in model.lower():
-                    for chunk in get_response_from_llama(message, model, selected_docs, file_type, num_calls, temperature):
-                        yield chunk
-                else:
-                    for response in get_response_from_pdf(message, model, selected_docs, num_calls, temperature):
-                        yield response
-
-        except Exception as e:
-            logging.error(f"Error with {model}: {str(e)}")
-            if "microsoft/Phi-3-mini-4k-instruct" in model:
-                logging.info("Falling back to Mistral model due to Phi-3 error")
-                fallback_model = "mistralai/Mistral-7B-Instruct-v0.3"
-                yield from respond(message, history, fallback_model, temperature, num_calls, use_web_search, selected_docs)
-            else:
-                yield f"An error occurred with the {model} model: {str(e)}. Please try again or select a different model."
-        
-logging.basicConfig(level=logging.DEBUG)
-
-def get_response_from_cloudflare(prompt, context, query, num_calls=3, temperature=0.2, search_type="pdf"):
-    headers = {
-        "Authorization": f"Bearer {API_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    model = "@cf/meta/llama-3.1-8b-instruct"
-
-    if search_type == "pdf":
-        instruction = f"""Using the following context from the PDF documents:
-{context}
-Write a detailed and complete response that answers the following user question: '{query}'"""
-    else:  # web search
-        instruction = f"""Using the following context:
-{context}
-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."""
-
-    inputs = [
-        {"role": "system", "content": instruction},
-        {"role": "user", "content": query}
-    ]
-
-    payload = {
-        "messages": inputs,
-        "stream": True,
-        "temperature": temperature,
-        "max_tokens": 32000
-    }
-
-    full_response = ""
-    for i in range(num_calls):
-        try:
-            with requests.post(f"{API_BASE_URL}{model}", headers=headers, json=payload, stream=True) as response:
-                if response.status_code == 200:
-                    for line in response.iter_lines():
-                        if line:
-                            try:
-                                json_response = json.loads(line.decode('utf-8').split('data: ')[1])
-                                if 'response' in json_response:
-                                    chunk = json_response['response']
-                                    full_response += chunk
-                                    yield full_response
-                            except (json.JSONDecodeError, IndexError) as e:
-                                logging.error(f"Error parsing streaming response: {str(e)}")
-                                continue
-                else:
-                    logging.error(f"HTTP Error: {response.status_code}, Response: {response.text}")
-                    yield f"I apologize, but I encountered an HTTP error: {response.status_code}. Please try again later."
-        except Exception as e:
-            logging.error(f"Error in generating response from Cloudflare: {str(e)}")
-            yield f"I apologize, but an error occurred: {str(e)}. Please try again later."
-    
-    if not full_response:
-        yield "I apologize, but I couldn't generate a response at this time. Please try again later."
-
-def create_web_search_vectors(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']}))
-    
-    return FAISS.from_documents(documents, embed)
-
-def get_response_from_pdf(query, model, selected_docs, num_calls=3, temperature=0.2):
-    logging.info(f"Entering get_response_from_pdf with query: {query}, model: {model}, selected_docs: {selected_docs}")
-    
-    embed = get_embeddings()
-    if os.path.exists("faiss_database"):
-        logging.info("Loading FAISS database")
-        database = FAISS.load_local("faiss_database", embed, allow_dangerous_deserialization=True)
-    else:
-        logging.warning("No FAISS database found")
-        yield "No documents available. Please upload PDF documents to answer questions."
-        return
-
-    # Pre-filter the documents
-    filtered_docs = []
-    for doc_id, doc in database.docstore._dict.items():
-        if isinstance(doc, Document) and doc.metadata.get("source") in selected_docs:
-            filtered_docs.append(doc)
-    
-    logging.info(f"Number of documents after pre-filtering: {len(filtered_docs)}")
-
-    if not filtered_docs:
-        logging.warning(f"No documents found for the selected sources: {selected_docs}")
-        yield "No relevant information found in the selected documents. Please try selecting different documents or rephrasing your query."
-        return
-
-    # Create a new FAISS index with only the selected documents
-    filtered_db = FAISS.from_documents(filtered_docs, embed)
-    
-    retriever = filtered_db.as_retriever(search_kwargs={"k": 10})
-    logging.info(f"Retrieving relevant documents for query: {query}")
-    relevant_docs = retriever.get_relevant_documents(query)
-    logging.info(f"Number of relevant documents retrieved: {len(relevant_docs)}")
-
-    for doc in relevant_docs:
-        logging.info(f"Document source: {doc.metadata['source']}")
-        logging.info(f"Document content preview: {doc.page_content[:100]}...")  # Log first 100 characters of each document
-
-    context_str = "\n".join([doc.page_content for doc in relevant_docs])
-    logging.info(f"Total context length: {len(context_str)}")
-
-    if model == "@cf/meta/llama-3.1-8b-instruct":
-        logging.info("Using Cloudflare API")
-        # Use Cloudflare API with the retrieved context
-        for response in get_response_from_cloudflare(prompt="", context=context_str, query=query, num_calls=num_calls, temperature=temperature, search_type="pdf"):
-            yield response
-    else:
-        logging.info("Using Hugging Face API")
-        # Use Hugging Face API
-        messages = [
-            {"role": "system", "content": """You are an AI assistant designed to provide detailed, step-by-step responses. Your outputs should follow this structure:
-
-        1. Begin with a <thinking> section. Everything in this section is invisible to the user.
-        2. Inside the thinking section:
-            a. Briefly analyze the question and outline your approach.
-            b. Present a clear plan of steps to solve the problem.
-            c. Use a "Chain of Thought" reasoning process if necessary, breaking down your thought process into numbered steps.
-        3. Include a <reflection> section for each idea where you:
-            a. Review your reasoning.
-            b. Check for potential errors or oversights.
-            c. Confirm or adjust your conclusion if necessary.
-        4. Be sure to close all reflection sections.
-        5. Close the thinking section with </thinking>.
-        6. Provide your final answer in an <output> section.
-  
-        Always use these tags in your responses. Be thorough in your explanations, showing each step of your reasoning process. Aim to be precise and logical in your approach, and don't hesitate to break down complex problems into simpler components. Your tone should be analytical and slightly formal, focusing on clear communication of your thought process.
-  
-        Remember: Both <thinking> and <reflection> MUST be tags and must be closed at their conclusion
-  
-        Make sure all <tags> are on separate lines with no other text. Do not include other text on a line containing a tag."""},
-
-            {"role": "user", "content": f"Using the following context from the PDF documents:\n{context_str}\n\nPlease generate a step-by-step reasoning before arriving at a comprehensive and accurate summary addressing the following question: '{query}'. Ensure your response is strictly based on the provided context, highlighting key financial metrics, trends, and significant details relevant to the query. Avoid any speculative or unverified information."}
-        ]
-        
-        client = InferenceClient(model, token=huggingface_token)
-        
-        response = ""
-        for i in range(num_calls):
-            logging.info(f"API call {i+1}/{num_calls}")
-            for message in client.chat_completion(
-                messages=messages,
-                max_tokens=20000,
-                temperature=temperature,
-                stream=True,
-                top_p=0.8,
-            ):
-                if message.choices and message.choices[0].delta and message.choices[0].delta.content:
-                    chunk = message.choices[0].delta.content
-                    response += chunk
-                    yield response  # Yield partial response
-        
-        logging.info("Finished generating response")
+        yield "Web search is not enabled. Please enable web search to use this feature."
 
 def vote(data: gr.LikeData):
     if data.liked:
@@ -868,62 +135,37 @@ css = """
 }
 """
 
-uploaded_documents = []
-
-def display_documents():
-    return gr.CheckboxGroup(
-        choices=[doc["name"] for doc in uploaded_documents],
-        value=[doc["name"] for doc in uploaded_documents if doc["selected"]],
-        label="Select documents to query or delete"
-    )
-
 def initial_conversation():
     return [
-        (None, "Welcome! I'm your AI assistant for web search and PDF analysis. Here's how you can use me:\n\n"
-                "1. Set the toggle for Web Search and PDF Search from the checkbox in Additional Inputs drop down window\n"
-                "2. Use web search to find information\n"
-                "3. Upload the documents and ask questions about uploaded PDF documents by selecting your respective document\n"
-                "4. For any queries feel free to reach out @[email protected] or discord - shreyas094\n\n"
-                "To get started, upload some PDFs or ask me a question!")
+        (None, "Welcome! I'm your AI assistant for web search. Here's how you can use me:\n\n"
+                "1. Make sure the 'Use Web Search' checkbox is enabled in the Additional Inputs section.\n"
+                "2. Ask me any question, and I'll search the web for the most relevant and up-to-date information.\n"
+                "3. You can adjust the model, temperature, and number of API calls in the Additional Inputs section to fine-tune your results.\n\n"
+                "To get started, just ask me a question!")
     ]
-# Add this new function
-def refresh_documents():
-    global uploaded_documents
-    uploaded_documents = load_documents()
-    return display_documents()
-
-# Define the checkbox outside the demo block
-document_selector = gr.CheckboxGroup(label="Select documents to query")
-
-use_web_search = gr.Checkbox(label="Use Web Search", value=False)
 
-custom_placeholder = "Ask a question (Note: You can toggle between Web Search and PDF Chat in Additional Inputs below)"
-
-# Update the demo interface
-# Update the Gradio interface
+# Create the Gradio interface
 demo = gr.ChatInterface(
     respond,
-    additional_inputs_accordion=gr.Accordion(label="⚙️ Parameters", open=True, render=False),
     additional_inputs=[
-        gr.Dropdown(choices=MODELS, label="Select Model", value=MODELS[3]),
+        gr.Dropdown(choices=MODELS, label="Select Model", value=MODELS[0]),
         gr.Slider(minimum=0.1, maximum=1.0, value=0.2, step=0.1, label="Temperature"),
         gr.Slider(minimum=1, maximum=5, value=1, step=1, label="Number of API Calls"),
-        gr.Checkbox(label="Use Web Search", value=True),
-        gr.CheckboxGroup(label="Select documents to query")        
+        gr.Checkbox(label="Use Web Search", value=True)
     ],
-    title="AI-powered PDF Chat and Web Search Assistant",
-    description="Chat with your PDFs or use web search to answer questions.",
+    title="AI-powered Web Search Assistant",
+    description="Ask questions and get answers from the latest web information.",
     theme=gr.Theme.from_hub("allenai/gradio-theme"),
     css=css,
     examples=[
-        ["Tell me about the contents of the uploaded PDFs."],
-        ["What are the main topics discussed in the documents?"],
-        ["Can you summarize the key points from the PDFs?"],
-        ["What's the latest news about artificial intelligence?"]
+        ["What's the latest news about artificial intelligence?"],
+        ["Summarize the current global economic situation."],
+        ["What are the top environmental concerns right now?"],
+        ["What are the recent breakthroughs in quantum computing?"]
     ],
     cache_examples=False,
     analytics_enabled=False,
-    textbox=gr.Textbox(placeholder="Ask a question about the uploaded PDFs or any topic", container=False, scale=7),
+    textbox=gr.Textbox(placeholder="Ask any question", container=False, scale=7),
     chatbot = gr.Chatbot(  
         show_copy_button=True,
         likeable=True,
@@ -933,51 +175,5 @@ demo = gr.ChatInterface(
     )
 )
 
-# Add file upload functionality
-with demo:
-    gr.Markdown("## Upload and Manage PDF Documents")
-    with gr.Row():
-        file_input = gr.Files(label="Upload your documents", file_types=[".pdf", ".docx", ".xlsx", ".xls"])
-        parser_dropdown = gr.Dropdown(choices=["pypdf", "llamaparse", "office"], label="Select PDF Parser", value="llamaparse")
-        update_button = gr.Button("Upload Document")
-        refresh_button = gr.Button("Refresh Document List")
-    
-    update_output = gr.Textbox(label="Update Status")
-    delete_button = gr.Button("Delete Selected Documents")
-
-    # Update both the output text and the document selector
-    update_button.click(
-        update_vectors, 
-        inputs=[file_input, parser_dropdown], 
-        outputs=[update_output, demo.additional_inputs[-1]]  # Use the CheckboxGroup from additional_inputs
-    )
-    
-    # Add the refresh button functionality
-    refresh_button.click(
-        refresh_documents, 
-        inputs=[], 
-        outputs=[demo.additional_inputs[-1]]  # Use the CheckboxGroup from additional_inputs
-    )
-    
-    # Add the delete button functionality
-    delete_button.click(
-        delete_documents,
-        inputs=[demo.additional_inputs[-1]],  # Use the CheckboxGroup from additional_inputs
-        outputs=[update_output, demo.additional_inputs[-1]]
-    )
-
-    gr.Markdown(
-    """
-    ## How to use
-    1. Upload PDF documents using the file input at the top.
-    2. Select the PDF parser (pypdf or llamaparse) and click "Upload Document" to update the vector store.
-    3. Select the documents you want to query using the checkboxes.
-    4. Ask questions in the chat interface. 
-    5. Toggle "Use Web Search" to switch between PDF chat and web search.
-    6. Adjust Temperature and Number of API Calls to fine-tune the response generation.
-    7. Use the provided examples or ask your own questions.
-    """
-    )
-
 if __name__ == "__main__":
     demo.launch(share=True)