changing the path urls

app.py

@@ -29,7 +29,6 @@ from qdrant_client import QdrantClient
 # 1️⃣ Load OCR + Embedding Models + Groq Client
 # -------------------------------
 device = "cuda" if torch.cuda.is_available() else "cpu"
-# Using a try-except block in case the model initialization fails (e.g., memory constraints)
 try:
     print(f"Loading OCR model to {device}...")
     ocr_model = ocr_predictor(pretrained=True).to(device)
@@ -60,7 +59,7 @@ QDRANT_URL = os.environ.get("QDRANT_URL", "https://bdf142ef-7e2a-433b-87a0-301ff
 QDRANT_API_KEY = os.environ.get("QDRANT_API_KEY")
 COLLECTION_NAME = "multimodal_rag_store"
 
-# --- Helper Functions ---
+# --- Helper Functions (2 to 7) ---
 
 # -------------------------------
 # 2️⃣ Helper: Check if image has substantial text
@@ -74,11 +73,10 @@ def has_substantial_text(text, min_words=10):
 
 
 # -------------------------------
-# 3️⃣ IMPROVED: Vision Analysis using Groq Llama 4 Scout
+# 3️⃣ Vision Analysis using Groq Llama 4 Scout
 # -------------------------------
 def analyze_image_with_vision(img_path=None, img_bytes=None, pil_image=None, max_retries=3):
     if not groq_client:
-        print("❌ Groq client not initialized. Cannot use vision model.")
         return ""
     
     for attempt in range(max_retries):
@@ -96,7 +94,6 @@ def analyze_image_with_vision(img_path=None, img_bytes=None, pil_image=None, max
                 img_format = img_path.lower().split('.')[-1]
             elif img_bytes:
                 img_data = img_bytes
-                # We assume PNG for raw bytes if format is unknown/irrelevant for a PIL-based source
             else:
                 return ""
             
@@ -107,7 +104,7 @@ def analyze_image_with_vision(img_path=None, img_bytes=None, pil_image=None, max
             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.)
+    - Specify the exact type 
     - List ALL categories/labels shown
     - Describe the data values and trends
     - Mention axis labels, title, legend if present
@@ -153,7 +150,6 @@ Provide a comprehensive description suitable for semantic search. Be specific an
                 print(f"❌ Vision model '{VISION_MODEL}' not available! Skipping vision analysis.")
                 return ""
             else:
-                print(f"❌ Vision API Error on attempt {attempt+1}: {e}")
                 if attempt < max_retries - 1:
                     time.sleep(2)
                     continue
@@ -186,7 +182,6 @@ def extract_text_from_image(img_path):
         else:
             print(f"🖼️  {os.path.basename(img_path)}: Using Vision Model (graph/chart/picture)")
             vision_summary = analyze_image_with_vision(img_path=img_path)
-            # Fallback to sparse OCR text if vision summary fails
             return vision_summary if vision_summary else ocr_text 
     except Exception as e:
         print(f"❌ Error processing {img_path}: {e}")
@@ -208,7 +203,7 @@ def extract_text_from_txt(file_path):
 
 
 # -------------------------------
-# 6️⃣ ENHANCED: Extract Content from PDFs with Vision Analysis
+# 6️⃣ Extract Content from PDFs with Vision Analysis
 # -------------------------------
 def extract_content_from_pdf(pdf_path):
     try:
@@ -221,11 +216,9 @@ def extract_content_from_pdf(pdf_path):
             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)")
-            
-            # 2. Vision analysis of the entire page image (for charts/layouts)
+                
+            # 2. Vision analysis of the entire page image 
             if groq_client:
-                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)
@@ -236,11 +229,10 @@ def extract_content_from_pdf(pdf_path):
                     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/analyzing page {page_num}: {e}")
+                except Exception:
+                    pass # Ignore rendering/analysis errors
             
-            # 3. OCR on embedded images (fallback/secondary) - only if OCR model is loaded
+            # 3. OCR on embedded images (if OCR model is loaded)
             if ocr_model:
                 image_list = page.get_images(full=True)
                 for img_index, img_info in enumerate(image_list, 1):
@@ -248,10 +240,8 @@ def extract_content_from_pdf(pdf_path):
                         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:
