Update app.py

app.py

@@ -1,8 +1,8 @@
 import streamlit as st
-import tempfile
+import pandas as pd
 import os
 
-# LangChain imports (new structure)
+# LangChain
 from langchain_community.document_loaders import PyPDFLoader, TextLoader
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_community.embeddings import HuggingFaceEmbeddings
@@ -10,107 +10,199 @@ from langchain_community.vectorstores import FAISS
 from langchain_community.llms import HuggingFacePipeline
 from langchain.chains import RetrievalQA
 
+# Transformers
 from transformers import pipeline
 
+# Charts
+import plotly.express as px
 
 # -------------------------------
-# Load Documents (FIXED temp file handling)
+# PAGE CONFIG
 # -------------------------------
-def load_documents(uploaded_files):
-    documents = []
+st.set_page_config(page_title="RAG + Analytics", layout="wide")
+st.title("📄 RAG Chatbot + 📊 Analytics Dashboard")
 
-    for file in uploaded_files:
-        suffix = file.name.split(".")[-1]
+# -------------------------------
+# CACHE (VERY IMPORTANT ⚡)
+# -------------------------------
+@st.cache_resource
+def load_llm():
+    pipe = pipeline(
+        "text2text-generation",
+        model="google/flan-t5-base",
+        max_length=512
+    )
+    return HuggingFacePipeline(pipeline=pipe)
 
-        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{suffix}") as tmp:
-            tmp.write(file.getbuffer())
-            tmp_path = tmp.name
+@st.cache_resource
+def load_embeddings():
+    return HuggingFaceEmbeddings(
+        model_name="sentence-transformers/all-MiniLM-L6-v2"
+    )
 
-        if suffix == "pdf":
-            loader = PyPDFLoader(tmp_path)
-        else:
-            loader = TextLoader(tmp_path)
+# -------------------------------
+# LOAD DOCUMENTS
+# -------------------------------
+def load_documents(files):
+    docs = []
+    stats = []
 
-        documents.extend(loader.load())
+    for file in files:
+        path = os.path.join("temp", file.name)
+        os.makedirs("temp", exist_ok=True)
 
-        os.remove(tmp_path)  # cleanup
+        with open(path, "wb") as f:
+            f.write(file.getbuffer())
 
-    return documents
+        if file.name.endswith(".pdf"):
+            loader = PyPDFLoader(path)
+            ftype = "PDF"
+        else:
+            loader = TextLoader(path)
+            ftype = "TXT"
+
+        loaded = loader.load()
+        docs.extend(loaded)
 
+        stats.append({
+            "File": file.name,
+            "Type": ftype,
+            "Pages": len(loaded)
+        })
+
+    return docs, pd.DataFrame(stats)
 
 # -------------------------------
-# Split Documents
+# SPLIT DOCUMENTS
 # -------------------------------
-def split_documents(documents):
+def split_docs(docs):
     splitter = RecursiveCharacterTextSplitter(
         chunk_size=500,
         chunk_overlap=50
     )
-    return splitter.split_documents(documents)
-
+    return splitter.split_documents(docs)
 
 # -------------------------------
-# Create Vector Store
+# VECTOR STORE
 # -------------------------------
 def create_vectorstore(chunks):
-    embeddings = HuggingFaceEmbeddings(
-        model_name="sentence-transformers/all-MiniLM-L6-v2"
-    )
+    embeddings = load_embeddings()
     return FAISS.from_documents(chunks, embeddings)
 
-
 # -------------------------------
-# Load Local LLM (STABLE VERSION)
+# QA CHAIN
 # -------------------------------
