changed to old one and enhanced a bit

app.py

@@ -10,208 +10,183 @@ from langchain_community.vectorstores import FAISS
 from langchain_huggingface import HuggingFaceEmbeddings
 from threading import Thread
 from dotenv import load_dotenv
-import json
 
 load_dotenv()
 
-# === CONFIG ===
+=== CONFIG ===
+
 STORAGE_DIR = "storage"
-CLEANUP_INTERVAL = 600
-SESSION_TTL = 1000
+CLEANUP_INTERVAL = 600  # 10 min
+SESSION_TTL = 1000      # 30 min
 OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
 OPENROUTER_MODEL = "z-ai/glm-4.5-air:free"
 
 if not os.path.exists(STORAGE_DIR):
-    os.makedirs(STORAGE_DIR)
+os.makedirs(STORAGE_DIR)
+
+=== CLEANUP THREAD ===
 
-# === CLEANUP THREAD ===
 def cleanup_old_sessions():
-    while True:
-        now = time.time()
-        for folder in os.listdir(STORAGE_DIR):
-            path = os.path.join(STORAGE_DIR, folder)
-            if os.path.isdir(path) and now - os.path.getmtime(path) > SESSION_TTL:
-                shutil.rmtree(path)
-        time.sleep(CLEANUP_INTERVAL)
+while True:
+now = time.time()
+for folder in os.listdir(STORAGE_DIR):
+path = os.path.join(STORAGE_DIR, folder)
+if os.path.isdir(path) and now - os.path.getmtime(path) > SESSION_TTL:
+shutil.rmtree(path)
+time.sleep(CLEANUP_INTERVAL)
 
 Thread(target=cleanup_old_sessions, daemon=True).start()
 
-# === PDF PROCESSING ===
+=== PDF PROCESSING ===
+
 def process_pdf(pdf_file):
-    if pdf_file is None:
-        return "No file uploaded.", "", []
+if pdf_file is None:
+return "No file uploaded.", "", []
+session_id = str(uuid.uuid4())
+reader = PdfReader(pdf_file.name)
+text = "".join([page.extract_text() for page in reader.pages if page.extract_text()])
+
+splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)  
+chunks = splitter.split_text(text)  
 
-    session_id = str(uuid.uuid4())
-    reader = PdfReader(pdf_file.name)
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")  
+session_path = os.path.join(STORAGE_DIR, session_id)  
+os.makedirs(session_path, exist_ok=True)  
 
-    metadata = reader.metadata or {}
-    num_pages = len(reader.pages)
-    title = metadata.get("/Title", "Unknown Title")
-    author = metadata.get("/Author", "Unknown Author")
+db = FAISS.from_texts(chunks, embeddings)  
+db.save_local(session_path)  
 
-    text = "".join([page.extract_text() for page in reader.pages if page.extract_text()])
+chat_history = [("System", "Paper uploaded and processed. You can now ask questions.")]  
+return f"Paper uploaded successfully. Session ID: {session_id}", session_id, chat_history
 
-    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-    chunks = splitter.split_text(text)
+=== QUERY FUNCTION ===
 
-    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-    session_path = os.path.join(STORAGE_DIR, session_id)
-    os.makedirs(session_path, exist_ok=True)
+def query_paper(session_id, user_message, chat_history):
+if not session_id or not os.path.exists(os.path.join(STORAGE_DIR, session_id)):
+chat_history = chat_history or []
+chat_history.append(("System", "Session expired or not found. Upload the paper again."))
+return chat_history, ""
 
-    db = FAISS.from_texts(chunks, embeddings)
-    db.save_local(session_path)
+if not user_message.strip():  
+    return chat_history, ""  
 
-    meta_data = {
-        "title": title,
-        "author": author,
-        "pages": num_pages,
-        "session_id": session_id,
-        "created_at": time.ctime()
-    }
-    with open(os.path.join(session_path, "metadata.json"), "w") as f:
-        json.dump(meta_data, f)
+session_path = os.path.join(STORAGE_DIR, session_id)  
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")  
+db = FAISS.load_local(session_path, embeddings, allow_dangerous_deserialization=True)  
+retriever = db.as_retriever(search_kwargs={"k": 3})  
 
