Upload 2 files

app.py

@@ -1,65 +1,148 @@
 import os
-from PyPDF2 import PdfReader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.vectorstores import FAISS
-from langchain.embeddings import SentenceTransformerEmbeddings
-from langchain.chains import RetrievalQA
-from langchain.chat_models import ChatOpenAI  # or HuggingFaceChatModel
+import faiss
+import numpy as np
 import gradio as gr
 
+from sentence_transformers import SentenceTransformer
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from PyPDF2 import PdfReader
+
+# -----------------------------
+# CONFIG
+# -----------------------------
+DATA_PATH = "Docs"
+TOP_K = 3
+
+# -----------------------------
+# EMBEDDING MODEL (LIGHT)
+# -----------------------------
+embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
+
 # -----------------------------
-# 1. Load PDF files
+# OPEN LLM (NO AUTH REQUIRED)
 # -----------------------------
-docs_path = "Docs"
-all_texts = []
+LLM_MODEL = "google/flan-t5-base"
+tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL)
+llm_model = AutoModelForSeq2SeqLM.from_pretrained(LLM_MODEL)
 
-for file in os.listdir(docs_path):
-    if file.endswith(".pdf"):
-        pdf = PdfReader(os.path.join(docs_path, file))
+# -----------------------------
+# FILE LOADER
+# -----------------------------
+def read_file(path):
+    if path.endswith(".txt") or path.endswith(".md"):
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    elif path.endswith(".pdf"):
+        reader = PdfReader(path)
         text = ""
-        for page in pdf.pages:
+        for page in reader.pages:
             text += page.extract_text() or ""
-        all_texts.append(text)
+        return text
+    return ""
 
-full_text = "\n".join(all_texts)
+def load_docs(folder):
+    texts = []
+    for file in os.listdir(folder):
+        path = os.path.join(folder, file)
+        try:
+            txt = read_file(path)
+            if txt.strip():
+                texts.append(txt)
+        except:
+            continue
+    return texts
 
 # -----------------------------
-# 2. Split text into chunks
+# CHUNKING
 # -----------------------------
-text_splitter = RecursiveCharacterTextSplitter(
-    chunk_size=1000,
-    chunk_overlap=200
-)
-texts = text_splitter.split_text(full_text)
+def chunk_text(text, size=300, overlap=50):
+    words = text.split()
+    chunks = []
+    for i in range(0, len(words), size - overlap):
+        chunks.append(" ".join(words[i:i + size]))
+    return chunks
 
 # -----------------------------
-# 3. Create embeddings and vector store
+# BUILD VECTOR DB
 # -----------------------------
-embedding_model = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")
-vectorstore = FAISS.from_texts(texts, embedding_model)
+def build_index(docs):
+    chunks = []
+    for doc in docs:
+        chunks.extend(chunk_text(doc))
+
+    if not chunks:
+        return None, []
+
+    embeddings = embedding_model.encode(chunks)
+    dim = embeddings.shape[1]
+
+    index = faiss.IndexFlatL2(dim)
+    index.add(np.array(embeddings))
+
+    return index, chunks
 
 # -----------------------------
-# 4. Create retrieval QA chain
+# RETRIEVE
 # -----------------------------
-llm = ChatOpenAI(temperature=0)  # or use HuggingFace model if you prefer
-qa = RetrievalQA.from_chain_type(
-    llm=llm,
-    retriever=vectorstore.as_retriever(),
-    chain_type="stuff"  # simple summarization chain
-)
+def retrieve(query, index, chunks, k=TOP_K):
+    q_embed = embedding_model.encode([query])
+    D, I = index.search(np.array(q_embed), k)
+    return [chunks[i] for i in I[0]]
 
 # -----------------------------
-# 5. Gradio interface
+# GENERATE ANSWER
 # -----------------------------
-def answer_question(query):
-    return qa.run(query)
+def generate_answer(query, contexts):
+    context = "\n\n".join(contexts)
+
+    prompt = f"""
+Answer the question based ONLY on the context.
+If not found, say: Not in knowledge base.
+
+Context:
+{context}
+
+Question:
+{query}
+"""
 
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True)
+    outputs = llm_model.generate(**inputs, max_new_tokens=200)
+
+    return tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+# -----------------------------
+# INIT
+# -----------------------------
+docs = load_docs(DATA_PATH)
+index, chunks = build_index(docs)
+
+# -----------------------------
+# RAG PIPELINE
+# -----------------------------
+def rag(query):
+    if index is None:
+        return "No documents found", ""
+
+    retrieved = retrieve(query, index, chunks)
+    answer = generate_answer(query, retrieved)
+
+    return answer, "\n\n---\n\n".join(retrieved)
+
+# -----------------------------
+# UI
+# -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# PDF RAG + Summarization Chatbot")
-    with gr.Row():
-        query_input = gr.Textbox(label="Ask a question about your PDFs")
-        output_box = gr.Textbox(label="Answer")
-    query_input.submit(answer_question, inputs=query_input, outputs=output_box)
-    gr.Button("Submit").click(answer_question, inputs=query_input, outputs=output_box)
-
-demo.launch(server_name="0.0.0.0", server_port=7860)
+    gr.Markdown("## AI/ML Knowledge RAG (Stable Version)")
+
+    q = gr.Textbox(placeholder="Ask about AI tools, companies, ML...")
+    ans = gr.Textbox(label="Answer")
+    ctx = gr.Textbox(label="Context")
+
+    gr.Button("Ask").click(rag, inputs=q, outputs=[ans, ctx])
+
+# -----------------------------
+# RUN
+# -----------------------------
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -1,7 +1,7 @@
-langchain==0.1.232
-gradio==6.10.0
-PyPDF2==3.0.1
-faiss-cpu==1.7.4
-sentence-transformers==2.2.2
-huggingface-hub==0.30.0
-transformers==4.33.2
+gradio
+faiss-cpu
+sentence-transformers
+transformers
+torch
+PyPDF2
+numpy