Integreted with new db

main.py

@@ -0,0 +1,815 @@
+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  # No longer needed
+
+from langchain_core.documents 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  # No longer needed
+
+# -------------------------------
+# 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"
+
+# -------------------------------
+# 1b ☁️ NEW: Qdrant Cloud Configuration
+# -------------------------------
+# Using the credentials you provided
+QDRANT_URL = "https://bdf142ef-7e2a-433b-87a0-301ff303e3af.us-east4-0.gcp.cloud.qdrant.io:6333"
+# API Key is loaded from environment variable for security
+QDRANT_API_KEY = os.environ.get("QDRANT_API_KEY")
+COLLECTION_NAME = "multimodal_rag_store"
+
+# NEW IMPORTS for QDRANT
+from langchain_qdrant import Qdrant
+from qdrant_client import QdrantClient
+
+# -------------------------------
+# 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
+# -------------------------------
+# ... (This function is identical, no changes needed) ...
+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
+# -------------------------------
+# ... (This function is identical, no changes needed) ...
+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
+# -------------------------------
+# ... (This function is identical, no changes needed) ...
+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
+# -------------------------------
+# ... (This function is identical, no changes needed) ...
+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
+# -------------------------------
+# ... (This function is identical, no changes needed) ...
+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,
+                        # This captures the *file modification time* for local files
+                        "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️⃣ ☁️ NEW: Build or Update QDRANT Store
+# -------------------------------
+# ... (This function is identical, no changes needed) ...
+def build_or_update_qdrant_store(folder_path):
+    """
+    Builds a new Qdrant store in the cloud, deleting any old one.
+    """
+    print("\n" + "=" * 60)
+    print("🔄 STARTING DOCUMENT PROCESSING FOR QDRANT")
+    print("=" * 60)
+
+    docs = create_documents_from_folder(folder_path)  # This part is the same
+
+    if not docs:
+        print("\n⚠️  No valid documents found!")
+        return None
+
+    print(f"\n✅ Successfully processed {len(docs)} documents")
+    print(f"☁️  Uploading documents to Qdrant Cloud collection: {COLLECTION_NAME}...")
+
+    # This command connects, deletes the old collection (if it exists),
+    # and uploads all the new documents.
+    try:
+        vector_store = Qdrant.from_documents(
+            docs,
+            embedding_model,
+            url=QDRANT_URL,
+            api_key=QDRANT_API_KEY,
+            collection_name=COLLECTION_NAME,
+            force_recreate=True  # This matches the old "delete and rebuild" logic
+        )
+        print(f"✅ Successfully created/updated Qdrant collection: {COLLECTION_NAME}")
+        return vector_store
+    except Exception as e:
+        print(f"❌ Error connecting or uploading to Qdrant: {e}")
+        print("Please check your QDRANT_URL and QDRANT_API_KEY")
+        return None
+
+
+# -------------------------------
+# 9️⃣ ☁️ NEW: Query QDRANT Function with Chart-Aware Re-ranking
+# -------------------------------
+# ... (This function is identical, no changes needed) ...
+def query_qdrant_store(query_text, k=3):
+    """
+    Query the QDRANT store and return top-k relevant documents.
+    """
+    try:
+        # 1. Create the Qdrant client
+        client = QdrantClient(
+            url=QDRANT_URL,
+            api_key=QDRANT_API_KEY,
+            timeout=20  # Increased timeout for cloud connection
+        )
+
+        # 2. Instantiate the LangChain vector store object
+        vector_store = Qdrant(
+            client=client,
+            collection_name=COLLECTION_NAME,
+            embeddings=embedding_model
+        )
+        print(f"✅ Connected to Qdrant collection: {COLLECTION_NAME}")
+
+    except Exception as e:
+        print(f"❌ Error connecting to Qdrant: {e}")
+        return []
+
+    initial_k = k * 3
+    # This part is identical to the old code!
+    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 (MODIFIED)
+# -------------------------------
+def answer_question_with_llm(query_text, retrieved_docs, max_tokens=1000): # Reduced max_tokens for brevity
+    """
+    Uses Llama-3.3-70b-versatile to answer questions based on retrieved documents.
+    **MODIFIED** for shorter answers and to read metadata (like upload time).
+    """
+    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']
+        metadata = doc['metadata'] # Get metadata
+
+        # Format timestamp
+        timestamp = metadata.get('upload_timestamp')
+        readable_time = "N/A"
+        if timestamp:
+            try:
+                # Use time.ctime() for a simple, human-readable string
+                readable_time = time.ctime(float(timestamp))
+            except (ValueError, TypeError):
+                readable_time = str(timestamp) # Fallback
+
+        metadata_str = (
+            f"Source: {source}\n"
+            f"File Type: {metadata.get('file_type', 'N/A')}\n"
+            f"Uploaded/Modified: {readable_time}"
+        )
+
+        # Truncate very long content to fit within token limits
+        max_content_length = 2500 # Kept it reasonably long for context
+        if len(content) > max_content_length:
+            content = content[:max_content_length] + "...[truncated]"
+
+        context_parts.append(
+            f"--- Document {i} ---\n"
+            f"[METADATA]:\n{metadata_str}\n\n"
+            f"[CONTENT]:\n{content}\n"
+        )
+
+    context = "\n".join(context_parts)
+
+    # Construct the prompt (MODIFIED FOR BREVITY)
+    system_prompt = """You are a concise AI assistant. Answer the user's question *only* using the provided documents.
+- Be brief and to the point.
+- The documents include `[METADATA]` and `[CONTENT]`.
+- Use the metadata to answer questions about file details (like upload time, source, or file type).
+- If the answer is not in the documents or metadata, simply state 'That information is not available in the documents.'"""
+
+    user_prompt = f"""DOCUMENTS:
+{context}
+
+QUESTION: {query_text}
+
+ANSWER: (Provide a concise answer based *only* on the documents)"""
+
+    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.2,  # Lowered for more factual, less creative answers
+            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
+# -------------------------------
+# ... (This function is identical, no changes needed) ...
+def ask_question(query_text, k=3, 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 from Qdrant...")
+    retrieved_docs = query_qdrant_store(query_text, k=k) # <-- CHANGED
+
+    if not retrieved_docs:
+        print("❌ No relevant documents found.")
+        return
+
+    # ... (Rest of function is identical) ...
+    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})")
+    
+    answer = answer_question_with_llm(query_text, retrieved_docs)
+    # ... (print statements) ...
+    return {
+        "query": query_text,
+        "answer": answer,
+        "sources": retrieved_docs
+    }
+
+
+# -------------------------------
+# 🆕 12️⃣ ☁️ NEW: GRADIO: Process Uploaded Files to QDRANT
+# -------------------------------
+def process_uploaded_files(file_list):
+    """
+    Processes a list of files uploaded via Gradio, adds them to the
+    QDRANT CLOUD index.
+    """
+    if not file_list:
+        return "No files uploaded. Please upload files first."
+
+    print("\n" + "=" * 60)
+    print("NEW UPLOAD DETECTED: Processing files...")
+    print("=" * 60)
+
+    # --- This whole section is identical ---
+    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() # This captures the *moment of upload*
+                }
+            )
+            docs.append(doc)
+            print(f"✅ Added {filename} to documents ({len(text)} chars)")
+        else:
+            print(f"⚠️  Skipping {filename} - no content extracted")
+    # --- End of identical section ---
+
+    if not docs:
+        print("\n⚠️  No valid documents processed from upload.")
+        return "⚠️ No valid documents were processed from the upload."
+
+    # --- NEW QDRANT UPLOAD LOGIC (APPENDS to DB) ---
+    try:
+        print(f"\n☁️  Connecting to Qdrant to add {len(docs)} new documents...")
+        
+        # 1. Create the client
+        client = QdrantClient(url=QDRANT_URL, api_key=QDRANT_API_KEY)
+
+        # 2. Instantiate the LangChain vector store object
+        vector_store = Qdrant(
+            client=client,
+            collection_name=COLLECTION_NAME,
+            embeddings=embedding_model
+        )
+        
+        # 3. Add the new documents (this appends to the existing collection)
+        vector_store.add_documents(docs)
+        
+        success_message = f"✅ Successfully processed and added {len(docs)} new document(s) to the cloud knowledge base."
+        print(f"\n{success_message}")
+        return success_message
+
+    except Exception as e:
+        print(f"❌ Error adding documents to Qdrant: {e}")
+        return f"❌ Error updating vector store: {e}"
+
+
+# -------------------------------
+# ✅ 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" # <-- No longer needed
+
+    # 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)
+        
+    # --- NEW: Check Qdrant API Key ---
+    if not QDRANT_API_KEY:
+        print("\n" + "=" * 60)
+        print("⚠️  WARNING: QDRANT_API_KEY not set!")
+        print("=" * 60)
+        print("Please set it with: export QDRANT_API_KEY='your-key-here'")
+        print("=" * 60 + "\n")
+        exit(1)
+
+    print(f"✅ Groq API Key found")
+    print(f"✅ Qdrant API Key found")
+    print(f"✅ Vision Model: {VISION_MODEL}")
+    print(f"✅ LLM Model: {LLM_MODEL}\n")
+
+    # ---
+    # 🚀 ALWAYS REBUILD THE CLOUD DATABASE ON STARTUP
+    # ---
+    print("\n" + "=" * 60)
+    print(f"🔄 Always rebuilding Qdrant collection '{COLLECTION_NAME}' from '{folder}'...")
+    print("=" * 60)
+
+    # Remove the old FAISS store logic
+    # This one function now handles deleting the old cloud collection
+    # and uploading the new one.
+    build_or_update_qdrant_store(folder)
+
+
+    # ---
+    # 🚀 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.
+        """
+        print("\n" + "=" * 80)
+        print(f"❓ GRADIO QUERY: {query_text}")
+        print("=" * 80)
+
+        # Step 1: Retrieve relevant documents (using NEW Qdrant function)
+        print("\n📚 Retrieving relevant documents from Qdrant...")
+        retrieved_docs = query_qdrant_store(query_text, k=k) # <-- CHANGED
+
+        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):
+            # Show the new metadata in the console log
+            print(f"   {i}. {doc['source']} (Score: {doc['score']:.4f})")
+            print(f"      Metadata: {doc['metadata']}")
+
+
+        # 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.
+        """
+        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 (Powered by Qdrant Cloud)")
+
+        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, # This now calls the Qdrant upload function
+                    inputs=[file_uploader],
+                    outputs=[status_output]
+                )
+
+    # Launch the app
+    demo.launch()
+
+    print("\n👋 Interface closed. Goodbye!")