app.py

import os
import json
import re
import gradio as gr
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 bs4 import BeautifulSoup
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain_core.prompts import ChatPromptTemplate
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

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=10, model=None):
        self.history = []
        self.history_size = history_size
        self.entity_tracker = {}
        self.conversation_context = ""
        self.model = model

    def add_to_history(self, text):
        self.history.append(text)
        if 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)

    def extract_topics(self, text):
        doc = nlp(text)
        return [chunk.text for chunk in doc.noun_chunks]

    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):
        if not self.model:
            return question  # Return original question if no model is available
        
        prompt = f"""
        Given the conversation context and the current question, rephrase the question to include relevant context:
        
        Conversation context: {self.get_context()}
        Current question: {question}
        
        Rephrased question:
        """
        
        rephrased_question = generate_chunked_response(self.model, prompt)
        
        return rephrased_question.strip()

    def process_question(self, question):
        contextualized_question = self.get_most_relevant_context(question)
        
        topics = self.extract_topics(question)
        
        if self.is_follow_up_question(question):
            contextualized_question = self.rephrase_query(contextualized_question)
        
        self.add_to_history(question)
        
        return contextualized_question, topics, self.entity_tracker
        
# Initialize LlamaParse
llama_parser = LlamaParse(
    api_key=llama_cloud_api_key,
    result_type="markdown",
    num_workers=4,
    verbose=True,
    language="en",
)

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 update_vectors(files, parser):
    if not files:
        return "Please upload at least one PDF file."
    
    embed = get_embeddings()
    total_chunks = 0
    
    all_data = []
    for file in files:
        data = load_document(file, parser)
        all_data.extend(data)
        total_chunks += len(data)
    
    if os.path.exists("faiss_database"):
        database = FAISS.load_local("faiss_database", embed, allow_dangerous_deserialization=True)
        database.add_documents(all_data)
    else:
        database = FAISS.from_documents(all_data, embed)
    
    database.save_local("faiss_database")
    
    return f"Vector store updated successfully. Processed {total_chunks} chunks from {len(files)} files using {parser}."

def get_embeddings():
    return HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")

def clear_cache():
    if os.path.exists("faiss_database"):
        os.remove("faiss_database")
        return "Cache cleared successfully."
    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": 1000
        },
        huggingfacehub_api_token=huggingface_token
    )

def generate_chunked_response(model, prompt, max_tokens=1000, 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"]):
        script.extract()
    text = soup.get_text()
    lines = (line.strip() for line in text.splitlines())
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    text = '\n'.join(chunk for chunk in chunks if chunk)
    return text

_useragent_list = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edge/91.0.864.59 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Edge/91.0.864.59 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Safari/537.36",
]

def google_search(term, num_results=5, lang="en", timeout=5, safe="active", ssl_verify=None):
    escaped_term = urllib.parse.quote_plus(term)
    start = 0
    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:
                user_agent = random.choice(_useragent_list)
                headers = {
                    'User-Agent': user_agent
                }
                resp = session.get(
                    url="https://www.google.com/search",
                    headers=headers,
                    params={
                        "q": term,
                        "num": num_results - start,
                        "hl": lang,
                        "start": start,
                        "safe": safe,
                    },
                    timeout=timeout,
                    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"})
            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()
                        visible_text = extract_text_from_webpage(webpage.text)
                        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 ask_question(question, temperature, top_p, repetition_penalty, web_search, chatbot):
    if not question:
        return "Please enter a question."

    model = get_model(temperature, top_p, repetition_penalty)
    
    # Update the chatbot's model
    chatbot.model = model

    embed = get_embeddings()

    if os.path.exists("faiss_database"):
        database = FAISS.load_local("faiss_database", embed, allow_dangerous_deserialization=True)
    else:
        database = None

    max_attempts = 3
    context_reduction_factor = 0.7

    if web_search:
        contextualized_question, topics, entity_tracker = chatbot.process_question(question)
        serializable_entity_tracker = {k: list(v) for k, v in entity_tracker.items()}
        search_results = google_search(contextualized_question)
        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 database is None:
                    database = FAISS.from_documents(web_docs, embed)
                else:
                    database.add_documents(web_docs)

                database.save_local("faiss_database")

                context_str = "\n".join([f"Source: {doc.metadata['source']}\nContent: {doc.page_content}" for doc in web_docs])

                prompt_template = """
                Answer the question based on the following web search results, conversation context, and entity information:
                Web Search Results:
                {context}
                Conversation Context: {conv_context}
                Current Question: {question}
                Topics: {topics}
                Entity Information: {entities}
                If the web search results don't contain relevant information, state that the information is not available in the search results.
                Provide a summarized and direct answer to the question without mentioning the web search or these instructions.
                Do not include any source information in your answer.                    
                """

                prompt_val = ChatPromptTemplate.from_template(prompt_template)
                formatted_prompt = prompt_val.format(
                    context=context_str, 
                    conv_context=chatbot.get_context(), 
                    question=contextualized_question,
                    topics=", ".join(topics),
                    entities=json.dumps(serializable_entity_tracker)
                )

                full_response = generate_chunked_response(model, formatted_prompt)
                answer = extract_answer(full_response)
                all_answers.append(answer)
                break

            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 I'm having trouble processing the query due to its length or complexity.")

        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

        # Update chatbot context with the answer
        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()
                relevant_docs = retriever.get_relevant_documents(question)
                context_str = "\n".join([doc.page_content for doc in relevant_docs])

                if attempt > 0:
                    words = context_str.split()
                    context_str = " ".join(words[:int(len(words) * context_reduction_factor)])

                prompt_template = """
                Answer the question based on the following context from the PDF document:
                Context:
                {context}
                Question: {question}
                If the context doesn't contain relevant information, state that the information is not available in the document.
                Provide a summarized and direct answer to the question.
                """

                prompt_val = ChatPromptTemplate.from_template(prompt_template)
                formatted_prompt = prompt_val.format(context=context_str, question=question)

                full_response = generate_chunked_response(model, formatted_prompt)
                answer = extract_answer(full_response)

                return answer

            except Exception as e:
                print(f"Error in ask_question (attempt {attempt + 1}): {e}")
                if attempt == max_attempts - 1:
                    return f"I apologize, but I'm having trouble processing your question. Could you please try rephrasing it more concisely?"

    return "An unexpected error occurred. Please try again later."

def extract_answer(full_response):
    # First, try to split the response at common instruction phrases
    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"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."     
    ]

    for pattern in answer_patterns:
        match = re.split(pattern, full_response, flags=re.IGNORECASE)
        if len(match) > 1:
            full_response = match[-1].strip()
            break
    
    # Then, 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\."
    ]

    for pattern in cleanup_patterns:
        full_response = re.sub(pattern, "", full_response, flags=re.IGNORECASE).strip()
    
    return full_response

# Gradio interface
with gr.Blocks() as demo:
    gr.Markdown("# Enhanced PDF Document Chat 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)
    
    with gr.Row():
        with gr.Column(scale=2):
            chatbot = gr.Chatbot(label="Conversation")
            question_input = gr.Textbox(label="Ask a question")
            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()

    def chat(question, history, temperature, top_p, repetition_penalty, web_search):
        answer = ask_question(question, temperature, top_p, repetition_penalty, web_search, enhanced_context_driven_chatbot)
        history.append((question, answer))
        return "", history
    
    submit_button.click(chat, inputs=[question_input, chatbot, temperature_slider, top_p_slider, repetition_penalty_slider, web_search_checkbox], 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)

if __name__ == "__main__":
    demo.launch()