Update app.py

app.py

@@ -6,183 +6,39 @@ import pandas as pd
 import requests
 import random
 import urllib.parse
-import spacy
-from sklearn.metrics.pairwise import cosine_similarity
-import numpy as np
-from typing import List, Dict
 from tempfile import NamedTemporaryFile
+from typing import List
 from bs4 import BeautifulSoup
-from langchain.prompts import PromptTemplate
-from langchain.chains import LLMChain
-from langchain_core.prompts import ChatPromptTemplate
+import logging
+
+from langchain_community.llms import HuggingFaceHub
 from langchain_community.vectorstores import FAISS
 from langchain_community.document_loaders import PyPDFLoader
-from langchain_core.output_parsers import StrOutputParser
 from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain_community.llms import HuggingFaceHub
 from langchain_core.documents import Document
-from sentence_transformers import SentenceTransformer
-from llama_parse import LlamaParse
-from llama_cpp import Llama
-from llama_cpp_agent.llm_agent import LlamaCppAgent
-from llama_cpp_agent.messages_formatter import MessagesFormatterType
-from llama_cpp_agent.providers.llama_cpp_endpoint_provider import LlamaCppEndpointSettings
-
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
 
+# Global variables
 huggingface_token = os.environ.get("HUGGINGFACE_TOKEN")
-llama_cloud_api_key = os.environ.get("LLAMA_CLOUD_API_KEY")
-
-# Load SentenceTransformer model
-sentence_model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
-
-def load_spacy_model():
-    try:
-        # Try to load the model
-        return spacy.load("en_core_web_sm")
-    except OSError:
-        # If loading fails, download the model
-        os.system("python -m spacy download en_core_web_sm")
-        # Try loading again
-        return spacy.load("en_core_web_sm")
-
-# Load spaCy model
-nlp = load_spacy_model()
-
-class EnhancedContextDrivenChatbot:
-    def __init__(self, history_size: int = 10, max_history_chars: int = 5000):
-        self.history = []
-        self.history_size = history_size
-        self.max_history_chars = max_history_chars
-        self.entity_tracker = {}
-        self.conversation_context = ""
-        self.model = None
-        self.last_instructions = None
-    
-    def add_to_history(self, text: str):
-        self.history.append(text)
-        while len(' '.join(self.history)) > self.max_history_chars or len(self.history) > self.history_size:
-            self.history.pop(0)
-        
-        # Update entity tracker
-        doc = nlp(text)
-        for ent in doc.ents:
-            if ent.label_ not in self.entity_tracker:
-                self.entity_tracker[ent.label_] = set()
-            self.entity_tracker[ent.label_].add(ent.text)
-
-        # Update conversation context
-        self.conversation_context += f" {text}"
-        self.conversation_context = ' '.join(self.conversation_context.split()[-100:])  # Keep last 100 words
-
-    def get_context(self):
-        return self.conversation_context
-
-    def is_follow_up_question(self, question):
-        doc = nlp(question.lower())
-        follow_up_indicators = set(['it', 'this', 'that', 'these', 'those', 'he', 'she', 'they', 'them'])
-        return any(token.text in follow_up_indicators for token in doc) or question.strip().startswith("What about")
 
