Upload 6 files

Dockerfile

@@ -1,20 +1,32 @@
-FROM python:3.13.5-slim
+# 1. Base Image
+FROM python:3.11-slim
 
+# 2. Set Working Directory
 WORKDIR /app
 
+# 3. Install System Dependencies
+# ADDED: libgl1 and libglib2.0-0 (Fixes ImportError: libGL.so.1)
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
-    git \
+    poppler-utils \
+    tesseract-ocr \
+    libmagic1 \
+    libgl1 \
+    libglib2.0-0 \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# 4. Copy Requirements
+COPY requirements.txt .
 
-RUN pip3 install -r requirements.txt
+# 5. Install Python Dependencies
+RUN pip install --no-cache-dir -r requirements.txt
 
-EXPOSE 8501
+# 6. Copy Application Code
+COPY . .
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# 7. Expose Port
+EXPOSE 8501
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# 8. Run
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,160 @@
+import streamlit as st
+import uuid
+import os
+import base64
+from langchain_community.retrievers import BM25Retriever
+from langchain_core.messages import HumanMessage, AIMessage
+
+from data_processing import process_and_ingest, SessionDocStore, cleanup_session_index
+from rag_engine import run_advanced_rag
+
+# ──────────────────────────────────────────────────────────────────
+# 1. PAGE CONFIG & STATE INITIALIZATION
+# ──────────────────────────────────────────────────────────────────
+
+st.set_page_config(
+    page_title="Deep RAG Analyzer",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Initialize Session State
+if "session_id" not in st.session_state:
+    st.session_state.session_id = str(uuid.uuid4())
+
+if "doc_store" not in st.session_state:
+    st.session_state.doc_store = SessionDocStore()
+
+if "messages" not in st.session_state:
+    st.session_state.messages = [] # Format: {"role": "user/assistant", "content": "text", "images": []}
+
+if "bm25" not in st.session_state:
+    st.session_state.bm25 = None
+
+if "processed_file" not in st.session_state:
+    st.session_state.processed_file = None
+    
+if "uploader_key" not in st.session_state:
+    st.session_state.uploader_key = str(uuid.uuid4())
+
+# ──────────────────────────────────────────────────────────────────
+# 2. SIDEBAR (Upload & Reset)
+# ──────────────────────────────────────────────────────────────────
+
+with st.sidebar:
+    st.title("📁 Document Upload")
+    uploaded_file = st.file_uploader("Upload PDF", type=["pdf"],key=st.session_state.uploader_key)
+    
+    if uploaded_file and uploaded_file.name != st.session_state.processed_file:
+        with st.spinner("Partitioning & Embedding (This may take a moment)..."):
+            # Save to temp file for processing
+            temp_path = f"temp_{uploaded_file.name}"
+            with open(temp_path, "wb") as f:
+                f.write(uploaded_file.getbuffer())
+                
+            try:
+                # Run Pipeline
+                documents = process_and_ingest(
+                    temp_path, 
+                    st.session_state.session_id, 
+                    st.session_state.doc_store
+                )
+                
+                # Setup Retriever
+                bm25 = BM25Retriever.from_documents(documents)
+                bm25.k = 3
+                st.session_state.bm25 = bm25
+                st.session_state.processed_file = uploaded_file.name
+                
+                st.success(f"Processed {len(documents)} chunks!")
+            except Exception as e:
+                st.error(f"Error: {e}")
+            finally:
+                # Cleanup temp file
+                if os.path.exists(temp_path):
+                    os.remove(temp_path)
+
+    st.markdown("---")
+    if st.button("🗑️ Clear Chat & Reset"):
+        # Cleanup Pinecone
+        cleanup_session_index(st.session_state.session_id)
+        # Reset State
+        st.session_state.session_id = str(uuid.uuid4())
+        st.session_state.doc_store = SessionDocStore()
+        st.session_state.messages = []
+        st.session_state.bm25 = None
+        st.session_state.processed_file = None
+        st.session_state.uploader_key = str(uuid.uuid4())
+        st.rerun()
+
+# ──────────────────────────────────────────────────────────────────
+# 3. CHAT INTERFACE
+# ──────────────────────────────────────────────────────────────────
+
+st.title("🤖 Advanced Multimodal RAG (with chat history and visuals)")
+st.caption("Using GPT-4.1, Pinecone, RRF and Re-ranking (Do not upload extremly large PDFs!)")
+
+# Display History
+for msg in st.session_state.messages:
+    with st.chat_message(msg["role"]):
+        st.markdown(msg["content"])
+        if "images" in msg and msg["images"]:
+            # Display images in a row
+            cols = st.columns(len(msg["images"]))
+            for idx, img_b64 in enumerate(msg["images"]):
+                with cols[idx]:
+                    if "," in img_b64: img_b64 = img_b64.split(",")[1]
+                    st.image(base64.b64decode(img_b64), use_container_width=True)
+
+# Chat Input
+if prompt := st.chat_input("Ask about your document..."):
+    
+    if not st.session_state.bm25:
+        st.error("Please upload and process a PDF first!")
+        st.stop()
+
+    # 1. Display User Message
+    st.chat_message("user").markdown(prompt)
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    
+    # 2. Prepare History for RAG
+    lc_history = []
+    for m in st.session_state.messages:
+        if m["role"] == "user":
+            lc_history.append(HumanMessage(content=m["content"]))
+        else:
+            lc_history.append(AIMessage(content=m["content"]))
+
+    # 3. Generate Response
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking (retrieving the context)..."):
+            try:
+                answer, images = run_advanced_rag(
+                    prompt,
+                    st.session_state.session_id,
+                    st.session_state.bm25,
+                    st.session_state.doc_store,
+                    lc_history
+                )
+                
+                st.markdown(answer)
+                
+                # Display Images if found
+                if images:
+                    st.write("---")
+                    st.caption("📸 Retrieved Visual Context:")
+                    cols = st.columns(min(3, len(images)))
+                    for idx, img_b64 in enumerate(images[:3]):
+                        with cols[idx]:
+                            if "," in img_b64: img_b64 = img_b64.split(",")[1]
+                            st.image(base64.b64decode(img_b64), use_container_width=True)
+                
+                # Save to history
+                st.session_state.messages.append({
+                    "role": "assistant", 
+                    "content": answer, 
+                    "images": images[:3] if images else []
+                })
+                
+            except Exception as e:
+                st.error(f"Error generating response: {e}")

config.py

@@ -0,0 +1,33 @@
+import os
+from dotenv import load_dotenv
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_openai import AzureChatOpenAI
+
+load_dotenv()
+
+# 1. API KEYS & CONFIG
+# ⚠️ Ensure these are set in your Hugging Face Space "Secrets" setting
+PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
+INDEX_NAME = "gradio-db"  # 768 dimensions
+
+AZURE_OPENAI_API_KEY = os.getenv("AZURE_OPENAI_API_KEY")
+AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
+AZURE_OPENAI_API_VERSION = "2025-01-01-preview" # Updated to stable preview
+AZURE_DEPLOYMENT_NAME = "gpt-4.1" 
+
+# 2. MODEL INITIALIZATION
+
+def get_llm(temperature=0.25):
+    
+    return AzureChatOpenAI(
+        azure_deployment=AZURE_DEPLOYMENT_NAME,
+        api_version=AZURE_OPENAI_API_VERSION,
+        temperature=temperature,
+        max_tokens=1024,
+        streaming=True
+    )
+
+def get_embeddings():
+    # IntFloat E5-Base v2 (768 dim)
+    return HuggingFaceEmbeddings(model_name="intfloat/e5-base-v2")
+

data_processing.py

@@ -0,0 +1,117 @@
+import os
+import uuid
+import json
+from typing import List, Dict
+from unstructured.partition.pdf import partition_pdf
+from unstructured.chunking.title import chunk_by_title
+from langchain_core.documents import Document
+from langchain_pinecone import PineconeVectorStore
+from langchain_core.messages import HumanMessage
+from pinecone import Pinecone, ServerlessSpec
+
+from config import *
+
+# Initialize Pinecone Client
+pc = Pinecone(api_key=PINECONE_API_KEY)
+
+class SessionDocStore:
+    """
+    In-memory storage for heavy content (Images/Tables) tied to a session.
+    In a real production app, use Redis/Postgres. 
+    """
+    def __init__(self):
+        self.store = {}
+
+    def save_chunk(self, doc_id: str, data: Dict):
+        self.store[doc_id] = data
+
+    def get_chunk(self, doc_id: str):
+        return self.store.get(doc_id, {})
+    
+    def clear(self):
+        self.store = {}
+
+# Helper to summarize visual content for embeddings
+def create_multimodal_summary(text, tables, images):
+    llm = get_llm()
+    prompt_text = f"Analyze content. TEXT: {text[:1000]}. INSTRUCTIONS: Summarize text and describe images/tables for retrieval."
+    
+    message_content = [{"type": "text", "text": prompt_text}]
+    if images:
+        for b64_str in images:
+            if "," in b64_str: b64_str = b64_str.split(",")[1]
+            message_content.append({
+                "type": "image_url",
+                "image_url": {"url": f"data:image/jpeg;base64,{b64_str}", "detail": "low"}
+            })
+            
+    response = llm.invoke([HumanMessage(content=message_content)])
+    return response.content
+
+def process_and_ingest(file_path: str, session_id: str, doc_store: SessionDocStore):
+    """
+    Parses PDF, creates summary/heavy splits, uploads to Pinecone Namespace.
+    """
+    print(f"📄 Partitioning: {file_path}")
+    elements = partition_pdf(
+        filename=file_path, strategy="hi_res", infer_table_structure=True,
+        extract_image_block_types=["Image", "Table"], extract_image_block_to_payload=True
+    )
+    
+    chunks = chunk_by_title(elements, max_characters=3000, new_after_n_chars=2400, combine_text_under_n_chars=500)
+    
+    documents = []
+    
+    for i, chunk in enumerate(chunks):
+        content = {'text': chunk.text, 'tables': [], 'images': []}
+        
+        # Extract visual data
+        if hasattr(chunk, 'metadata') and hasattr(chunk.metadata, 'orig_elements'):
+            for element in chunk.metadata.orig_elements:
+                el_type = type(element).__name__
+                if el_type == 'Table':
+                    content['tables'].append(getattr(element.metadata, 'text_as_html', element.text))
+                elif el_type == 'Image' and hasattr(element.metadata, 'image_base64'):
+                    content['images'].append(element.metadata.image_base64)
+
+        # Summarize if heavy content exists
+        if content['images'] or content['tables']:
+            enhanced_text = create_multimodal_summary(content['text'], content['tables'], content['images'])
+        else:
+            enhanced_text = content['text']
+
+        doc_id = str(uuid.uuid4())
+        
+        # Save heavy data to local in-memory store
+        doc_store.save_chunk(doc_id, {
+            "raw_text": content['text'],
+            "tables": content['tables'],
+            "images": content['images']
+        })
+        
+        # Create light document for Pinecone
+        doc = Document(
+            page_content=enhanced_text, # "query: " prefix added automatically by some embeddings, but explicit here
+            metadata={"doc_id": doc_id, "chunk_index": i}
+        )
+        documents.append(doc)
+
+    # Ingest to Pinecone (Namespace = Session ID)
+    print(f"🔮 Ingesting to Namespace: {session_id}")
+    PineconeVectorStore.from_documents(
+        documents=documents,
+        index_name=INDEX_NAME,
+        embedding=get_embeddings(),
+        namespace=session_id 
+    )
+    
+    return documents # Return docs for BM25 initialization
+
+def cleanup_session_index(session_id: str):
+    """Deletes the specific namespace for the session"""
+    try:
+        index = pc.Index(INDEX_NAME)
+        index.delete(delete_all=True, namespace=session_id)
+        print(f"🗑️ Deleted Namespace: {session_id}")
+    except Exception as e:
+        print(f"⚠️ Error deleting namespace: {e}")

rag_engine.py

@@ -0,0 +1,126 @@
+import logging
+from typing import List
+from langchain_pinecone import PineconeVectorStore
+from langchain_core.documents import Document
+from langchain_core.messages import HumanMessage
+from flashrank import Ranker, RerankRequest
+from config import *
+
+# Logging setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ⚡ OPTIMIZATION 1: Use FlashRank (Ultra-fast CPU Re-ranking)
+ranker = Ranker(model_name="ms-marco-MiniLM-L-12-v2", cache_dir="/tmp/flashrank_cache")
+
+def reciprocal_rank_fusion(results: List[List[Document]], k=60):
+    fused_scores = {}
+    doc_map = {}
+    for docs in results:
+        for rank, doc in enumerate(docs):
+            doc_id = doc.metadata.get("doc_id")
+            if doc_id not in doc_map: doc_map[doc_id] = doc
+            if doc_id not in fused_scores: fused_scores[doc_id] = 0
+            fused_scores[doc_id] += 1 / (rank + k)
+    
+    reranked_ids = sorted(fused_scores, key=fused_scores.get, reverse=True)
+    return [doc_map[doc_id] for doc_id in reranked_ids]
+
+def rerank_documents(query: str, docs: List[Document], top_n=5):
+    """
+    Optimized Re-ranking using FlashRank (runs in milliseconds).
+    """
+    if not docs: return []
+
+    try:
+        # Prepare format for FlashRank
+        passages = [
+            {"id": str(i), "text": doc.page_content, "meta": doc.metadata}
+            for i, doc in enumerate(docs)
+        ]
+        
+        # Rerank
+        rerank_request = RerankRequest(query=query, passages=passages)
+        results = ranker.rerank(rerank_request)
+        
+        # Convert back to Document objects
+        final_docs = []
+        for res in results[:top_n]:
+            final_docs.append(Document(page_content=res["text"], metadata=res["meta"]))
+            
+        return final_docs
+    except Exception as e:
+        logger.error(f"FlashRank failed: {e}")
+        return docs[:top_n] # Fallback
+
+def run_advanced_rag(query: str, session_id: str, bm25_retriever, doc_store, chat_history):
+    # ⚡ OPTIMIZATION 2: Skip LLM Query Decomposition (Saves 3-5s)
+    # We treat the user query as the only query.
+    queries = [query]
+    
+    # ⚡ OPTIMIZATION 3: Standard Similarity Search (Faster than MMR)
+    vectorstore = PineconeVectorStore.from_existing_index(
+        index_name=INDEX_NAME, embedding=get_embeddings(), namespace=session_id
+    )
+    dense_retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 3})
+    
+    all_docs = []
+    
+    # Hybrid Search
+    for q in queries:
+        dense_docs = dense_retriever.invoke(f"query: {q}")
+        sparse_docs = bm25_retriever.invoke(q)
+        # Fuse results
+        all_docs.extend(reciprocal_rank_fusion([dense_docs, sparse_docs]))
+        
+    # Deduplicate by ID
+    unique_docs = {d.metadata["doc_id"]: d for d in all_docs}
+    
+    # Re-rank (Fast)
+    final_docs = rerank_documents(query, list(unique_docs.values()), top_n=5)
+    
+    # Context Construction
+    context_text = ""
+    retrieved_images = []
+    seen_imgs = set()
+    
+    for i, doc in enumerate(final_docs):
+        # Fetch heavy content from in-memory store
+        heavy = doc_store.get_chunk(doc.metadata["doc_id"])
+        
+        context_text += f"\n--- Source {i+1} ---\n{heavy.get('raw_text', '')}\n"
+        for t in heavy.get('tables', []): 
+            context_text += f"[Table]: {t}\n"
+            
+        # Collect images
+        for img in heavy.get('images', []):
+            if img not in seen_imgs:
+                seen_imgs.add(img)
+                retrieved_images.append(img)
+                
+    # Final Generation
+    llm = get_llm()
+    
+    # Limit history to last 2 turns to save tokens/time
+    hist_text = "\n".join([f"{m.type}: {m.content}" for m in chat_history[-2:]])
+    
+    prompt = f"""
+    Answer the user question based on the provided context.
+    CHAT HISTORY: {hist_text} 
+    CONTEXT: {context_text[:5000]} 
+    QUESTION: {query}
+    """
+    
+    msg_content = [{"type": "text", "text": prompt}]
+    
+    # ⚡ OPTIMIZATION 4: Limit Images to top 2
+    for b64 in retrieved_images[:2]:
+        if "," in b64: b64 = b64.split(",")[1]
+        msg_content.append({
+            "type": "image_url", 
+            "image_url": {"url": f"data:image/jpeg;base64,{b64}"}
+        })
+        
+    response = llm.invoke([HumanMessage(content=msg_content)])
+    
+    return response.content, retrieved_images

requirements.txt

@@ -1,3 +1,15 @@
-altair
-pandas
-streamlit
+FlashRank==0.2.10
+langchain==1.2.0
+openai==2.11.0
+langchain_community==0.4.1
+langchain_core==1.2.6
+langchain_huggingface==1.2.0
+langchain_openai==1.1.6
+langchain_pinecone==0.2.13
+pinecone==7.3.0
+python-dotenv==1.2.1
+streamlit==1.44.1
+unstructured[all-docs]==0.17.2
+pdfminer.six
+pi-heif==1.1.0
+