@@ -264,14 +254,12 @@ def extract_content_from_pdf(pdf_path):
                         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:
-                            # Use vision for image within PDF if OCR is sparse
                             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}")
+                    except Exception:
                         continue
             
             if page_content:
@@ -288,7 +276,7 @@ def extract_content_from_pdf(pdf_path):
 
 
 # -------------------------------
-# 7️⃣ Process All Document Types
+# 7️⃣ Process All Document Types for folder build
 # -------------------------------
 def create_documents_from_folder(folder_path):
     docs = []
@@ -296,9 +284,6 @@ def create_documents_from_folder(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"]:
@@ -308,7 +293,6 @@ def create_documents_from_folder(folder_path):
             elif file_ext == "pdf":
                 text = extract_content_from_pdf(full_path)
             else:
-                print(f"⏭️  Skipping unsupported file: {filename}")
                 continue
                 
             if text.strip():
@@ -323,30 +307,22 @@ def create_documents_from_folder(folder_path):
                     }
                 )
                 docs.append(doc)
-                print(f"✅ Added {filename} to documents ({len(text)} chars)")
-            else:
-                print(f"⚠️  Skipping {filename} - no content extracted")
+            
     return docs
 
+# --- Core RAG/DB Functions (8 to 12) ---
 
 # -------------------------------
-# 8️⃣ ☁️ NEW: Build or Update QDRANT Store
+# 8️⃣ Build or Update QDRANT Store
 # -------------------------------
 def build_or_update_qdrant_store(folder_path):
     if not QDRANT_API_KEY:
-        print("❌ QDRANT_API_KEY is missing. Skipping database build.")
         return None
         
-    print("\n" + "=" * 60)
-    print("🔄 STARTING DOCUMENT PROCESSING FOR QDRANT")
-    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")
-    print(f"☁️  Uploading documents to Qdrant Cloud collection: {COLLECTION_NAME}...")
     try:
         vector_store = Qdrant.from_documents(
             docs,
@@ -356,20 +332,18 @@ def build_or_update_qdrant_store(folder_path):
             collection_name=COLLECTION_NAME,
             force_recreate=True
         )
-        print(f"✅ Successfully created/updated Qdrant collection: {COLLECTION_NAME}")
+        print(f"✅ Successfully created/updated Qdrant collection: {COLLECTION_NAME} with {len(docs)} documents.")
         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
+# 9️⃣ Query QDRANT Function with Chart-Aware Re-ranking
 # -------------------------------
 def query_qdrant_store(query_text, k=3):
     if not QDRANT_API_KEY:
-        print("❌ QDRANT_API_KEY is missing. Cannot query database.")
         return []
         
     try:
@@ -383,7 +357,6 @@ def query_qdrant_store(query_text, k=3):
             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 []
@@ -395,33 +368,25 @@ def query_qdrant_store(query_text, k=3):
     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
-            # Check for visual analysis tags
-            if "Visual Analysis]" in doc.page_content or "bar chart" in doc.page_content.lower() or "line graph" in doc.page_content.lower():
+            if "Visual Analysis]" in doc.page_content or "bar chart" in doc.page_content.lower():
                 visual_content = doc.page_content.lower()
                 
-                # Apply high boost if query type matches content type
                 if 'bar chart' in query_text.lower() and 'bar chart' in visual_content:
                     boost += 1.0
                 elif 'pie chart' in query_text.lower() and 'pie chart' in visual_content:
                     boost += 1.0
-                elif ('line graph' in query_text.lower() or 'line chart' in query_text.lower()) and ('line graph' in visual_content or 'line chart' in visual_content):
-                    boost += 1.0
-                # Apply moderate boost if a general visual query matches any visual content
-                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', 'table']):
-                        boost += 0.5
+                elif any(kw in query_text.lower() for kw in ['chart', 'graph']) and any(kw in visual_content for kw in ['chart', 'graph', 'plot', 'diagram', 'table']):
+                    boost += 0.5
                 else:
                     boost += 0.2
             
-            # Note: Qdrant similarity search returns distance (lower is better), so we *subtract* the boost to make the score lower (better).
             adjusted_score = score - boost
             reranked_results.append((doc, adjusted_score, score))
             