-    def extract_topics(self, text):
-        doc = nlp(text)
-        return [chunk.text for chunk in doc.noun_chunks]
-
-    def extract_instructions(self, text):
-        instruction_patterns = [
-            r"(.*?),?\s*(?:please\s+)?(provide\s+(?:me\s+)?a\s+.*?|give\s+(?:me\s+)?a\s+.*?|create\s+a\s+.*?)$",
-            r"(.*?),?\s*(?:please\s+)?(summarize|analyze|explain|describe|elaborate\s+on).*$",
-            r"(.*?),?\s*(?:please\s+)?(in\s+detail|briefly|concisely).*$",
-        ]
-        
-        for pattern in instruction_patterns:
-            match = re.match(pattern, text, re.IGNORECASE)
-            if match:
-                return match.group(1).strip(), match.group(2).strip()
-
-        return text, None
-
-    def get_most_relevant_context(self, question):
-        if not self.history:
-            return question
-
-        # Create a combined context from history
-        combined_context = self.get_context()
-        
-        # Get embeddings
-        context_embedding = sentence_model.encode([combined_context])[0]
-        question_embedding = sentence_model.encode([question])[0]
-        
-        # Calculate similarity
-        similarity = cosine_similarity([context_embedding], [question_embedding])[0][0]
-        
-        # If similarity is high, it's likely a follow-up question
-        if similarity > 0.5:  # This threshold can be adjusted
-            return f"{combined_context} {question}"
-        
-        # Otherwise, it might be a new topic
-        return question
-    
-    def rephrase_query(self, question, instructions=None):
-        if not self.model:
-            return question  # Return original question if no model is available
-        
-        instruction_prompt = f"Instructions: {instructions}\n" if instructions else ""
-        
-        prompt = f"""
-        Given the conversation context, the current question, and any provided instructions, rephrase the question to include relevant context and rephrase it to more search-engine-friendly query:
-        
-        Conversation context: {self.get_context()}
-        Current question: {question}
-        {instruction_prompt}
-        Rephrased question:
-        """
-        
-        rephrased_question = generate_chunked_response(self.model, prompt)
-        
-        return rephrased_question.strip()
-
-    def process_question(self, question):
-        core_question, instructions = self.extract_instructions(question)
-        
-        if self.is_follow_up_question(core_question):
-            contextualized_question = self.get_most_relevant_context(core_question)
-            contextualized_question = self.rephrase_query(contextualized_question, instructions)
-        else:
-            contextualized_question = core_question
-        
-        topics = self.extract_topics(contextualized_question)
-        
-        self.add_to_history(question)
-        self.last_instructions = instructions
-        
-        return contextualized_question, topics, self.entity_tracker, instructions
-        
-# Initialize LlamaParse
-llama_parser = LlamaParse(
-    api_key=llama_cloud_api_key,
-    result_type="markdown",
-    num_workers=4,
-    verbose=True,
-    language="en",
-)
+def get_model(temperature, top_p, repetition_penalty):
+    return HuggingFaceHub(
+        repo_id="mistralai/Mistral-7B-Instruct-v0.3",
+        model_kwargs={
+            "temperature": temperature,
+            "top_p": top_p,
+            "repetition_penalty": repetition_penalty,
+            "max_length": 1000
+        },
+        huggingfacehub_api_token=huggingface_token
+    )
 
-def load_document(file: NamedTemporaryFile, parser: str = "pypdf") -> 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 load_document(file: NamedTemporaryFile) -> List[Document]:
+    loader = PyPDFLoader(file.name)
+    return loader.load_and_split()
 
-def update_vectors(files, parser):
+def update_vectors(files):
     if not files:
         return "Please upload at least one PDF file."
     
@@ -191,7 +47,7 @@ def update_vectors(files, parser):
     
     all_data = []
     for file in files:
-        data = load_document(file, parser)
+        data = load_document(file)
         all_data.extend(data)
         total_chunks += len(data)
     
@@ -203,7 +59,7 @@ def update_vectors(files, parser):
     
     database.save_local("faiss_database")
     
-    return f"Vector store updated successfully. Processed {total_chunks} chunks from {len(files)} files using {parser}."
+    return f"Vector store updated successfully. Processed {total_chunks} chunks from {len(files)} files."
 
 def get_embeddings():
     return HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
@@ -215,55 +71,6 @@ def clear_cache():
     else:
         return "No cache to clear."
 
-def get_model(temperature, top_p, repetition_penalty):
-    return HuggingFaceHub(
-        repo_id="mistralai/Mistral-7B-Instruct-v0.3",
-        model_kwargs={
-            "temperature": temperature,
-            "top_p": top_p,
-            "repetition_penalty": repetition_penalty,
-            "max_length": 800
-        },
-        huggingfacehub_api_token=huggingface_token
-    )
-
-MAX_PROMPT_CHARS = 20000  # Adjust based on your model's limitations
-
-def chunk_text(text: str, max_chunk_size: int = 800) -> List[str]:
-    chunks = []
-    current_chunk = ""
-    for sentence in re.split(r'(?<=[.!?])\s+', text):
-        if len(current_chunk) + len(sentence) > max_chunk_size:
-            chunks.append(current_chunk.strip())
-            current_chunk = sentence
-        else:
-            current_chunk += " " + sentence
-    if current_chunk:
-        chunks.append(current_chunk.strip())
-    return chunks
-
-def get_most_relevant_chunks(question: str, chunks: List[str], top_k: int = 3) -> List[str]:
-    question_embedding = sentence_model.encode([question])[0]
-    chunk_embeddings = sentence_model.encode(chunks)
-    similarities = cosine_similarity([question_embedding], chunk_embeddings)[0]
-    top_indices = np.argsort(similarities)[-top_k:]
-    return [chunks[i] for i in top_indices]
-
-def generate_chunked_response(model, prompt, max_tokens=800, max_chunks=5):
-    full_response = ""
-    for i in range(max_chunks):
-        try:
-            chunk = model(prompt + full_response, max_new_tokens=max_tokens)
-            chunk = chunk.strip()
-            if chunk.endswith((".", "!", "?")):
-                full_response += chunk
-                break
-            full_response += chunk
-        except Exception as e:
-            print(f"Error in generate_chunked_response: {e}")
-            break
-    return full_response.strip()
-
 def extract_text_from_webpage(html):
     soup = BeautifulSoup(html, 'html.parser')
     for script in soup(["script", "style"]):