-@st.cache_resource
-def load_llm():
-    pipe = pipeline(
-        task="text2text-generation",
-        model="google/flan-t5-base",
-        max_length=512,
-        do_sample=False
+def build_qa(vs):
+    llm = load_llm()
+    return RetrievalQA.from_chain_type(
+        llm=llm,
+        retriever=vs.as_retriever()
     )
-    return HuggingFacePipeline(pipeline=pipe)
 
+# -------------------------------
+# FILE UPLOAD
+# -------------------------------
+files = st.file_uploader(
+    "Upload PDF / TXT files",
+    accept_multiple_files=True
+)
 
 # -------------------------------
-# Build QA Chain
+# SESSION STATE
 # -------------------------------
-def build_qa(vectorstore):
-    llm = load_llm()
-    retriever = vectorstore.as_retriever()
+if "qa" not in st.session_state:
+    st.session_state.qa = None
 
-    qa = RetrievalQA.from_chain_type(
-        llm=llm,
-        retriever=retriever
+if "history" not in st.session_state:
+    st.session_state.history = []
+
+# -------------------------------
+# PROCESS FILES
+# -------------------------------
+if files and st.session_state.qa is None:
+    with st.spinner("Processing documents..."):
+        docs, df = load_documents(files)
+        chunks = split_docs(docs)
+        vs = create_vectorstore(chunks)
+        qa = build_qa(vs)
+
+        st.session_state.qa = qa
+        st.session_state.df = df
+        st.session_state.chunk_count = len(chunks)
+        st.session_state.doc_count = len(docs)
+
+    st.success("✅ Documents processed!")
+
+# -------------------------------
+# DASHBOARD
+# -------------------------------
+if st.session_state.qa:
+
+    st.subheader("📊 Analytics Dashboard")
+
+    df = st.session_state.df
+
+    col1, col2, col3 = st.columns(3)
+
+    col1.metric("📄 Total Documents", st.session_state.doc_count)
+    col2.metric("🧩 Total Chunks", st.session_state.chunk_count)
+    col3.metric("📁 Files Uploaded", len(df))
+
+    # ---- Bar Chart ----
+    fig1 = px.bar(
+        df,
+        x="File",
+        y="Pages",
+        color="Type",
+        title="Pages per File"
     )
-    return qa
+    st.plotly_chart(fig1, use_container_width=True)
 
+    # ---- Pie Chart ----
+    fig2 = px.pie(
+        df,
+        names="Type",
+        title="File Type Distribution"
+    )
+    st.plotly_chart(fig2, use_container_width=True)
+
+    # ---- Line Chart ----
+    growth_df = pd.DataFrame({
+        "Stage": ["Documents", "Chunks"],
+        "Count": [st.session_state.doc_count, st.session_state.chunk_count]
+    })
+
+    fig3 = px.line(
+        growth_df,
+        x="Stage",
+        y="Count",
+        markers=True,
+        title="Processing Growth"
+    )
+    st.plotly_chart(fig3, use_container_width=True)
 
 # -------------------------------
-# Streamlit UI
+# CHATBOT
 # -------------------------------
-st.set_page_config(page_title="RAG Chatbot", layout="wide")
-st.title("📄 Chat with Your Documents (RAG)")
+st.subheader("🤖 Chat with Documents")
 
-uploaded_files = st.file_uploader(
-    "Upload PDF or TXT files",
-    accept_multiple_files=True
-)
+query = st.text_input("Ask your question...")
 
-if uploaded_files:
-    with st.spinner("Processing documents..."):
-        docs = load_documents(uploaded_files)
-        chunks = split_documents(docs)
-        vectorstore = create_vectorstore(chunks)
-        qa_chain = build_qa(vectorstore)
+if query and st.session_state.qa:
+    with st.spinner("Thinking..."):
+        result = st.session_state.qa.invoke({"query": query})
+        answer = result["result"]
 
-    st.success("✅ Documents ready!")
+        # Save history
+        st.session_state.history.append((query, answer))
 
-    query = st.text_input("Ask a question from your documents")
+# -------------------------------
+# CHAT HISTORY
+# -------------------------------
+if st.session_state.history:
+    st.subheader("💬 Chat History")
 
-    if query:
-        with st.spinner("Generating answer..."):
-            result = qa_chain.invoke({"query": query})
-            st.write("### Answer:")
-            st.write(result["result"])
+    for q, a in reversed(st.session_state.history):
+        st.markdown(f"**🧑 Question:** {q}")
+        st.markdown(f"**🤖 Answer:** {a}")
+        st.markdown("---")