-        reranked_results.sort(key=lambda x: x[1]) # Sort by adjusted 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]
@@ -438,12 +403,11 @@ def query_qdrant_store(query_text, k=3):
 
 
 # -------------------------------
-# 🆕 10️⃣ Answer Question using Llama 3.3 70B
+# 10️⃣ Answer Question using Llama 3.3 70B
 # -------------------------------
 def answer_question_with_llm(query_text, retrieved_docs, max_tokens=1000):
     if not groq_client:
         return "❌ Groq client not initialized. Cannot generate answer."
-    
     if not retrieved_docs:
         return "❌ No relevant documents found to answer your question."
         
@@ -454,12 +418,7 @@ def answer_question_with_llm(query_text, retrieved_docs, max_tokens=1000):
         metadata = doc['metadata']
         timestamp = metadata.get('upload_timestamp')
         
-        readable_time = "N/A"
-        if timestamp:
-            try:
-                readable_time = time.ctime(float(timestamp))
-            except (ValueError, TypeError):
-                readable_time = str(timestamp)
+        readable_time = time.ctime(float(timestamp)) if timestamp else "N/A"
 
         metadata_str = (
             f"Source: {source}\n"
@@ -481,8 +440,6 @@ def answer_question_with_llm(query_text, retrieved_docs, max_tokens=1000):
     
     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:
@@ -493,7 +450,6 @@ 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=[
@@ -507,36 +463,22 @@ ANSWER: (Provide a concise answer based *only* on the documents)"""
         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️⃣ Core RAG Response Function
+# 11️⃣ Core RAG Response Function
 # -------------------------------
 def get_rag_response(query_text: str, k: int = 3) -> Dict[str, Any]:
-    """
-    Core RAG pipeline: retrieves, generates, and formats response.
-    """
-    print("\n" + "=" * 80)
+    """Core RAG pipeline: retrieves, generates, and formats response."""
     print(f"❓ QUERY: {query_text}")
-    print("=" * 80)
-    
-    print("\n📚 Retrieving relevant documents from Qdrant...")
     retrieved_docs = query_qdrant_store(query_text, k=k)
     
     if not retrieved_docs:
-        print("❌ No relevant documents found.")
         return {
             "answer": "❌ No relevant documents found to answer your question. Please upload files first.",
             "sources": []
         }
     
-    print(f"\n📄 Retrieved {len(retrieved_docs)} relevant documents:")
-    for i, doc in enumerate(retrieved_docs, 1):
-        # We need the original score for display, which is `score` in the dict.
-        # The stored score might be the adjusted one if re-ranking occurred.
-        print(f"    {i}. {doc['source']} (Score: {doc['score']:.4f})") 
-
     answer = answer_question_with_llm(query_text, retrieved_docs)
     
     sources_list = [
@@ -548,19 +490,13 @@ def get_rag_response(query_text: str, k: int = 3) -> Dict[str, Any]:
         "sources": sources_list
     }
     
-    print("\n" + "=" * 80)
-    print(f"💡 ANSWER: {answer}")
-    print("=" * 80)
-    
     return response_data
 
 # -------------------------------
-# 🆕 12️⃣ Core File Processing Function
+# 12️⃣ Core File Processing & Qdrant Addition
 # -------------------------------
 def process_single_file(file_path: str, filename: str) -> Document:
-    """
-    Processes a single file from a file path and returns a LangChain Document.
-    """
+    """Processes a single file and returns a LangChain Document."""
     file_ext = filename.lower().split('.')[-1]
     text = ""
     
@@ -570,10 +506,7 @@ def process_single_file(file_path: str, filename: str) -> Document:
         text = extract_text_from_txt(file_path)
     elif file_ext == "pdf":
         text = extract_content_from_pdf(file_path)
-    else:
-        print(f"⏭️  Skipping unsupported file: {filename}")
-        return None
-
+    
     if text.strip():
         doc = Document(
             page_content=text,
@@ -584,26 +517,15 @@ def process_single_file(file_path: str, filename: str) -> Document:
                 "upload_timestamp": time.time()
             }
         )
-        print(f"✅ Processed {filename} ({len(text)} chars)")
         return doc
-    else:
-        print(f"⚠️  Skipping {filename} - no content extracted")
-        return None
+    return None
 
 def add_documents_to_qdrant(docs: List[Document]):
-    """
-    Adds a list of processed documents to the Qdrant cloud.
-    """
-    if not QDRANT_API_KEY:
-        print("❌ QDRANT_API_KEY is missing. Cannot add documents.")
-        return
-        
-    if not docs:
-        print("No documents to add.")
+    """Adds a list of processed documents to the Qdrant cloud."""
+    if not QDRANT_API_KEY or not docs:
         return
 
     try:
-        print(f"\n☁️  Connecting to Qdrant to add {len(docs)} new documents...")
         client = QdrantClient(url=QDRANT_URL, api_key=QDRANT_API_KEY)
         vector_store = Qdrant(
             client=client,
@@ -616,10 +538,10 @@ def add_documents_to_qdrant(docs: List[Document]):
         print(f"❌ Error adding documents to Qdrant: {e}")
         raise HTTPException(status_code=500, detail=f"Error updating vector store: {e}")
 
+
 # -------------------------------
-# 🚀 14. Gradio UI Setup (DEFINED BEFORE USE)
+# 🚀 14. Gradio UI Setup
 # -------------------------------
-
 def create_gradio_ui():
     """
     Creates the Gradio Blocks UI.
@@ -656,8 +578,7 @@ def create_gradio_ui():
         failed_count = 0
 
         for file_obj in file_list:
-            # Gradio passes the file as a temp file path (file_obj.name)
-            full_path = file_obj.name 
+            full_path = file_obj.name
             filename = os.path.basename(full_path)
             
             try:
@@ -679,10 +600,12 @@ def create_gradio_ui():
 
         return f"✅ Processing complete. Added {processed_count} files. Failed: {failed_count}."
 
+    # Create the Gradio UI using Blocks
     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=gradio_chat_response_func,
@@ -696,23 +619,28 @@ def create_gradio_ui():
                     ],
                 )
             
