Update app.py

app.py

@@ -1,157 +1,87 @@
-# app.py
-
 import streamlit as st
-import arxiv
-import networkx as nx
-import matplotlib.pyplot as plt
-import datetime
-
-from transformers import pipeline
-
-# Initialize Hugging Face pipelines for summarization and text generation
-@st.cache_resource(show_spinner=False)
-def load_summarizer():
-    return pipeline("summarization", model="facebook/bart-large-cnn")
-
-@st.cache_resource(show_spinner=False)
-def load_generator():
-    return pipeline("text-generation", model="gpt2")
-
-summarizer = load_summarizer()
-generator = load_generator()
-
-# -------------------------------
-# Helper Functions
-# -------------------------------
-
-def retrieve_papers(query, max_results=5):
-    """
-    Retrieve academic papers from arXiv based on the query.
-    """
-    search = arxiv.Search(query=query, max_results=max_results)
-    papers = []
-    for result in search.results():
-        paper = {
-            "title": result.title,
-            "summary": result.summary,
-            "url": result.pdf_url,
-            "authors": [author.name for author in result.authors],
-            "published": result.published
-        }
-        papers.append(paper)
-    return papers
-
-def summarize_text(text):
-    """
-    Use a generative model to create a concise summary of the input text.
-    """
-    # The summarizer may need the text to be below a certain token length.
-    # If necessary, you could chunk the text.
-    summarized = summarizer(text, max_length=130, min_length=30, do_sample=False)
-    return summarized[0]['summary_text']
-
-def generate_concept_map(papers):
-    """
-    Generate a visual concept map by connecting papers with shared authors.
-    """
-    G = nx.Graph()
-    # Add nodes for each paper title
-    for paper in papers:
-        G.add_node(paper['title'])
-    # Create edges between papers that share at least one common author
-    for i in range(len(papers)):
-        for j in range(i + 1, len(papers)):
-            common_authors = set(papers[i]['authors']).intersection(set(papers[j]['authors']))
-            if common_authors:
-                G.add_edge(papers[i]['title'], papers[j]['title'])
-    return G
-
-def generate_citation(paper):
-    """
-    Format citation information in APA style.
-    """
-    authors = ", ".join(paper['authors'])
-    year = paper['published'].year if isinstance(paper['published'], datetime.datetime) else "n.d."
-    title = paper['title']
-    url = paper['url']
-    citation = f"{authors} ({year}). {title}. Retrieved from {url}"
-    return citation
-
-def generate_proposal_suggestions(text):
-    """
-    Generate research proposal suggestions based on the synthesized literature review.
-    """
-    prompt = (
-        "Based on the following literature review, propose a novel research proposal "
-        "including potential research questions and an outline for experimental design.\n\n"
-        f"{text}\n\nProposal:"
-    )
-    generated = generator(prompt, max_new_tokens=50, num_return_sequences=1)
-    return generated[0]['generated_text']
-
-# -------------------------------
-# Streamlit User Interface
-# -------------------------------
-
-st.title("📚PaperPilot – The Intelligent Academic Navigator")
-st.markdown("Welcome to **PaperPilot**! Enter a research topic or question below to retrieve academic papers, generate summaries, visualize concept maps, format citations, and get research proposal suggestions.")
-
-# Input section
-query = st.text_input("Research Topic or Question:")
-
-if st.button("Search"):
-
-    if query.strip() == "":
-        st.warning("Please enter a research topic or question.")
-    else:
-        # --- Step 1: Retrieve Papers ---
-        with st.spinner("Retrieving relevant academic papers..."):
-            papers = retrieve_papers(query, max_results=5)
-        
-        if not papers:
-            st.error("No papers found. Please try a different query.")
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import faiss
+import numpy as np
+from sentence_transformers import SentenceTransformer
+import PyPDF2
+import os
+
+# Model Setup
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model_path = "ibm-granite/granite-3.1-1b-a400m-instruct"
+
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map="auto")
+model.eval()
+
+# Embedding Model for FAISS
+embedding_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+
+# FAISS Index
+dimension = 384  # Embedding size for MiniLM
+index = faiss.IndexFlatL2(dimension)
+docs = []  # Store document texts
+
+# Function to extract text from PDF
+def extract_text_from_pdf(uploaded_file):
+    reader = PyPDF2.PdfReader(uploaded_file)
+    text = "\n".join([page.extract_text() for page in reader.pages if page.extract_text()])
+    return text
+
+# Function to process uploaded documents
+def process_documents(files):
+    global docs, index
+    docs = []
+    
+    for file in files:
+        if file.type == "application/pdf":
+            text = extract_text_from_pdf(file)
         else:
