Upload 7 files

app.py

@@ -1,69 +1,97 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
-
-
-if __name__ == "__main__":
-    demo.launch()
+import gradio as gr
+from huggingface_hub import InferenceClient
+
+from loader import Loader
+from chunker import Chunker
+from embedder import Embedder
+from vector import VectorStorage
+from retriever import Retriever
+
+
+client = InferenceClient("meta-llama/Llama-3.2-3B-Instruct")
+
+def process_document(file):
+    """Systemic Entry Point: Converts PDF to Searchable Index"""
+    if file is None:
+        return None, None, "❌ Please upload a PDF first."
+    
+    
+    text = Loader(file.name).load()
+    chunks = Chunker().chunker(text)
+    
+    
+    embedder = Embedder()
+    vectors = embedder.embed(chunks)
+    
+    store = VectorStorage(dimension=len(vectors[0])) 
+    store.add(vectors, chunks)
+    
+    return store, embedder, "✅ PDF Indexed. Ready to chat!"
+
+def rag_chat(message, history, store, embedder):
+    """The Retrieval-Generation Loop"""
+    if store is None:
+        yield "Please upload and process a PDF on the left first."
+        return
+
+    
+    retriever = Retriever(store, embedder, k=3)
+    context_chunks = retriever.retrieve(message)
+    
+    
+    if not context_chunks:
+        yield "I couldn't find any relevant information in the document to answer that."
+        return
+
+    context_text = "\n\n".join(context_chunks)
+
+    
+    system_prompt = (
+        "You are a research assistant which gives answer to the questions of the user from the provided context only. Use the provided context to answer. "
+        "If the answer isn't there, say you don't know. Do not hallucinate."
+    )
+    
+
+    messages = [{"role": "system", "content": system_prompt}]
+    messages.extend(history)
+    messages.append({"role": "user", "content": f"Context:\n{context_text}\n\nQuestion: {message}"})
+
+    response = ""
+    for token in client.chat_completion(messages, max_tokens=512, stream=True):
+        token_text = token.choices[0].delta.content
+        if token_text:
+            response += token_text
+            yield response
+
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="slate")) as demo:
+    
+    store_state = gr.State()
+    embedder_state = gr.State()
+
+    gr.Markdown("# 📑 DocuMind AI")
+    
+    with gr.Row():
+        
+        with gr.Column(scale=1):
+            file_input = gr.File(label="Source Document", file_types=[".pdf"])
+            btn = gr.Button("Build Knowledge Base", variant="primary")
+            status = gr.Markdown("Status: Waiting for upload...")
+
+        
+        with gr.Column(scale=3):
+            gr.ChatInterface(
+                fn=rag_chat,
+                additional_inputs=[store_state, embedder_state],
+                type="messages", 
+                fill_height=True
+            )
+
+   
+    btn.click(
+        fn=process_document,
+        inputs=[file_input],
+        outputs=[store_state, embedder_state, status]
+    )
+
+demo.launch()

chunker.py

@@ -0,0 +1,31 @@
+class Chunker:
+    def __init__(self, chunk_size=500, overlap=100):
+        self.chunk_size = chunk_size
+        self.overlap = overlap
+
+    def chunker(self, text):
+        if self.overlap >= self.chunk_size:
+            raise ValueError("Overlap must be smaller than chunk size.")
+
+        chunks = []
+        start = 0
+        text_size = len(text)
+
+        while start < text_size:
+            end = start + self.chunk_size
+            
+            
+            if end < text_size:
+                last_space = text.rfind(' ', start, end)
+                if last_space != -1:
+                    end = last_space 
+            
+
+            chunk = text[start:end].strip()
+            if chunk:
+                chunks.append(chunk)
+            
+            
+            start = end - self.overlap
+            
+        return chunks

embedder.py

@@ -0,0 +1,19 @@
+from sentence_transformers import SentenceTransformer
+class Embedder:
+    """
+    converts the text into numbers 
+    and places them close meaningfully
+    """
+    def __init__(self):
+        self.model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+
+
+    def embed(self,chunk):
+        vectors = self.model.encode(chunk)
+        return vectors
+    
+    def embed_q(self,query):
+        q_vector = self.model.encode(query)
+        return q_vector
+
+

loader.py

@@ -0,0 +1,17 @@
+import PyPDF2
+
+
+class Loader:
+    """
+    loads the text from the pdf files
+    """
+    def __init__(self,file_path):
+        self.file = file_path
+
+    def load(self):
+        reader = PyPDF2.PdfReader(self.file)
+        text = ""
+
+        for page in reader.pages:
+            text = text + page.extract_text()
+        return text

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+huggingface_hub
+sentence-transformers
+faiss-cpu
+numpy
+PyPDF2>=3.0.0
+

retriever.py

@@ -0,0 +1,28 @@
+class Retriever:
+    def __init__(self, vector_store, embedder, k=5):
+        self.vector_store = vector_store
+        self.embedder = embedder
+        self.k = k
+
+    def retrieve(self, query):
+        
+        vquery = self.embedder.embed_q(query)
+        
+        
+        scores, indices = self.vector_store.search(vquery, self.k)
+
+        
+        if scores[0] < 0.5:
+            print(f"Evidence too low: {scores[0]}")
+            return []
+
+        
+        results = [
+            self.vector_store.chunks[i] 
+            for i in indices if i != -1
+        ]
+        return results
+
+
+
+

vector.py

@@ -0,0 +1,26 @@
+import faiss
+import numpy as np
+
+class VectorStorage:
+    def __init__(self, dimension=384): 
+    
+        self.index = faiss.IndexFlatIP(dimension)
+        self.chunks = []
+
+    def add(self, vectors, chunks):
+        
+        v_array = np.array(vectors).astype('float32')
+        
+        faiss.normalize_L2(v_array)
+        
+        self.index.add(v_array)
+        self.chunks.extend(chunks)
+
+    def search(self, query_vector, k=5):
+        
+        q_array = np.array([query_vector]).astype('float32')
+        faiss.normalize_L2(q_array)
+        
+        
+        scores, indices = self.index.search(q_array, k)
+        return scores[0], indices[0]