-            with gr.TabItem("Upload Documents"):
-                gr.Markdown("## 📤 Upload Files to Index")
-                gr.File(
-                    label="Upload Documents (PDF, JPG, PNG, TXT, MD)",
+            # --- UPLOAD TAB ---
+            with gr.TabItem("Upload New Documents"):
+                gr.Markdown("Upload new PDF, image, or text files to add them to the knowledge base.")
+                
+                # Define components
+                file_uploader = gr.File(
+                    label="Upload Documents",
                     file_count="multiple",
-                    file_types=[".pdf", ".jpg", ".jpeg", ".png", ".txt", ".md"],
-                    type="filepath",
-                    elem_id="file-upload"
-                ).then(
+                    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=gradio_upload_func,
-                    inputs=gr.Files(label="Files to Upload"),
-                    outputs=gr.Textbox(label="Status")
+                    inputs=[file_uploader],
+                    outputs=[status_output]
                 )
-                gr.Markdown("---")
-                gr.Markdown("💡 *Tip: Uploading files will take a minute as each page/image is processed using OCR and Vision models before being stored in the vector database.*")
-
-    return demo
+        
+        return demo
 
 
 # -------------------------------
@@ -738,60 +666,34 @@ app = FastAPI(title="🧠 Multimodal RAG API")
 
 @app.on_event("startup")
 def on_startup():
-    """
-    Checks keys and builds the initial database on server startup.
-    """
+    """Checks keys and builds the initial database on server startup."""
     print("🚀 FastAPI app starting up...")
     
-    # Check Groq API key
     if not os.environ.get("GROQ_API_KEY"):
         print("⚠️  WARNING: GROQ_API_KEY not set!")
-    else:
-        print("✅ Groq API Key found")
-        
-    # Check Qdrant API Key
     if not QDRANT_API_KEY:
         print("⚠️  WARNING: QDRANT_API_KEY not set! Database functions will fail.")
-    else:
-        print("✅ Qdrant API Key found")
-
-    print(f"✅ Vision Model: {VISION_MODEL}")
-    print(f"✅ LLM Model: {LLM_MODEL}\n")
 
-    # Rebuild the cloud database on startup
     folder = "data"
     if os.path.exists(folder):
-        print("\n" + "=" * 60)
-        print(f"🔄 Found 'data' folder, rebuilding Qdrant collection...")
-        print("=" * 60)
         build_or_update_qdrant_store(folder)
     else:
-        print("\n" + "=" * 60)
-        print(f"ℹ️  No 'data' folder found. Skipping initial build.")
-        print("   Database will be populated via the /upload endpoint.")
-        print("=" * 60)
+        print("ℹ️  No 'data' folder found. Skipping initial build.")
 
-# ---
-# 🚀 API Endpoints
-# ---
+# --- API Endpoints ---
 
 @app.post("/query/", response_model=QueryResponse)
 async def handle_query(request: QueryRequest):
-    """
-    Executes a RAG query against the vector database.
-    """
+    """Executes a RAG query against the vector database."""
     try:
         response_data = get_rag_response(request.query, request.k)
         return response_data
     except Exception as e:
-        print(f"❌ Error during query: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.post("/upload/", response_model=UploadResponse)
 async def handle_upload(files: List[UploadFile] = File(...)):
-    """
-    Uploads one or more files, processes them, and adds them to the vector DB.
-    """
+    """Uploads one or more files, processes them, and adds them to the vector DB."""
     if not QDRANT_API_KEY:
         raise HTTPException(status_code=500, detail="QDRANT_API_KEY is not set. Upload failed.")
         
@@ -802,16 +704,12 @@ async def handle_upload(files: List[UploadFile] = File(...)):
     for file in files:
         tmp_path = None
         try:
-            # 1. Save file to a temporary location
             with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{file.filename}") as tmp:
                 shutil.copyfileobj(file.file, tmp)
                 tmp_path = tmp.name
             
-            # 2. Process the single file
-            print(f"\nProcessing uploaded file: {file.filename}")
             doc = process_single_file(tmp_path, file.filename)
             
-            # 3. Collect processed document or log failure
             if doc:
                 docs_to_add.append(doc)
                 processed_files.append(file.filename)
@@ -819,25 +717,19 @@ async def handle_upload(files: List[UploadFile] = File(...)):
                 failed_files.append(file.filename)
 
         except Exception as e:
-            print(f"❌ Error processing file {file.filename}: {e}")
             failed_files.append(file.filename)
         
         finally:
-            # 4. Cleanup temp file
             if tmp_path and os.path.exists(tmp_path):
                 os.unlink(tmp_path)
-            # 5. Close the UploadFile stream
             file.file.close()
 
-    # 6. Add all successfully processed documents to Qdrant in a batch
     if docs_to_add:
         try:
             add_documents_to_qdrant(docs_to_add)
         except HTTPException:
-            # If batch upload failed, revert the success list to failures
             failed_files.extend(processed_files)
             processed_files = []
-            print(f"❌ Batch upload to Qdrant failed for {len(docs_to_add)} documents.")
         
     return {
         "message": f"Processing complete. Added {len(processed_files)} file(s) to the database.",
@@ -849,7 +741,6 @@ async def handle_upload(files: List[UploadFile] = File(...)):
 # 🚀 15. Create and Mount the Apps
 # -------------------------------
 
-# Define the root redirect and API info endpoints BEFORE mounting Gradio
 @app.get("/")
 def redirect_to_ui():
     """Redirect root to the Gradio UI"""
@@ -862,14 +753,8 @@ def api_info():
         "message": "Welcome to the Multimodal RAG API",
         "endpoints": {
             "ui": "/ui - Gradio interface",
-            "docs": "/docs - API documentation (Swagger UI)",
-            "redoc": "/redoc - Alternative API documentation",
             "query": "POST /query/ - Execute RAG queries",
             "upload": "POST /upload/ - Upload and process files"
-        },
-        "models": {
-            "vision_model": VISION_MODEL,
-            "llm_model": LLM_MODEL
         }
     }
 
@@ -877,7 +762,4 @@ def api_info():
 gradio_ui = create_gradio_ui()
 
 # Mount the Gradio UI at /ui path
-app = gr.mount_gradio_app(app, gradio_ui, path="/ui")
-
-# The application is now ready to be run by uvicorn:
-# uvicorn app:app --host 0.0.0.0 --port 7860
+app = gr.mount_gradio_app(app, gradio_ui, path="/ui")