-    chat_history = [
-        {"role": "system", "content": f"📄 Paper uploaded.\nTitle: {title}\nAuthor: {author}\nPages: {num_pages}"}
-    ]
-    return f"Paper uploaded successfully. Session ID: {session_id}", session_id, chat_history
+# Use invoke() method  
+docs = retriever.invoke(user_message)  
+context = "\n\n".join([d.page_content for d in docs])  
 
-# === QUERY FUNCTION ===
-def query_paper(session_id, user_message, chat_history):
-    if not session_id or not os.path.exists(os.path.join(STORAGE_DIR, session_id)):
-        chat_history = chat_history or []
-        chat_history.append({"role": "system", "content": "Session expired or not found. Upload the paper again."})
-        return chat_history, ""
-
-    if not user_message.strip():
-        return chat_history, ""
-
-    session_path = os.path.join(STORAGE_DIR, session_id)
-    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-    db = FAISS.load_local(session_path, embeddings, allow_dangerous_deserialization=True)
-    retriever = db.as_retriever(search_kwargs={"k": 3})
-
-    metadata_path = os.path.join(session_path, "metadata.json")
-    if os.path.exists(metadata_path):
-        with open(metadata_path, "r") as f:
-            metadata = json.load(f)
-    else:
-        metadata = {"title": "Unknown", "author": "Unknown", "pages": "Unknown"}
-
-    lower_q = user_message.lower()
-    if "title" in lower_q or "name of this paper" in lower_q:
-        answer = f"The title of this paper is: **{metadata['title']}**."
-    elif "author" in lower_q or "who wrote" in lower_q:
-        answer = f"The author of this paper is: **{metadata['author']}**."
-    elif "pages" in lower_q or "how many pages" in lower_q:
-        answer = f"This paper has **{metadata['pages']} pages**."
-    else:
-        docs = retriever.invoke(user_message)
-        context = "\n\n".join([d.page_content for d in docs])
-
-        prompt = f"""
-You are an AI research assistant. Use the paper content and metadata to answer clearly.
-
-Paper Metadata:
-- Title: {metadata['title']}
-- Author: {metadata['author']}
-- Pages: {metadata['pages']}
+prompt = f"""
 
