The main interface created with gradio

gradio_interface.py

@@ -0,0 +1,749 @@
+import gradio as gr
+from doctr.models import ocr_predictor
+from PIL import Image
+import numpy as np
+import torch
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.schema import Document
+import os
+from groq import Groq
+import base64
+from io import BytesIO
+import fitz  # PyMuPDF
+from pathlib import Path
+import time
+import shutil
+
+# -------------------------------
+# 1️⃣ Load OCR + Embedding Models + Groq Client
+# -------------------------------
+device = "cuda" if torch.cuda.is_available() else "cpu"
+ocr_model = ocr_predictor(pretrained=True).to(device)
+embedding_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+# Initialize Groq client
+groq_client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+
+# Model configurations
+VISION_MODEL = "meta-llama/llama-4-scout-17b-16e-instruct"
+LLM_MODEL = "llama-3.3-70b-versatile"
+
+
+# -------------------------------
+# 2️⃣ Helper: Check if image has substantial text
+# -------------------------------
+def has_substantial_text(text, min_words=10):
+    """
+    Determines if OCR extracted enough text to consider it a text-based image.
+    """
+    words = text.split()
+    return len(words) >= min_words
+
+
+# -------------------------------
+# 3️⃣ IMPROVED: Vision Analysis using Groq Llama 4 Scout
+# -------------------------------
+def analyze_image_with_vision(img_path=None, img_bytes=None, pil_image=None, max_retries=3):
+    """
+    Uses Groq's Llama 4 Scout vision model to analyze images (graphs, charts, pictures).
+    Returns a descriptive summary optimized for chart and graph detection.
+    """
+    for attempt in range(max_retries):
+        try:
+            # Read image data
+            if pil_image:
+                buffered = BytesIO()
+                pil_image.save(buffered, format="PNG")
+                img_data = buffered.getvalue()
+                img_format = "png"
+            elif img_path:
+                with open(img_path, "rb") as img_file:
+                    img_data = img_file.read()
+                img_format = img_path.lower().split('.')[-1]
+            elif img_bytes:
+                img_data = img_bytes
+                img_format = "png"
+            else:
+                return ""
+
+            base64_image = base64.b64encode(img_data).decode('utf-8')
+            if img_format == 'jpg':
+                img_format = 'jpeg'
+
+            vision_prompt = """Analyze this image carefully and provide a detailed description:
+
+1. IDENTIFY THE TYPE: Is this a chart, graph, table, diagram, photograph, or text document?
+
+2. IF IT'S A CHART/GRAPH/TABLE:
+   - Specify the exact type (bar chart, pie chart, line graph, scatter plot, table, etc.)
+   - List ALL categories/labels shown
+   - Describe the data values and trends
+   - Mention axis labels, title, legend if present
+   - Highlight key insights or patterns
+
+3. IF IT'S A PHOTOGRAPH/DIAGRAM:
+   - Describe what you see in detail
+   - Identify key objects, people, or concepts
+   - Note any text visible in the image
+
+4. IF IT'S A TEXT DOCUMENT:
+   - Summarize the main content and structure
+
+Provide a comprehensive description suitable for semantic search. Be specific and detailed."""
+
+            chat_completion = groq_client.chat.completions.create(
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": vision_prompt},
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/{img_format};base64,{base64_image}"
+                                }
+                            }
+                        ]
+                    }
+                ],
+                model=VISION_MODEL,
+                temperature=0.2,
+                max_tokens=1500,
+            )
+
+            summary = chat_completion.choices[0].message.content
+            if summary and len(summary.strip()) > 30:
+                return summary
+            else:
+                if attempt < max_retries - 1:
+                    time.sleep(1)
+                    continue
+                return ""
+
+        except Exception as e:
+            error_msg = str(e)
+            if "model_not_found" in error_msg or "not available" in error_msg:
+                print(f"❌ Vision model '{VISION_MODEL}' not available!")
+                return ""
+            else:
+                if attempt < max_retries - 1:
+                    time.sleep(2)
+                    continue
+                return ""
+
+    return ""
+
+
+# -------------------------------
+# 4️⃣ Smart OCR/Vision Extraction for Images
+# -------------------------------
+def extract_text_from_image(img_path):
+    """
+    Intelligently extracts content from images:
+    - Uses OCR for text-heavy images
+    - Uses Vision model for graphs, charts, and pictures
+    """
+    try:
+        image = Image.open(img_path).convert("RGB")
+        image_np = np.array(image)
+        result = ocr_model([image_np])
+
+        text = []
+        for page in result.pages:
+            for block in page.blocks:
+                for line in block.lines:
+                    line_text = " ".join([word.value for word in line.words])
+                    text.append(line_text)
+
+        ocr_text = "\n".join(text)
+
+        if has_substantial_text(ocr_text, min_words=10):
+            print(f"📄 {os.path.basename(img_path)}: Using OCR (text document)")
+            return ocr_text
+        else:
+            print(f"🖼️  {os.path.basename(img_path)}: Using Vision Model (graph/chart/picture)")
+            vision_summary = analyze_image_with_vision(img_path=img_path)
+            return vision_summary if vision_summary else ocr_text
+
+    except Exception as e:
+        print(f"❌ Error processing {img_path}: {e}")
+        return ""
+
+
+# -------------------------------
+# 5️⃣ Extract Text from Plain Text Files
+# -------------------------------
+def extract_text_from_txt(file_path):
+    """
+    Extracts text from plain text files (.txt, .md, etc.)
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            text = f.read()
+        print(f"📝 {os.path.basename(file_path)}: Extracted text document")
+        return text
+    except Exception as e:
+        print(f"❌ Error reading text file {file_path}: {e}")
+        return ""
+
+
+# -------------------------------
+# 6️⃣ ENHANCED: Extract Content from PDFs with Vision Analysis
+# -------------------------------
+def extract_content_from_pdf(pdf_path):
+    """
+    Extracts content from PDFs with comprehensive vision analysis
+    """
+    try:
+        doc = fitz.open(pdf_path)
+        all_content = []
+
+        for page_num, page in enumerate(doc, 1):
+            page_content = []
+
+            # Extract text
+            text = page.get_text()
+            if text.strip():
+                page_content.append(f"[Page {page_num} - Text Content]\n{text}")
+                print(f"📄 {os.path.basename(pdf_path)} (Page {page_num}): Extracted text ({len(text)} chars)")
+
+            # Render entire page as image for vision analysis
+            print(f"🔄 {os.path.basename(pdf_path)} (Page {page_num}): Rendering page for vision analysis...")
+            try:
+                mat = fitz.Matrix(2, 2)
+                pix = page.get_pixmap(matrix=mat)
+                img_data = pix.tobytes("png")
+                page_image = Image.open(BytesIO(img_data)).convert("RGB")
+
+                print(f"🔍 {os.path.basename(pdf_path)} (Page {page_num}): Analyzing with {VISION_MODEL}...")
+                vision_analysis = analyze_image_with_vision(pil_image=page_image)
+
+                if vision_analysis and len(vision_analysis.strip()) > 30:
+                    vision_section = f"[Page {page_num} - Visual Analysis]\n{vision_analysis}"
+                    page_content.append(vision_section)
+                    print(f"✅ {os.path.basename(pdf_path)} (Page {page_num}): Vision analysis complete")
+
+            except Exception as e:
+                print(f"❌ Error rendering page {page_num}: {e}")
+
+            # Extract embedded images
+            image_list = page.get_images(full=True)
+            for img_index, img_info in enumerate(image_list, 1):
+                try:
+                    xref = img_info[0]
+                    base_image = doc.extract_image(xref)
+                    image_bytes = base_image["image"]
+                    image = Image.open(BytesIO(image_bytes)).convert("RGB")
+                    image_np = np.array(image)
+
+                    result = ocr_model([image_np])
+                    ocr_text = []
+                    for ocr_page in result.pages:
+                        for block in ocr_page.blocks:
+                            for line in block.lines:
+                                line_text = " ".join([word.value for word in line.words])
+                                ocr_text.append(line_text)
+
+                    extracted_text = "\n".join(ocr_text)
+
+                    if has_substantial_text(extracted_text, min_words=10):
+                        page_content.append(f"[Page {page_num} - Embedded Image {img_index} OCR]\n{extracted_text}")
+                    else:
+                        vision_summary = analyze_image_with_vision(img_bytes=image_bytes)
+                        if vision_summary:
+                            page_content.append(
+                                f"[Page {page_num} - Embedded Image {img_index} Analysis]\n{vision_summary}")
+
+                except Exception as e:
+                    print(f"❌ Error processing embedded image {img_index}: {e}")
+                    continue
+
+            if page_content:
+                combined_page = "\n\n---SECTION BREAK---\n\n".join(page_content)
+                all_content.append(combined_page)
+
+        doc.close()
+        final_content = "\n\n---PAGE BREAK---\n\n".join(all_content)
+        return final_content
+
+    except Exception as e:
+        print(f"❌ Error processing PDF {pdf_path}: {e}")
+        return ""
+
+
+# -------------------------------
+# 7️⃣ Process All Document Types
+# -------------------------------
+def create_documents_from_folder(folder_path):
+    """
+    Process all supported file types in a folder and create documents.
+    """
+    docs = []
+
+    for root, dirs, files in os.walk(folder_path):
+        for filename in files:
+            full_path = os.path.join(root, filename)
+            file_ext = filename.lower().split('.')[-1]
+
+            print(f"\n{'=' * 60}")
+            print(f"Processing: {filename}")
+            print(f"{'=' * 60}")
+
+            text = ""
+
+            if file_ext in ["jpg", "jpeg", "png"]:
+                text = extract_text_from_image(full_path)
+            elif file_ext in ["txt", "md"]:
+                text = extract_text_from_txt(full_path)
+            elif file_ext == "pdf":
+                text = extract_content_from_pdf(full_path)
+            else:
+                print(f"⏭️  Skipping unsupported file: {filename}")
+                continue
+
+            if text.strip():
+                relative_path = os.path.relpath(full_path, folder_path)
+                doc = Document(
+                    page_content=text,
+                    metadata={
+                        "source": relative_path,
+                        "filename": filename,
+                        "file_type": file_ext,
+                        "upload_timestamp": os.path.getmtime(full_path)
+                    }
+                )
+                docs.append(doc)
+                print(f"✅ Added {filename} to documents ({len(text)} chars)")
+            else:
+                print(f"⚠️  Skipping {filename} - no content extracted")
+
+    return docs
+
+
+# -------------------------------
+# 8️⃣ Build or Update FAISS Store
+# -------------------------------
+def build_or_update_faiss_store(folder_path, faiss_store_path="faiss_multimodal_store"):
+    """
+    Builds a new FAISS store if none exists, otherwise updates it incrementally.
+    """
+    print("\n" + "=" * 60)
+    print("🔄 STARTING DOCUMENT PROCESSING")
+    print("=" * 60)
+
+    docs = create_documents_from_folder(folder_path)
+
+    if not docs:
+        print("\n⚠️  No valid documents found!")
+        return None
+
+    print(f"\n✅ Successfully processed {len(docs)} documents")
+
+    if not os.path.exists(faiss_store_path):
+        print("\n🔨 Creating new FAISS index...")
+        vector_store = FAISS.from_documents(docs, embedding_model)
+        vector_store.save_local(faiss_store_path)
+        print(f"✅ Created new FAISS index at {faiss_store_path}")
+    else:
+        print("\n🔄 Updating existing FAISS index...")
+        vector_store = FAISS.load_local(faiss_store_path, embedding_model, allow_dangerous_deserialization=True)
+        vector_store.add_documents(docs)
+        vector_store.save_local(faiss_store_path)
+        print(f"✅ Updated existing FAISS index at {faiss_store_path}")
+
+    return vector_store
+
+
+# -------------------------------
+# 9️⃣ Query Function with Chart-Aware Re-ranking
+# -------------------------------
+def query_faiss_store(query_text, k=3, faiss_store_path="faiss_multimodal_store"):
+    """
+    Query the FAISS store and return top-k relevant documents.
+    """
+    if not os.path.exists(faiss_store_path):
+        print(f"❌ FAISS store not found at {faiss_store_path}")
+        return []
+
+    vector_store = FAISS.load_local(faiss_store_path, embedding_model, allow_dangerous_deserialization=True)
+
+    initial_k = k * 3
+    results = vector_store.similarity_search_with_score(query_text, k=initial_k)
+
+    # Check if query is asking about visual content
+    visual_query_keywords = ['chart', 'graph', 'bar', 'pie', 'plot', 'diagram', 'table', 'visual', 'visualization']
+    is_visual_query = any(keyword in query_text.lower() for keyword in visual_query_keywords)
+
+    if is_visual_query:
+        print(f"🔍 Detected visual content query - applying smart re-ranking...")
+        reranked_results = []
+
+        for doc, score in results:
+            boost = 0.0
+
+            if "**Type:**" in doc.page_content or "Visual Analysis]" in doc.page_content:
+                visual_content = doc.page_content.lower()
+
+                if 'bar chart' in query_text.lower() or 'bar graph' in query_text.lower():
+                    if 'bar chart' in visual_content or 'bar graph' in visual_content:
+                        boost += 1.0
+
+                elif 'pie chart' in query_text.lower():
+                    if 'pie chart' in visual_content:
+                        boost += 1.0
+
+                elif 'line graph' in query_text.lower() or 'line chart' in query_text.lower():
+                    if 'line graph' in visual_content or 'line chart' in visual_content:
+                        boost += 1.0
+
+                elif any(kw in query_text.lower() for kw in ['chart', 'graph', 'visualization']):
+                    if any(kw in visual_content for kw in ['chart', 'graph', 'plot', 'diagram']):
+                        boost += 0.5
+                else:
+                    boost += 0.2
+
+            adjusted_score = score - boost
+            reranked_results.append((doc, adjusted_score, score))
+
+        reranked_results.sort(key=lambda x: x[1])
+        results = [(doc, adj_score) for doc, adj_score, _ in reranked_results[:k]]
+    else:
+        results = results[:k]
+
+    retrieved_docs = []
+    for doc, score in results:
+        retrieved_docs.append({
+            "source": doc.metadata['source'],
+            "content": doc.page_content,
+            "score": score,
+            "metadata": doc.metadata
+        })
+
+    return retrieved_docs
+
+
+# -------------------------------
+# 🆕 10️⃣ Answer Question using Llama 3.3 70B
+# -------------------------------
+def answer_question_with_llm(query_text, retrieved_docs, max_tokens=2000):
+    """
+    Uses Llama-3.3-70b-versatile to answer questions based on retrieved documents.
+    """
+    if not retrieved_docs:
+        return "❌ No relevant documents found to answer your question."
+
+    # Prepare context from retrieved documents
+    context_parts = []
+    for i, doc in enumerate(retrieved_docs, 1):
+        source = doc['source']
+        content = doc['content']
+        # Truncate very long content to fit within token limits
+        max_content_length = 3000
+        if len(content) > max_content_length:
+            content = content[:max_content_length] + "...[truncated]"
+
+        context_parts.append(f"--- Document {i}: {source} ---\n{content}\n")
+
+    context = "\n".join(context_parts)
+
+    # Construct the prompt
+    system_prompt = """You are a helpful AI assistant that answers questions based on provided documents. 
+Your responses should be:
+1. Accurate and based solely on the provided context
+2. Clear and well-structured
+3. Include specific details from the documents when relevant
+4. Cite the document source when making specific claims
+5. If the answer isn't in the documents, say so clearly
+
+When documents contain visual analysis (charts, graphs, tables), use that information to answer questions about visual elements."""
+
+    user_prompt = f"""Based on the following documents, please answer this question: {query_text}
+
+DOCUMENTS:
+{context}
+
+Please provide a comprehensive answer based on the information above. If the documents contain relevant charts, graphs, or visual elements, include that information in your answer."""
+
+    try:
+        print(f"\n🤖 Generating answer with {LLM_MODEL}...")
+
+        response = groq_client.chat.completions.create(
+            model=LLM_MODEL,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.3,  # Lower for more factual responses
+            max_tokens=max_tokens,
+            top_p=0.9,
+        )
+
+        answer = response.choices[0].message.content
+        return answer
+
+    except Exception as e:
+        print(f"❌ Error calling LLM: {e}")
+        return f"❌ Error generating answer: {str(e)}"
+
+
+# -------------------------------
+# 🆕 11️⃣ Complete RAG Pipeline
+# -------------------------------
+def ask_question(query_text, k=3, faiss_store_path="faiss_multimodal_store", show_sources=True):
+    """
+    Complete RAG pipeline: retrieves relevant documents and generates an answer.
+    (This function is kept for logic, but the Gradio app will use a wrapper)
+    """
+    print("\n" + "=" * 80)
+    print(f"❓ QUESTION: {query_text}")
+    print("=" * 80)
+
+    # Step 1: Retrieve relevant documents
+    print("\n📚 Retrieving relevant documents...")
+    retrieved_docs = query_faiss_store(query_text, k=k, faiss_store_path=faiss_store_path)
+
+    if not retrieved_docs:
+        print("❌ No relevant documents found.")
+        return
+
+    # Display retrieved sources
+    if show_sources:
+        print(f"\n📄 Retrieved {len(retrieved_docs)} relevant documents:")
+        for i, doc in enumerate(retrieved_docs, 1):
+            print(f"   {i}. {doc['source']} (score: {doc['score']:.4f})")
+
+    # Step 2: Generate answer with LLM
+    print("\n" + "=" * 80)
+    answer = answer_question_with_llm(query_text, retrieved_docs)
+
+    print("💡 ANSWER:")
+    print("=" * 80)
+    print(answer)
+    print("=" * 80)
+
+    # Display source citations
+    print("\n📚 Sources Used:")
+    for i, doc in enumerate(retrieved_docs, 1):
+        print(f"   [{i}] {doc['source']}")
+    print()
+
+    return {
+        "query": query_text,
+        "answer": answer,
+        "sources": retrieved_docs
+    }
+
+
+# -------------------------------
+# 🆕 12️⃣ GRADIO: Process Uploaded Files
+# -------------------------------
+def process_uploaded_files(file_list, faiss_store_path="faiss_multimodal_store"):
+    """
+    Processes a list of files uploaded via Gradio, adds them to the
+    FAISS index, and saves the index.
+    """
+    if not file_list:
+        return "No files uploaded. Please upload files first."
+
+    print("\n" + "=" * 60)
+    print("NEW UPLOAD DETECTED: Processing files...")
+    print("=" * 60)
+
+    docs = []
+    for file_obj in file_list:
+        # file_obj.name is the temporary path where Gradio stored the file
+        full_path = file_obj.name
+        filename = os.path.basename(full_path)
+        file_ext = filename.lower().split('.')[-1]
+
+        print(f"\nProcessing uploaded file: {filename}")
+
+        text = ""
+        if file_ext in ["jpg", "jpeg", "png"]:
+            text = extract_text_from_image(full_path)
+        elif file_ext in ["txt", "md"]:
+            text = extract_text_from_txt(full_path)
+        elif file_ext == "pdf":
+            text = extract_content_from_pdf(full_path)
+        else:
+            print(f"⏭️  Skipping unsupported file: {filename}")
+            continue
+
+        if text.strip():
+            # Use filename as source for metadata
+            doc = Document(
+                page_content=text,
+                metadata={
+                    "source": filename,  # Using filename as source
+                    "filename": filename,
+                    "file_type": file_ext,
+                    "upload_timestamp": time.time()
+                }
+            )
+            docs.append(doc)
+            print(f"✅ Added {filename} to documents ({len(text)} chars)")
+        else:
+            print(f"⚠️  Skipping {filename} - no content extracted")
+
+    if not docs:
+        print("\n⚠️  No valid documents processed from upload.")
+        return "⚠️ No valid documents were processed from the upload."
+
+    # Add the new documents to the FAISS store
+    if not os.path.exists(faiss_store_path):
+        print("\n🔨 Creating new FAISS index from uploaded files...")
+        vector_store = FAISS.from_documents(docs, embedding_model)
+    else:
+        print("\n🔄 Updating existing FAISS index with uploaded files...")
+        try:
+            vector_store = FAISS.load_local(faiss_store_path, embedding_model, allow_dangerous_deserialization=True)
+            vector_store.add_documents(docs)
+        except Exception as e:
+            print(f"❌ Error loading or adding to FAISS: {e}")
+            return f"❌ Error updating vector store: {e}"
+
+    vector_store.save_local(faiss_store_path)
+
+    success_message = f"✅ Successfully processed and added {len(docs)} new document(s) to the knowledge base."
+    print(f"\n{success_message}")
+    return success_message
+
+
+# -------------------------------
+# ✅ Example Usage (NOW WITH GRADIO TABS!)
+# -------------------------------
+if __name__ == "__main__":
+    folder = "data"  # Your folder with images, PDFs, and text files
+    faiss_store_path = "faiss_multimodal_store"
+
+    # Check Groq API key
+    if not os.environ.get("GROQ_API_KEY"):
+        print("\n" + "=" * 60)
+        print("⚠️  WARNING: GROQ_API_KEY not set!")
+        print("=" * 60)
+        print("Please set it with: export GROQ_API_KEY='your-key-here'")
+        print("=" * 60 + "\n")
+        exit(1)
+
+    print(f"✅ Groq API Key found")
+    print(f"✅ Vision Model: {VISION_MODEL}")
+    print(f"✅ LLM Model: {LLM_MODEL}\n")
+
+    # Build/update the vector store (only run once or when adding new documents)
+    print("Would you like to rebuild the FAISS index from the 'data' folder? (y/n): ", end="")
+    rebuild = input().strip().lower()
+
+    if rebuild == 'y':
+        build_or_update_faiss_store(folder, faiss_store_path)
+    else:
+        if not os.path.exists(faiss_store_path):
+            print(f"⚠️  FAISS store not found at '{faiss_store_path}'. Building a new one from '{folder}'...")
+            build_or_update_faiss_store(folder, faiss_store_path)
+        else:
+            print(f"✅ Using existing FAISS index at '{faiss_store_path}'")
+
+
+    # ---
+    # 🚀 GRADIO INTERFACE SECTION (WITH TABS)
+    # ---
+
+    def gradio_ask_question(query_text, k=3):
+        """
+        A wrapper function for Gradio that calls the RAG pipeline
+        and formats the output as a single string.
+        (This is the same function as before)
+        """
+        print("\n" + "=" * 80)
+        print(f"❓ GRADIO QUERY: {query_text}")
+        print("=" * 80)
+
+        # Step 1: Retrieve relevant documents (using your existing function)
+        print("\n📚 Retrieving relevant documents...")
+        retrieved_docs = query_faiss_store(query_text, k=k, faiss_store_path=faiss_store_path)
+
+        if not retrieved_docs:
+            print("❌ No relevant documents found.")
+            return "❌ No relevant documents found to answer your question."
+
+        print(f"\n📄 Retrieved {len(retrieved_docs)} relevant documents:")
+        for i, doc in enumerate(retrieved_docs, 1):
+            print(f"   {i}. {doc['source']} (score: {doc['score']:.4f})")
+
+        # Step 2: Generate answer with LLM (using your existing function)
+        answer = answer_question_with_llm(query_text, retrieved_docs)
+
+        # Step 3: Format the response for the chat bubble
+        sources_md = "\n\n---\n**📚 Sources Used:**\n"
+        for i, doc in enumerate(retrieved_docs, 1):
+            sources_md += f"* **{doc['source']}** (Score: {doc['score']:.4f})\n"
+
+        final_response = answer + sources_md
+
+        print("\n" + "=" * 80)
+        print("💡 ANSWER (for Gradio):")
+        print(final_response)
+        print("=" * 80)
+
+        return final_response
+
+
+    def chat_response_func(message, history):
+        """
+        The main function that Gradio's ChatInterface will call.
+        (This is the same function as before)
+        """
+        return gradio_ask_question(message, k=3)
+
+
+    print("\n" + "=" * 80)
+    print("🚀 LAUNCHING GRADIO INTERFACE WITH TABS...")
+    print("=" * 80)
+    print("Visit the URL in your terminal (usually http://127.0.0.1:7860) to chat or upload.")
+    print("=" * 80)
+
+    # Create the Gradio UI using Blocks for tabs
+    with gr.Blocks(theme="soft") as demo:
+        gr.Markdown("# 🧠 Multimodal RAG System")
+
+        with gr.Tabs():
+            # --- CHAT TAB ---
+            with gr.TabItem("Chat with Documents"):
+                gr.ChatInterface(
+                    fn=chat_response_func,
+                    title="Multimodal RAG Chat",
+                    description="Ask questions about your documents (PDFs, images, text). The system uses Llama 4 Scout for vision and Llama 3.3 70B for answers.",
+                    examples=[
+                        "What documents contain bar charts?",
+                        "Summarize the information about pollution",
+                        "What are the key findings in the environmental report?",
+                        "Describe the graphs showing water quality"
+                    ],
+                )
+
+            # --- UPLOAD TAB ---
+            with gr.TabItem("Upload New Documents"):
+                gr.Markdown("Upload new PDF, image, or text files to add them to the knowledge base.")
+
+                file_uploader = gr.File(
+                    label="Upload Documents",
+                    file_count="multiple",
+                    file_types=["image", ".pdf", ".txt", ".md"],
+                    interactive=True
+                )
+
+                upload_button = gr.Button("Process and Add Documents", variant="primary")
+
+                status_output = gr.Markdown("Status: Ready to upload new documents.")
+
+                # Connect the upload button to the processing function
+                upload_button.click(
+                    fn=process_uploaded_files,
+                    inputs=[file_uploader],
+                    outputs=[status_output]
+                )
+
+    # Launch the app
+    demo.launch()
+
+    print("\n👋 Interface closed. Goodbye!")