added app files

README_HF.md

@@ -0,0 +1,35 @@
+# RAG PDF Chat Application
+
+A powerful Retrieval-Augmented Generation (RAG) application that allows you to upload PDF documents and ask questions about their content using AI.
+
+## Features
+
+- **PDF Upload**: Upload PDF documents and automatically process them into searchable chunks
+- **AI-Powered Q&A**: Ask questions about your uploaded PDFs and get intelligent answers
+- **Vector Search**: Uses advanced embedding technology to find relevant information
+- **Source Tracking**: See which parts of your documents contributed to each answer
+
+## How to Use
+
+1. **Upload a PDF**: Go to the "Upload PDF" tab and select a PDF file from your computer
+2. **Wait for Processing**: The app will automatically chunk and embed your document
+3. **Ask Questions**: Switch to the "Ask Questions" tab and enter your questions
+4. **Get Answers**: Receive AI-generated answers based on your document content
+
+## Technical Details
+
+- **Vector Database**: Uses Qdrant for efficient similarity search
+- **Embeddings**: OpenAI's text-embedding-3-large model for document chunking
+- **Language Model**: GPT-4 for generating intelligent answers
+- **Framework**: Built with Gradio for easy deployment
+
+## Environment Variables
+
+Make sure to set your OpenAI API key:
+```
+OPENAI_API_KEY=your_openai_api_key_here
+```
+
+## Deployment
+
+This app is designed to run on Hugging Face Spaces. Simply push this repository to a Hugging Face Space and it will automatically deploy.

app.py

@@ -1,7 +1,5 @@
-import gradio as gr
+# Import the main Gradio app
+from gradio_app import demo
 
-def greet(name):
-    return f"Hello, {name}!"
-
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()

custom_types.py

@@ -0,0 +1,21 @@
+import pydantic
+
+
+class RAGChunkAndSrc(pydantic.BaseModel):
+    chunks: list[str]
+    source_id: str = None
+
+
+class RAGUpsertResult(pydantic.BaseModel):
+    ingested: int
+
+
+class RAGSearchResult(pydantic.BaseModel):
+    contexts: list[str]
+    sources: list[str]
+
+
+class RAQQueryResult(pydantic.BaseModel):
+    answer: str
+    sources: list[str]
+    num_contexts: int

data_loader.py

@@ -0,0 +1,36 @@
+from openai import OpenAI
+from llama_index.readers.file import PDFReader
+from llama_index.core.node_parser import SentenceSplitter
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = OpenAI()
+EMBED_MODEL = "text-embedding-3-large"
+EMBED_DIM = 3072
+
+splitter = SentenceSplitter(chunk_size=1000, chunk_overlap=200)
+
+def load_and_chunk_pdf(path: str):
+    docs = PDFReader().load_data(file=path)
+    texts = [d.text for d in docs if getattr(d, "text", None)]
+    chunks = []
+    for t in texts:
+        new_chunks = splitter.split_text(t)
+        # Filter out empty chunks
+        chunks.extend([chunk for chunk in new_chunks if chunk.strip()])
+    return chunks
+
+
+def embed_texts(texts: list[str]) -> list[list[float]]:
+    # Double-check that we don't have empty texts
+    texts = [text for text in texts if text and text.strip()]
+    
+    if not texts:
+        return []
+    
+    response = client.embeddings.create(
+        model=EMBED_MODEL,
+        input=texts,
+    )
+    return [item.embedding for item in response.data]

gradio_app.py