-            st.success(f"Found {len(papers)} papers.")
-
-            # --- Step 2: Display Retrieved Papers ---
-            st.header("Retrieved Papers")
-            for idx, paper in enumerate(papers, start=1):
-                with st.expander(f"{idx}. {paper['title']}"):
-                    st.markdown(f"**Authors:** {', '.join(paper['authors'])}")
-                    st.markdown(f"**Published:** {paper['published'].strftime('%Y-%m-%d') if isinstance(paper['published'], datetime.datetime) else 'n.d.'}")
-                    st.markdown(f"**Link:** [PDF Link]({paper['url']})")
-                    st.markdown("**Abstract:**")
-                    st.write(paper['summary'])
-
-            # --- Step 3: Generate Summaries & Literature Review ---
-            st.header("Automated Summaries & Literature Review")
-            combined_summary = ""
-            for paper in papers:
-                st.subheader(f"Summary for: {paper['title']}")
-                # Use the paper summary as input for further summarization
-                summary_text = summarize_text(paper['summary'])
-                st.write(summary_text)
-                combined_summary += summary_text + " "
-
-            # --- Step 4: Create Visual Concept Map & Gap Analysis ---
-            st.header("Visual Concept Map & Gap Analysis")
-            G = generate_concept_map(papers)
-            if len(G.nodes) > 0:
-                fig, ax = plt.subplots(figsize=(8, 6))
-                pos = nx.spring_layout(G, seed=42)
-                nx.draw_networkx(G, pos, with_labels=True, node_color='skyblue', edge_color='gray', node_size=1500, font_size=8, ax=ax)
-                st.pyplot(fig)
-            else:
-                st.info("Not enough data to generate a concept map.")
-
-            # --- Step 5: Citation & Reference Management ---
-            st.header("Formatted Citations (APA Style)")
-            for paper in papers:
-                citation = generate_citation(paper)
-                st.markdown(f"- {citation}")
-
-            # --- Step 6: Research Proposal Assistance ---
-            st.header("Research Proposal Suggestions")
-            proposal = generate_proposal_suggestions(combined_summary)
-            st.write(proposal)
-st.caption("Built with ❤️")
+            text = file.getvalue().decode("utf-8")
+
+        docs.append(text)
+    
+    embeddings = embedding_model.encode(docs)
+    index.add(np.array(embeddings))
+
+# Function to retrieve relevant context
+def retrieve_context(query):
+    query_embedding = embedding_model.encode([query])
+    distances, indices = index.search(np.array(query_embedding), k=1)
+    
+    if len(indices) > 0 and indices[0][0] < len(docs):
+        return docs[indices[0][0]]
+    return "No relevant context found."
+
+# Function to generate response using IBM Granite
+def generate_response(query, context):
+    chat = [
+        {"role": "system", "content": "You are a helpful assistant using retrieved knowledge."},
+        {"role": "user", "content": f"Context: {context}\nQuestion: {query}\nAnswer based on context:"},
+    ]
+    chat = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
+
+    input_tokens = tokenizer(chat, return_tensors="pt").to(device)
+    output = model.generate(**input_tokens, max_new_tokens=200)
+    return tokenizer.batch_decode(output, skip_special_tokens=True)[0]
+
+# Streamlit UI
+st.set_page_config(page_title="📖 RAG-Based AI", page_icon="🤖")
+st.title("📖 RAG-based Q&A using IBM Granite")
+st.subheader("Upload documents and ask questions!")
+
+uploaded_files = st.file_uploader("Upload PDFs or TXT files", accept_multiple_files=True)
+
+if uploaded_files:
+    with st.spinner("Processing documents..."):
+        process_documents(uploaded_files)
+    st.success("Documents uploaded and indexed!")
+
+query = st.text_input("Ask a question:")
+if st.button("Get Answer"):
+    with st.spinner("Retrieving and generating response..."):
+        context = retrieve_context(query)
+        response = generate_response(query, context)
+        st.markdown("### 🤖 Answer:")
+        st.write(response)