cod-app.text

import gradio as gr
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings  # Updated for Persian embeddings
from langchain.vectorstores import FAISS
from langchain.memory import ConversationBufferMemory
from groq import Groq
import requests
from bs4 import BeautifulSoup
from serpapi import GoogleSearch
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

client = Groq(api_key="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")

embedding_model = HuggingFaceEmbeddings(model_name="HooshvareLab/bert-fa-base-uncased")

memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

def process_pdf_with_langchain(pdf_path):
    try:
        loader = PyPDFLoader(pdf_path)
        documents = loader.load()
        text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
        split_documents = text_splitter.split_documents(documents)

        vectorstore = FAISS.from_documents(split_documents, embedding_model)
        retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
        return retriever
    except Exception as e:
        logger.error(f"Error processing PDF: {e}")
        raise

SERPAPI_KEY = "8a20e83850a3be0a0b4e3aed98bd3addbad56e82d52e639e1a692a02d021bca1"

def scrape_google_search(query, num_results=3):
    try:
        params = {
            "q": query,
            "hl": "fa",
            "gl": "ir",
            "num": num_results,
            "api_key": SERPAPI_KEY,
        }
        search = GoogleSearch(params)
        results = search.get_dict()

        if "error" in results:
            return f"Error: {results['error']}"

        search_results = []
        for result in results.get("organic_results", []):
            title = result.get("title", "No Title")
            link = result.get("link", "No Link")
            search_results.append(f"{title}: {link}")
        return "\n".join(search_results) if search_results else "No results found"
    except Exception as e:
        logger.error(f"Error scraping Google search: {e}")
        return f"Error: {e}"

def scrape_webpage(url):
    try:
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
        }
        response = requests.get(url, headers=headers)
        response.raise_for_status()

        soup = BeautifulSoup(response.content, "html.parser")
        text = soup.get_text(separator="\n")
        return text.strip()
    except Exception as e:
        logger.error(f"Error scraping webpage {url}: {e}")
        return f"Error: {e}"

def generate_response(query, retriever=None, use_web_search=False, scrape_web=False):
    try:
        knowledge = ""

        if retriever:
            relevant_docs = retriever.get_relevant_documents(query)
            knowledge += "\n".join([doc.page_content for doc in relevant_docs])

        if use_web_search:
            web_results = scrape_google_search(query)
            knowledge += f"\n\nWeb Search Results:\n{web_results}"

        if scrape_web:
            urls = [word for word in query.split() if word.startswith("http://") or word.startswith("https://")]
            for url in urls:
                webpage_content = scrape_webpage(url)
                knowledge += f"\n\nWebpage Content from {url}:\n{webpage_content}"

        chat_history = memory.load_memory_variables({}).get("chat_history", "")
        context = (
            f"This is a conversation with ParvizGPT, an AI model designed by Amir Mahdi Parviz from Kermanshah University of Technology (KUT), "
            f"to help with tasks like answering questions in Persian, providing recommendations, and decision-making."
        )
        if knowledge:
            context += f"\n\nRelevant Knowledge:\n{knowledge}"
        if chat_history:
            context += f"\n\nChat History:\n{chat_history}"

        context += f"\n\nYou: {query}\nParvizGPT:"

        chat_completion = client.chat.completions.create(
            messages=[{"role": "user", "content": context}],
            model=  "gemma2-9b-it" #"llama-3.3-70b-versatile",
        )
        response = chat_completion.choices[0].message.content.strip()

        memory.save_context({"input": query}, {"output": response})
        return response
    except Exception as e:
        logger.error(f"Error generating response: {e}")
        return f"Error: {e}"

def gradio_interface(user_message, chat_box, pdf_file=None, enable_web_search=False, scrape_web=False):
    global retriever
    if pdf_file is not None:
        try:
            retriever = process_pdf_with_langchain(pdf_file.name)
        except Exception as e:
            return chat_box + [("Error", f"Error processing PDF: {e}")]

    response = generate_response(user_message, retriever=retriever, use_web_search=enable_web_search, scrape_web=scrape_web)
    chat_box.append(("You", user_message))
    chat_box.append(("ParvizGPT", response))
    return chat_box

def clear_memory():
    memory.clear()
    return []

retriever = None

with gr.Blocks() as interface:
    gr.Markdown("## ParvizGPT")
    chat_box = gr.Chatbot(label="Chat History", value=[])

    user_message = gr.Textbox(
        label="Your Message",
        placeholder="Type your message here and press Enter...",
        lines=1,
        interactive=True,
    )
    enable_web_search = gr.Checkbox(label="🌐Enable Web Search", value=False)
    scrape_web = gr.Checkbox(label="🌍Scrape Webpages", value=False)

    clear_memory_btn = gr.Button("Clear Memory", interactive=True)
    pdf_file = gr.File(label="Upload PDF for Context (Optional)", type="filepath", interactive=True , scale=1)

    submit_btn = gr.Button("Submit")
    submit_btn.click(gradio_interface, inputs=[user_message, chat_box, pdf_file, enable_web_search, scrape_web], outputs=chat_box)
    user_message.submit(gradio_interface, inputs=[user_message, chat_box, pdf_file, enable_web_search, scrape_web], outputs=chat_box)
    clear_memory_btn.click(clear_memory, inputs=[], outputs=chat_box)

interface.launch()