second iteration

app.py

@@ -2,29 +2,61 @@ import gradio as gr
 from utils.pdf_parser import extract_text_from_pdf
 from summarizer import Summarizer
 from qa_engine import QABot
+from chatbot import ask_model
+from suggestions import suggest_questions
 
+# Initialize summarizer and global variables
 summarizer = Summarizer()
+qa_bot = None
+summary = ""
+text_chunks = []
 
-def summarize_and_answer(pdf_file, question):
-    text = extract_text_from_pdf(pdf_file.name)
+# Gradio chat history
+chat_history = []
+
+def process_pdf(file):
+    global summary, qa_bot, text_chunks, chat_history
+    text = extract_text_from_pdf(file.name)
     summary = summarizer.summarize(text)
-    bot = QABot(text.split("\n\n"))
-    context = bot.retrieve_context(question)
-    return summary, context
-
-iface = gr.Interface(
-    fn=summarize_and_answer,
-    inputs=[
-        gr.File(label="Upload Biotech Research PDF"),
-        gr.Textbox(label="Ask a Question")
-    ],
-    outputs=[
-        gr.Textbox(label="Summary"),
-        gr.Textbox(label="Context")
-    ],
-    title="🧬 BioSummarize.ai",
-    description="Summarize biotech papers and ask questions using AI"
-)
+    text_chunks = text.split("\n\n")
+    qa_bot = QABot(text_chunks)
+    chat_history.clear()
+    return summary, "PDF processed. You can now ask questions."
+
+def chat_with_doc(question):
+    if not qa_bot:
+        return chat_history, "Please upload and summarize a document first."
+
+    context = qa_bot.retrieve_context(question)
+    response = ask_model(context, question)
+
+    chat_history.append((question, response))
+    suggestions = suggest_questions(summary)
+    suggestions_block = "💡 You can also ask:\n" + "\n".join([f"• {q}" for q in suggestions])
+
+    return chat_history, suggestions_block
+
+# UI layout
+with gr.Blocks(title="BioSummarize.ai") as iface:
+    gr.Markdown("# 🧬 BioSummarize.ai")
+    gr.Markdown("Upload a biotech research paper, generate its summary, and chat with it using an AI-powered assistant.")
+
+    with gr.Row():
+        file_input = gr.File(label="Upload Biotech Research PDF")
+        summarize_btn = gr.Button("Summarize + Start Chat")
+
+    summary_box = gr.Textbox(label="📘 Summary", lines=6)
+    summary_status = gr.Textbox(label="Status / Info", lines=2)
+
+    chat_input = gr.Textbox(label="💬 Ask a Question", placeholder="What is the main finding?")
+    chatbot = gr.Chatbot(label="🧠 BioResearch Chatbot")
+
+    suggestions_box = gr.Textbox(label="💡 Follow-up Suggestions", interactive=False)
+
+    # Bind actions
+    summarize_btn.click(fn=process_pdf, inputs=file_input, outputs=[summary_box, summary_status])
+    chat_input.submit(fn=chat_with_doc, inputs=chat_input, outputs=[chatbot, suggestions_box])
 
+# Launch the app
 if __name__ == "__main__":
     iface.launch()

chatbot.py

@@ -0,0 +1,12 @@
+import openai  # or use requests if OpenRouter API
+import os
+
+openai.api_key = os.getenv("OPENROUTER_API_KEY")
+
+def ask_model(context, query, model="mistral"):
+    prompt = f"""Context: {context}\n\nUser: {query}\nAI:"""
+    response = openai.ChatCompletion.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response['choices'][0]['message']['content']

qa_engine.py

@@ -4,13 +4,13 @@ import numpy as np
 
 class QABot:
     def __init__(self, chunks):
-        self.embedder = SentenceTransformer("pritamdeka/BioBERT-mnli-snli-scinli-scitail-mednli-stsb")
+        self.model = SentenceTransformer("pritamdeka/BioBERT-mnli-snli-scinli-scitail-mednli-stsb")
         self.chunks = chunks
-        self.index = faiss.IndexFlatL2(768)
-        self.embeddings = self.embedder.encode(chunks)
+        self.embeddings = self.model.encode(chunks)
+        self.index = faiss.IndexFlatL2(self.embeddings.shape[1])
         self.index.add(np.array(self.embeddings))
 
-    def retrieve_context(self, query, k=3):
-        q_embed = self.embedder.encode([query])
-        D, I = self.index.search(np.array(q_embed), k)
-        return "\n".join([self.chunks[i] for i in I[0]])
+    def retrieve(self, query, k=3):
+        query_vec = self.model.encode([query])
+        D, I = self.index.search(np.array(query_vec), k)
+        return "\n\n".join([self.chunks[i] for i in I[0]])

suggestions.py

@@ -0,0 +1,8 @@
+def suggest_questions(summary):
+    return [
+        "What is the objective of this research?",
+        "What methods were used in the study?",
+        "What are the key results?",
+        "What limitations or future work are mentioned?",
+        "What is the significance of this study?"
+    ]

summarizer.py

@@ -1,11 +1,27 @@
 from transformers import AutoTokenizer, BartForConditionalGeneration
+import torch
+import math
 
 class Summarizer:
     def __init__(self):
-        self.tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
-        self.model = BartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn")
+        self.tokenizer = AutoTokenizer.from_pretrained("sshleifer/distilbart-cnn-12-6")
+        self.model = BartForConditionalGeneration.from_pretrained("sshleifer/distilbart-cnn-12-6")
 
-    def summarize(self, text, max_tokens=200):
-        inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=1024)
-        summary_ids = self.model.generate(inputs["input_ids"], max_new_tokens=max_tokens)
-        return self.tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+    def split_text(self, text, max_tokens=1024):
+        words = text.split()
+        chunks = [' '.join(words[i:i+max_tokens]) for i in range(0, len(words), max_tokens)]
+        return chunks
+
+    def summarize(self, text):
+        chunks = self.split_text(text)
+        partial_summaries = []
+
+        for chunk in chunks:
+            inputs = self.tokenizer(chunk, return_tensors="pt", truncation=True, max_length=1024)
+            summary_ids = self.model.generate(inputs["input_ids"], max_new_tokens=200)
+            summary = self.tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+            partial_summaries.append(summary)
+
+        # Final merged summary
+        full_summary = " ".join(partial_summaries)
+        return full_summary