@@ -0,0 +1,254 @@
+import gradio as gr
+import asyncio
+import threading
+import time
+from pathlib import Path
+import uuid
+import os
+from dotenv import load_dotenv
+
+# Import your existing modules
+from data_loader import load_and_chunk_pdf, embed_texts
+from vector_db import QdrantStorage
+from custom_types import RAGSearchResult
+from openai import OpenAI
+
+load_dotenv()
+
+# Initialize OpenAI client
+openai_client = OpenAI()
+
+class RAGProcessor:
+    def __init__(self):
+        self.vector_store = QdrantStorage()
+        self.uploads_dir = Path("uploads")
+        self.uploads_dir.mkdir(parents=True, exist_ok=True)
+    
+    def save_uploaded_pdf(self, file) -> Path:
+        """Save uploaded PDF file with unique name"""
+        unique_id = str(uuid.uuid4())[:8]
+        file_stem = Path(file.name).stem
+        file_suffix = Path(file.name).suffix
+        unique_filename = f"{file_stem}_{unique_id}{file_suffix}"
+        
+        file_path = self.uploads_dir / unique_filename
+        file_bytes = file.getbuffer()
+        file_path.write_bytes(file_bytes)
+        return file_path
+    
+    def ingest_pdf(self, pdf_path: Path) -> str:
+        """Process and ingest PDF into vector database"""
+        try:
+            # Load and chunk the PDF
+            chunks = load_and_chunk_pdf(str(pdf_path))
+            
+            # Generate embeddings
+            embeddings = embed_texts(chunks)
+            
+            # Generate unique IDs
+            source_id = pdf_path.stem
+            ids = [str(uuid.uuid5(uuid.NAMESPACE_URL, f"{source_id}:{i}")) for i in range(len(chunks))]
+            
+            # Create payloads
+            payloads = [{"source": source_id, "text": chunks[i]} for i in range(len(chunks))]
+            
+            # Upsert to vector database
+            self.vector_store.upsert(ids, embeddings, payloads)
+            
+            return f"Successfully ingested {len(chunks)} chunks from {pdf_path.name}"
+        
+        except Exception as e:
+            return f"Error ingesting PDF: {str(e)}"
+    
+    def query_pdf(self, question: str, top_k: int = 5, source_filter: str = None) -> dict:
+        """Query the vector database and generate answer"""
+        try:
+            # Generate query embedding
+            query_embedding = embed_texts([question])[0]
+            
+            # Search vector database
+            search_results = self.vector_store.search(query_embedding, top_k, source_filter)
+            
+            if not search_results["contexts"]:
+                return {
+                    "answer": "No relevant information found in the uploaded PDFs.",
+                    "sources": [],
+                    "contexts": []
+                }
+            
+            # Create context for LLM
+            context_block = "\n\n".join(f"- {c}" for c in search_results["contexts"])
+            user_content = (
+                "Use the following context to answer the question.\n\n"
+                f"Context:\n{context_block}\n\n"
+                f"Question: {question}\n"
+                "Answer concisely using the context above."
+            )
+            
+            # Generate answer using OpenAI
+            response = openai_client.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": "You answer questions using only the provided context."},
+                    {"role": "user", "content": user_content}
+                ],
+                max_tokens=1024,
+                temperature=0.2
+            )
+            
+            answer = response.choices[0].message.content.strip()
+            
+            return {
+                "answer": answer,
+                "sources": search_results["sources"],
+                "contexts": search_results["contexts"]
+            }
+        
+        except Exception as e:
+            return {
+                "answer": f"Error processing query: {str(e)}",
+                "sources": [],
+                "contexts": []
+            }
+    
+    def get_most_recent_pdf(self) -> str:
+        """Get the most recently uploaded PDF filename"""
+        if not self.uploads_dir.exists():
+            return None
+        
+        pdf_files = list(self.uploads_dir.glob("*.pdf"))
+        if not pdf_files:
+            return None
+        
+        most_recent = max(pdf_files, key=lambda p: p.stat().st_mtime)
+        return most_recent.stem
+
+# Initialize the RAG processor
+rag_processor = RAGProcessor()
+
+def upload_and_ingest_pdf(file):
+    """Handle PDF upload and ingestion"""
+    if file is None:
+        return "Please upload a PDF file."
+    
+    # Save the uploaded file
+    pdf_path = rag_processor.save_uploaded_pdf(file)
+    
+    # Ingest the PDF
+    result = rag_processor.ingest_pdf(pdf_path)
+    
+    return result
+
+def ask_question(question, top_k, use_recent_pdf):
+    """Handle question asking"""
+    if not question.strip():
+        return "Please enter a question.", []
+    
+    # Determine source filter
+    source_filter = None
+    if use_recent_pdf:
+        recent_pdf = rag_processor.get_most_recent_pdf()
+        if recent_pdf:
+            source_filter = recent_pdf
+        else:
+            return "No recent PDF found. Please upload a PDF first.", []
+    
+    # Query the system
+    result = rag_processor.query_pdf(question, int(top_k), source_filter)
+    
+    # Format sources for display
+    sources_text = "\n".join([f"• {source}" for source in result["sources"]]) if result["sources"] else "No sources found"
+    
+    return result["answer"], sources_text
+
+# Create Gradio interface
+with gr.Blocks(title="RAG PDF Chat", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 📄 RAG PDF Chat Application")
+    gr.Markdown("Upload PDFs and ask questions about their content using AI-powered retrieval.")
+    
+    with gr.Tab("Upload PDF"):
+        gr.Markdown("### Upload a PDF Document")
+        pdf_upload = gr.File(
+            label="Choose a PDF file",
+            file_types=[".pdf"],
+            file_count="single"
+        )
+        upload_btn = gr.Button("Upload & Process PDF", variant="primary")
+        upload_status = gr.Textbox(
+            label="Upload Status",
+            interactive=False,
+            lines=2
+        )
+        
+        upload_btn.click(
+            fn=upload_and_ingest_pdf,
+            inputs=[pdf_upload],
+            outputs=[upload_status]
+        )
+    
+    with gr.Tab("Ask Questions"):
+        gr.Markdown("### Ask Questions About Your PDFs")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                question_input = gr.Textbox(
+                    label="Your Question",
+                    placeholder="What is the main topic of the document?",
+                    lines=3
+                )
+                
+                with gr.Row():
+                    top_k_slider = gr.Slider(
+                        minimum=1,
+                        maximum=20,
+                        value=5,
+                        step=1,
+                        label="Number of chunks to retrieve"
+                    )
+                    use_recent_checkbox = gr.Checkbox(
+                        label="Search only in most recent PDF",
+                        value=True
+                    )
+                
+                ask_btn = gr.Button("Ask Question", variant="primary")
+            
+            with gr.Column(scale=2):
+                recent_pdf_info = gr.Markdown("")
+        
+        with gr.Row():
+            with gr.Column():
+                answer_output = gr.Textbox(
+                    label="Answer",
+                    interactive=False,
+                    lines=8
+                )
+            
+            with gr.Column():
+                sources_output = gr.Textbox(
+                    label="Sources",
+                    interactive=False,
+                    lines=8
+                )
+        
+        # Update recent PDF info
+        def update_recent_pdf_info():
+            recent_pdf = rag_processor.get_most_recent_pdf()
+            if recent_pdf:
+                return f"🔍 **Most recent PDF:** {recent_pdf}"
+            else:
+                return "⚠️ **No PDFs uploaded yet.**"
+        
+        # Update the recent PDF info when the demo loads
+        demo.load(
+            fn=update_recent_pdf_info,
+            outputs=[recent_pdf_info]
+        )
+        
+        ask_btn.click(
+            fn=ask_question,
+            inputs=[question_input, top_k_slider, use_recent_checkbox],
+            outputs=[answer_output, sources_output]
+        )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,8 @@
+gradio>=4.0.0
+fastapi>=0.116.1
+llama-index-core>=0.14.0
+llama-index-readers-file>=0.5.4
+openai>=1.107.0
+python-dotenv>=1.1.1
+qdrant-client>=1.15.1
+uvicorn>=0.35.0

vector_db.py

@@ -0,0 +1,59 @@
+from qdrant_client import QdrantClient
+from qdrant_client.models import VectorParams, Distance, PointStruct
+
+
+class QdrantStorage:
+    def __init__(self, path="./qdrant_storage", collection="docs", dim=3072):
+        # Use local mode - this will use your existing data
+        self.client = QdrantClient(path=path)
+        self.collection = collection
+        if not self.client.collection_exists(self.collection):
+            self.client.create_collection(
+                collection_name=self.collection,
+                vectors_config=VectorParams(size=dim, distance=Distance.COSINE),
+            )
+
+    def upsert(self, ids, vectors, payloads):
+        points = [PointStruct(id=ids[i], vector=vectors[i], payload=payloads[i]) for i in range(len(ids))]
+        self.client.upsert(self.collection, points=points)
+
+    def search(self, query_vector, top_k: int = 5, source_filter: str = None):
+        from qdrant_client.models import Filter, FieldCondition, MatchValue
+        
+        # If source_filter is provided, only search within that source
+        if source_filter:
+            results = self.client.search(
+                collection_name=self.collection,
+                query_vector=query_vector,
+                query_filter=Filter(
+                    must=[
+                        FieldCondition(
+                            key="source",
+                            match=MatchValue(value=source_filter)
+                        )
+                    ]
+                ),
+                with_payload=True,
+                limit=top_k
+            )
+        else:
+            # Search across all sources
+            results = self.client.search(
+                collection_name=self.collection,
+                query_vector=query_vector,
+                with_payload=True,
+                limit=top_k
+            )
+        
+        contexts = []
+        sources = set()
+
+        for r in results:
+            payload = getattr(r, "payload", None) or {}
+            text = payload.get("text", "")
+            source = payload.get("source", "")
+            if text:
+                contexts.append(text)
+                sources.add(source)
+
+        return {"contexts": contexts, "sources": list(sources)}