+You are an AI assistant. Explain the following research paper content in simple terms and answer the question. Use your own knowledge also and make it more technical but simpler explanation should be like professor with high knowledge but teaches in awesome way with more technical stuff but easier
 Context from paper:
 {context}
 
 Question: {user_message}
 Answer:
 """
-        headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json"}
-        payload = {
-            "model": OPENROUTER_MODEL,
-            "messages": [
-                {"role": "system", "content": "You are a helpful research explainer. Always use metadata if available."},
-                {"role": "user", "content": prompt}
-            ]
-        }
-
-        try:
-            response = requests.post("https://openrouter.ai/api/v1/chat/completions",
-                                     headers=headers, json=payload)
-            if response.status_code == 200:
-                answer = response.json()["choices"][0]["message"]["content"].strip()
-            else:
-                answer = f"Error: {response.status_code} - {response.text}"
-        except Exception as e:
-            answer = f"Error: {str(e)}"
-
-    chat_history = chat_history or []
-    chat_history.append({"role": "user", "content": user_message})
-    chat_history.append({"role": "assistant", "content": answer})
-    return chat_history, ""
-
-# === GRADIO UI ===
+
+headers = {"Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json"}  
+payload = {  
+    "model": OPENROUTER_MODEL,  
+    "messages": [  
+        {"role": "system", "content": "You are a helpful research paper explainer.Explain all concepts clearly with technical aspects but in a easy way that user can understand easily and gains more knowledge don't be greedy and use more tokens if question is more or it's about the research paper"},  
+        {"role": "user", "content": prompt}  
+    ]  
+}  
+
+try:  
+    response = requests.post("https://openrouter.ai/api/v1/chat/completions",  
+                             headers=headers, json=payload)  
+
+    if response.status_code == 200:  
+        answer = response.json()["choices"][0]["message"]["content"].strip()  
+    else:  
+        answer = f"Error: {response.status_code} - {response.text}"  
+except Exception as e:  
+    answer = f"Error: {str(e)}"  
+
+# Update chat history  
+chat_history = chat_history or []  
+chat_history.append((user_message, answer))  
+  
+return chat_history, ""
+
+=== GRADIO UI ===
+
 with gr.Blocks() as demo:
-    gr.Markdown("## 📄 Research Paper Chatbot (RAG + OpenRouter)")
-
-    with gr.Row():
-        pdf_input = gr.File(label="Upload Research Paper (PDF)", file_types=[".pdf"])
-        session_box = gr.Textbox(label="Session ID", interactive=False)
-
-    chatbot = gr.Chatbot(label="Chat about your paper", type="messages", height=400)
-    user_message = gr.Textbox(label="Ask a question", placeholder="What is this paper about?")
-
-    with gr.Row():
-        upload_btn = gr.Button("Upload Paper", variant="primary")
-        ask_btn = gr.Button("Send Question")
-        clear_btn = gr.Button("Clear Chat")
-
-    state_chat = gr.State([])
-    state_session = gr.State("")
-
-    def handle_upload(pdf_file):
-        status, session_id, chat_history = process_pdf(pdf_file)
-        return status, session_id, chat_history
-
-    upload_btn.click(
-        fn=handle_upload,
-        inputs=[pdf_input],
-        outputs=[session_box, state_session, state_chat]
-    )
-
-    def handle_question(session_id, message, chat_history):
-        updated_chat, _ = query_paper(session_id, message, chat_history)
-        return updated_chat, ""
-
-    ask_btn.click(
-        fn=handle_question,
-        inputs=[state_session, user_message, state_chat],
-        outputs=[chatbot, user_message]
-    ).then(
-        lambda chat: chat,
-        inputs=[chatbot],
-        outputs=[state_chat]
-    )
-
-    user_message.submit(
-        fn=handle_question,
-        inputs=[state_session, user_message, state_chat],
-        outputs=[chatbot, user_message]
-    ).then(
-        lambda chat: chat,
-        inputs=[chatbot],
-        outputs=[state_chat]
-    )
-
-    def clear_chat():
-        return [], []
-
-    clear_btn.click(
-        fn=clear_chat,
-        outputs=[chatbot, state_chat]
-    )
-
-    state_chat.change(
-        lambda chat: chat,
-        inputs=[state_chat],
-        outputs=[chatbot]
-    )
-
-demo.launch(debug=True, server_name="0.0.0.0", server_port=7860)
+gr.Markdown("## 📄 Research Paper Chatbot (RAG + OpenRouter)")
+
+with gr.Row():  
+    pdf_input = gr.File(label="Upload Research Paper (PDF)", file_types=[".pdf"])  
+    session_box = gr.Textbox(label="Session ID", interactive=False)  
+
+chatbot = gr.Chatbot(label="Chat about your paper", height=400)  
+user_message = gr.Textbox(label="Ask a question", placeholder="What is this paper about?")  
+
+with gr.Row():  
+    upload_btn = gr.Button("Upload Paper", variant="primary")  
+    ask_btn = gr.Button("Send Question")  
+    clear_btn = gr.Button("Clear Chat")  
+
+# Store chat history and session  
+state_chat = gr.State([])  
+state_session = gr.State("")  
+
+# Upload button functionality  
+def handle_upload(pdf_file):  
+    status, session_id, chat_history = process_pdf(pdf_file)  
+    return status, session_id, chat_history  
+
+upload_btn.click(  
+    fn=handle_upload,  
+    inputs=[pdf_input],  
+    outputs=[session_box, state_session, state_chat]  
+)  
+
+# Ask button functionality  
+def handle_question(session_id, message, chat_history):  
+    updated_chat, _ = query_paper(session_id, message, chat_history)  
+    return updated_chat, ""  
+
+ask_btn.click(  
+    fn=handle_question,  
+    inputs=[state_session, user_message, state_chat],  
+    outputs=[chatbot, user_message]  
+).then(  
+    lambda chat: chat,  
+    inputs=[chatbot],  
+    outputs=[state_chat]  
+)  
+
+# Submit on enter  
+user_message.submit(  
+    fn=handle_question,  
+    inputs=[state_session, user_message, state_chat],  
+    outputs=[chatbot, user_message]  
+).then(  
+    lambda chat: chat,  
+    inputs=[chatbot],  
+    outputs=[state_chat]  
+)  
+
+# Clear chat  
+def clear_chat():  
+    return [], []  
+
+clear_btn.click(  
+    fn=clear_chat,  
+    outputs=[chatbot, state_chat]  
+)  
+
+# Update chatbot display when chat history changes  
+state_chat.change(  
+    lambda chat: chat,  
+    inputs=[state_chat],  
+    outputs=[chatbot]  
+)
+
+demo.launch(debug=True)