@@ -289,8 +96,6 @@ def google_search(term, num_results=5, lang="en", timeout=5, safe="active", ssl_
     all_results = []
     max_chars_per_page = 8000
 
-    print(f"Starting Google search for term: '{term}'")
-
     with requests.Session() as session:
         while start < num_results:
             try:
@@ -312,23 +117,19 @@ def google_search(term, num_results=5, lang="en", timeout=5, safe="active", ssl_
                     verify=ssl_verify,
                 )
                 resp.raise_for_status()
-                print(f"Successfully retrieved search results page (start={start})")
             except requests.exceptions.RequestException as e:
                 print(f"Error retrieving search results: {e}")
                 break
 
             soup = BeautifulSoup(resp.text, "html.parser")
-            result_block = soup.find_all("div", attrs={"class": "g"})
+                result_block = soup.find_all("div", attrs={"class": "g"})
             if not result_block:
-                print("No results found on this page")
                 break
             
-            print(f"Found {len(result_block)} results on this page")
             for result in result_block:
                 link = result.find("a", href=True)
                 if link:
                     link = link["href"]
-                    print(f"Processing link: {link}")
                     try:
                         webpage = session.get(link, headers=headers, timeout=timeout)
                         webpage.raise_for_status()
@@ -336,291 +137,130 @@ def google_search(term, num_results=5, lang="en", timeout=5, safe="active", ssl_
                         if len(visible_text) > max_chars_per_page:
                             visible_text = visible_text[:max_chars_per_page] + "..."
                         all_results.append({"link": link, "text": visible_text})
-                        print(f"Successfully extracted text from {link}")
                     except requests.exceptions.RequestException as e:
                         print(f"Error retrieving webpage content: {e}")
                         all_results.append({"link": link, "text": None})
                 else:
-                    print("No link found for this result")
                     all_results.append({"link": None, "text": None})
             start += len(result_block)
 
-    print(f"Search completed. Total results: {len(all_results)}")
-    
     if not all_results:
-        print("No search results found. Returning a default message.")
         return [{"link": None, "text": "No information found in the web search results."}]
 
     return all_results
 
-def estimate_tokens(text):
-    return len(text.split())
-
-def truncate_text(text, max_tokens):
-    words = text.split()
-    if len(words) <= max_tokens:
-        return text
-    return ' '.join(words[:max_tokens])
-
-def rerank_documents(query: str, documents: List[Document], top_k: int = 5) -> List[Document]:
-    query_embedding = sentence_model.encode([query])[0]
-    doc_embeddings = sentence_model.encode([doc.page_content for doc in documents])
-    
-    similarities = cosine_similarity([query_embedding], doc_embeddings)[0]
-    
-    ranked_indices = similarities.argsort()[::-1][:top_k]
-    return [documents[i] for i in ranked_indices]
-
-def prepare_context(query: str, documents: List[Document], max_tokens: int) -> str:
-    reranked_docs = rerank_documents(query, documents)
-    
-    context = ""
-    for doc in reranked_docs:
-        doc_content = f"Source: {doc.metadata.get('source', 'Unknown')}\nContent: {doc.page_content}\n\n"
-        if estimate_tokens(context + doc_content) > max_tokens:
-            break
-        context += doc_content
-    
-    return truncate_text(context, max_tokens)
-
-# Initialize LlamaCppAgent
-def initialize_llama_cpp_agent():
-    main_model = LlamaCppEndpointSettings(
-        completions_endpoint_url="http://127.0.0.1:8080/completion"
-    )
-    llama_cpp_agent = LlamaCppAgent(
-        main_model,
-        debug_output=False,
-        system_prompt="You are an AI assistant designed to help with RAG tasks.",
-        predefined_messages_formatter_type=MessagesFormatterType.CHATML
-    )
-    return llama_cpp_agent
-
-# Modify the ask_question function to use LlamaCppAgent
-def ask_question(question, temperature, top_p, repetition_penalty, web_search, chatbot, user_instructions):
-    if not question:
-        return "Please enter a question."
-
-    llama_cpp_agent = initialize_llama_cpp_agent()
+def duckduckgo_search(query):
+    # Implement DuckDuckGo search here
+    # This is a placeholder. You'll need to implement the actual DuckDuckGo search functionality
+    return [{"link": "https://example.com", "text": "Example search result from DuckDuckGo"}]
+
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    temperature,
+    top_p,
+    repetition_penalty,
+    max_tokens,
+    search_engine
+):
     model = get_model(temperature, top_p, repetition_penalty)
-    
-    # Update the chatbot's model
-    chatbot.model = model
 
-    embed = get_embeddings()
+    # Perform web search
+    if search_engine == "Google":
+        search_results = google_search(message)
+    else:
+        search_results = duckduckgo_search(message)
 
+    # Check if we have a FAISS database
     if os.path.exists("faiss_database"):
+        embed = get_embeddings()
         database = FAISS.load_local("faiss_database", embed, allow_dangerous_deserialization=True)
+        retriever = database.as_retriever()
+        relevant_docs = retriever.get_relevant_documents(message)
+        context_str = "\n".join([doc.page_content for doc in relevant_docs])
+        
+        # Use the context in the prompt
+        prompt_template = f"""
+        Answer the question based on the following context and web search results:
+        Context from documents:
+        {context_str}
+        
+        Web Search Results:
+        {{search_results}}
+        
+        Question: {{message}}
+        
+        If the context and web search results don't contain relevant information, state that the information is not available.
+        Provide a concise and direct answer to the question.
+        """
     else:
-        database = None
-
-    max_attempts = 3
-    max_input_tokens = 20000
-    max_output_tokens = 800
-
-    if web_search:
-        contextualized_question, topics, entity_tracker, _ = chatbot.process_question(question)
+        prompt_template = """
+        Answer the question based on the following web search results:
+        Web Search Results:
+        {search_results}
         
-        try:
-            search_results = google_search(contextualized_question, num_results=5)
-        except Exception as e:
-            print(f"Error in web search: {e}")
-            return f"I apologize, but I encountered an error while searching for information: {str(e)}"
-
-        all_answers = []
-
-        for attempt in range(max_attempts):
-            try:
-                web_docs = [Document(page_content=result["text"], metadata={"source": result["link"]}) for result in search_results if result["text"]]
-
-                if not web_docs:
-                    return "I'm sorry, but I couldn't find any relevant information from the web search."
-
-                if database is None:
-                    database = FAISS.from_documents(web_docs, embed)
-                else:
-                    database.add_documents(web_docs)
-
-                database.save_local("faiss_database")
-
-                context_str = prepare_context(contextualized_question, web_docs, max_input_tokens // 2)
-
-                instruction_prompt = f"User Instructions: {user_instructions}\n" if user_instructions else ""
-
-                prompt_template = f"""
-                Answer the question based on the following web search results, conversation context, entity information, and user instructions:
-                Web Search Results:
-                {{context}}
-                Conversation Context: {{conv_context}}
-                Current Question: {{question}}
-                Topics: {{topics}}
-                Entity Information: {{entities}}
-                {instruction_prompt}
-                Provide a concise and relevant answer to the question.
-                """
-
-                current_conv_context = truncate_text(chatbot.get_context(), max_input_tokens // 4)
-                current_topics = topics[:5]
-                current_entities = {k: list(v)[:3] for k, v in entity_tracker.items()}
-
-                formatted_prompt = prompt_template.format(
-                    context=context_str,
-                    conv_context=current_conv_context,
-                    question=question,
-                    topics=", ".join(current_topics),
-                    entities=json.dumps(current_entities)
-                )
-
-                if estimate_tokens(formatted_prompt) > max_input_tokens:
-                    formatted_prompt = truncate_text(formatted_prompt, max_input_tokens)
-
-                try:
-                    # Use LlamaCppAgent for initial response generation
-                    initial_response = llama_cpp_agent.get_chat_response(formatted_prompt, temperature=temperature)
-                    
-                    # Use generate_chunked_response for further refinement if needed
-                    full_response = generate_chunked_response(model, initial_response, max_tokens=max_output_tokens)
-                    
-                    answer = extract_answer(full_response, user_instructions)
-                    all_answers.append(answer)
-                    break
-                except Exception as e:
-                    print(f"Error in response generation: {e}")
-                    if attempt == max_attempts - 1:
-                        all_answers.append(f"I apologize, but I encountered an error while generating the response. Please try again with a simpler question.")
-
-            except Exception as e:
-                print(f"Error in ask_question (attempt {attempt + 1}): {e}")
-                if attempt == max_attempts - 1:
-                    all_answers.append(f"I apologize, but an unexpected error occurred. Please try again with a different question or check your internet connection.")
-
-        answer = "\n\n".join(all_answers)
-        sources = set(doc.metadata['source'] for doc in web_docs)
-        sources_section = "\n\nSources:\n" + "\n".join(f"- {source}" for source in sources)
-        answer += sources_section
-
-        chatbot.add_to_history(answer)
-
-        return answer
-
-    else:  # PDF document chat
-        for attempt in range(max_attempts):
-            try:
-                if database is None:
-                    return "No documents available. Please upload PDF documents to answer questions."
-
-                retriever = database.as_retriever(search_kwargs={"k": 5})
-                relevant_docs = retriever.get_relevant_documents(question)
-                
-                context_str = prepare_context(question, relevant_docs, max_input_tokens // 2)
-
-                instruction_prompt = f"User Instructions: {user_instructions}\n" if user_instructions else ""
-
-                prompt_template = f"""
-                Answer the question based on the following context from the PDF document:
-                Context:
-                {{context}}
-                Question: {{question}}
-                {instruction_prompt}
-                Provide a summarized and direct answer to the question.
-                """
-
-                formatted_prompt = prompt_template.format(context=context_str, question=question)
-
-                if estimate_tokens(formatted_prompt) > max_input_tokens:
-                    formatted_prompt = truncate_text(formatted_prompt, max_input_tokens)
-
-                try:
-                    # Use LlamaCppAgent for initial response generation
-                    initial_response = llama_cpp_agent.get_chat_response(formatted_prompt, temperature=temperature)
-                    
-                    # Use generate_chunked_response for further refinement if needed
-                    full_response = generate_chunked_response(model, initial_response, max_tokens=max_output_tokens)
-                    
-                    answer = extract_answer(full_response, user_instructions)
-                    return answer
-                except Exception as e:
-                    print(f"Error in response generation: {e}")
-                    if attempt == max_attempts - 1:
-                        return f"I apologize, but I encountered an error while generating the response. Please try again with a simpler question."
-
-            except Exception as e:
-                print(f"Error in ask_question (attempt {attempt + 1}): {e}")
-                if attempt == max_attempts - 1:
-                    return f"I apologize, but an unexpected error occurred. Please try again with a different question."
+        Question: {message}
+        
+        If the web search results don't contain relevant information, state that the information is not available.
+        Provide a concise and direct answer to the question.
+        """
 
-    return "An unexpected error occurred. Please try again later."
+    prompt = PromptTemplate(
+        input_variables=["search_results", "message"],
+        template=prompt_template
+    )
 
+    chain = LLMChain(llm=model, prompt=prompt)
 
-def extract_answer(full_response, instructions=None):
-    answer_patterns = [
-        r"Provide a concise and direct answer to the question without mentioning the web search or these instructions:",
-        r"Provide a concise and direct answer to the question:",
-        r"Provide a concise and relevant answer to the question.",
-        r"Answer:",
-        r"Provide a summarized and direct answer to the question.",
-        r"If the context doesn't contain relevant information, state that the information is not available in the document.",
-        r"Provide a summarized and direct answer to the original question without mentioning the web search or these instructions:",
-        r"Do not include any source information in your answer."     
-    ]
+    search_results_text = "\n".join([f"- {result['text']}" for result in search_results if result['text']])
+    response = chain.run(search_results=search_results_text, message=message)
 
-    for pattern in answer_patterns:
-        match = re.split(pattern, full_response, flags=re.IGNORECASE)
-        if len(match) > 1:
-            full_response = match[-1].strip()
-            break
-    
-    # Remove any remaining instruction-like phrases
-    cleanup_patterns = [
-        r"without mentioning the web search or these instructions\.",
-        r"Do not include any source information in your answer\.",
-        r"If the context doesn't contain relevant information, state that the information is not available in the document\."
-    ]
+    # Add sources
+    sources = set(result["link"] for result in search_results if result["link"])
+    sources_section = "\n\nSources:\n" + "\n".join(f"- {source}" for source in sources)
+    response += sources_section
 
-    for pattern in cleanup_patterns:
-        full_response = re.sub(pattern, "", full_response, flags=re.IGNORECASE).strip()
-    
-    # Remove the user instructions if present
-    if instructions:
-        instruction_pattern = rf"User Instructions:\s*{re.escape(instructions)}.*?\n"
-        full_response = re.sub(instruction_pattern, "", full_response, flags=re.IGNORECASE | re.DOTALL)
-    
-    return full_response.strip()
+    return response
 
 # Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Enhanced PDF Document Chat and Web Search")
+demo = gr.Blocks()
+
+with demo:
+    gr.Markdown("# Chat with your PDF documents and Web Search")
     
     with gr.Row():
         file_input = gr.Files(label="Upload your PDF documents", file_types=[".pdf"])
-        parser_dropdown = gr.Dropdown(choices=["pypdf", "llamaparse"], label="Select PDF Parser", value="pypdf")
         update_button = gr.Button("Upload PDF")
     
     update_output = gr.Textbox(label="Update Status")
-    update_button.click(update_vectors, inputs=[file_input, parser_dropdown], outputs=update_output)
+    update_button.click(update_vectors, inputs=[file_input], outputs=update_output)
     
     with gr.Row():
         with gr.Column(scale=2):
             chatbot = gr.Chatbot(label="Conversation")
-            question_input = gr.Textbox(label="Ask a question")
-            instructions_input = gr.Textbox(label="Instructions for response (optional)", placeholder="Enter any specific instructions for the response here")
+            message_input = gr.Textbox(label="Enter your message")
             submit_button = gr.Button("Submit")
         with gr.Column(scale=1):
-            temperature_slider = gr.Slider(label="Temperature", minimum=0.0, maximum=1.0, value=0.5, step=0.1)
-            top_p_slider = gr.Slider(label="Top P", minimum=0.0, maximum=1.0, value=0.9, step=0.1)
-            repetition_penalty_slider = gr.Slider(label="Repetition Penalty", minimum=1.0, maximum=2.0, value=1.0, step=0.1)
-            web_search_checkbox = gr.Checkbox(label="Enable Web Search", value=False)
-
-    enhanced_context_driven_chatbot = EnhancedContextDrivenChatbot()
-
-    # Update the chat function to use the modified ask_question function
-    def chat(question, history, temperature, top_p, repetition_penalty, web_search, user_instructions):
-        answer = ask_question(question, temperature, top_p, repetition_penalty, web_search, enhanced_context_driven_chatbot, user_instructions)
-        history.append((question, answer))
-        return "", history
+            temperature = gr.Slider(minimum=0.1, maximum=1.0, value=0.7, step=0.1, label="Temperature")
+            top_p = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p")
+            repetition_penalty = gr.Slider(minimum=1.0, maximum=2.0, value=1.1, step=0.1, label="Repetition penalty")
+            max_tokens = gr.Slider(minimum=1, maximum=1000, value=500, step=1, label="Max tokens")
+            search_engine = gr.Dropdown(["DuckDuckGo", "Google"], value="DuckDuckGo", label="Search Engine")
+
+    submit_button.click(
+        respond,
+        inputs=[
+            message_input,
+            chatbot,
+            temperature,
+            top_p,
+            repetition_penalty,
+            max_tokens,
+            search_engine
+        ],
+        outputs=chatbot
+    )
     
-    submit_button.click(chat, inputs=[question_input, chatbot, temperature_slider, top_p_slider, repetition_penalty_slider, web_search_checkbox, instructions_input], outputs=[question_input, chatbot])
-
     clear_button = gr.Button("Clear Cache")
     clear_output = gr.Textbox(label="Cache Status")
     clear_button.click(clear_cache, inputs=[], outputs=clear_output)