Update app.py

app.py

@@ -1,12 +1,8 @@
 """
-app.py — Enterprise RAG System — Gradio UI entry point.
+app.py — Enterprise RAG System — Gradio 5 entry point.
 
-This is the file Hugging Face Spaces looks for first.
-It wires together all modules and builds the Gradio interface.
-
-Architecture: stateful single-user session using Gradio's gr.State()
-In production multi-user deployment, each session would have isolated
-vector store state (Redis or per-session FAISS index in memory).
+Wires together all pipeline modules and renders the three-panel UI.
+Uses gr.State() for per-session document isolation.
 """
 
 import os
@@ -21,138 +17,129 @@ from src.generation import generate_answer
 from src.evaluation import run_evaluation
 from src.observability import trace_rag_query, get_observability_status
 from src.metrics import record_query_metrics, get_metrics_summary
-from src.utils import format_retrieved_chunks, count_tokens_estimate
+from src.utils import format_retrieved_chunks
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("enterprise-rag.app")
 
+
 # ─────────────────────────────────────────────────────────────────────────────
-# DOCUMENT PROCESSING
+# PIPELINE FUNCTIONS
 # ─────────────────────────────────────────────────────────────────────────────
 
 def process_pdf(pdf_file, chunk_size: int, chunk_overlap: int):
     """
     Full ingestion pipeline: PDF → text → chunks → embeddings → FAISS index.
 
-    Returns:
-        status_message: shown in the UI
-        chunks_state: stored in gr.State for use during queries
-        index_state: FAISS index stored in gr.State
+    Gradio 5 passes uploaded files as a file path string directly.
     """
     if pdf_file is None:
-        return "⚠️ Please upload a PDF file.", None, None, "No document loaded."
+        return (
+            "⚠️ Please upload a PDF file first.",
+            None,
+            None,
+            "",
+        )
 
     try:
-        # Read file bytes
-        with open(pdf_file.name, "rb") as f:
+        # Gradio 5: pdf_file is a filepath string
+        file_path = pdf_file if isinstance(pdf_file, str) else pdf_file.name
+
+        with open(file_path, "rb") as f:
             file_bytes = f.read()
 
-        # Size validation
+        # Validate size
         valid, size_msg = validate_pdf(file_bytes)
         if not valid:
-            return f"❌ {size_msg}", None, None, "No document loaded."
+            return f"❌ {size_msg}", None, None, ""
 
-        # Step 1: Extract text
+        # Step 1 — Extract text
         extraction = extract_text_from_pdf(file_bytes)
         if not extraction["success"]:
-            return f"❌ {extraction['error']}", None, None, "Extraction failed."
+            return f"❌ {extraction['error']}", None, None, ""
 
         doc_text = extraction["text"]
         page_count = extraction["page_count"]
 
-        # Step 2: Chunk
+        # Step 2 — Chunk
         chunks = chunk_text(doc_text, int(chunk_size), int(chunk_overlap))
         if not chunks:
-            return "❌ No chunks created. Document may be too short.", None, None, ""
+            return "❌ No chunks created. Document may be too short or empty.", None, None, ""
 
         stats = chunk_statistics(chunks)
         chunk_texts = [c["text"] for c in chunks]
 
-        # Step 3: Embed
+        # Step 3 — Embed
         embeddings = embed_texts(chunk_texts)
 
-        # Step 4: Build FAISS index
+        # Step 4 — Build FAISS index
         faiss_index = build_faiss_index(embeddings)
 
         status = (
             f"✅ Document processed successfully!\n\n"
             f"📄 Pages: {page_count}\n"
             f"📦 Chunks: {stats['count']}\n"
-            f"📊 Avg chunk size: {stats['avg_tokens']} tokens\n"
+            f"📊 Avg chunk: {stats['avg_tokens']} tokens\n"
             f"🔢 Total tokens: {stats['total_tokens']}\n\n"
             f"Ready to answer questions."
         )
 
         doc_info = (
-            f"**Document loaded:** {os.path.basename(pdf_file.name)}\n"
+            f"**Loaded:** `{os.path.basename(file_path)}`  \n"
             f"Pages: {page_count} | Chunks: {stats['count']} | "
             f"Avg chunk: {stats['avg_tokens']} tokens"
         )
 
-        logger.info(f"PDF processed: {stats['count']} chunks, {stats['total_tokens']} total tokens")
+        logger.info(
+            f"PDF ready: {stats['count']} chunks, "
+            f"{stats['total_tokens']} total tokens"
+        )
         return status, chunks, faiss_index, doc_info
 
     except Exception as e:
         logger.error(f"PDF processing failed: {e}")
-        return f"❌ Processing error: {str(e)}", None, None, "Error"
+        return f"❌ Error: {str(e)}", None, None, ""
 
 
-# ───────���─────────────────────────────────────────────────────────────────────
-# QUERY PIPELINE
-# ─────────────────────────────────────────────────────────────────────────────
-
-def answer_question(
-    query: str,
-    chunks_state,
-    index_state,
-    top_k: int,
-):
+def answer_question(query: str, chunks_state, index_state, top_k: int):
     """
-    Full RAG query pipeline: query → embed → retrieve → generate → evaluate → trace.
-
-    Returns:
-        answer_text: shown in the center panel
-        chunks_display: retrieved chunks for the right panel
-        metrics_display: latency/token metrics for the right panel
-        eval_display: evaluation scores for the right panel
-        obs_display: observability status
+    Full RAG query pipeline:
+    embed query → retrieve → generate → evaluate → trace → display.
     """
-    empty_right = ("", "", "", "")
-
     if not query or not query.strip():
-        return "⚠️ Please enter a question.", *empty_right
+        return "⚠️ Please enter a question.", "", "", "", ""
 
     if chunks_state is None or index_state is None:
         return (
             "⚠️ No document loaded. Please upload a PDF first.",
-            *empty_right,
+            "", "", "", "",
         )
 
+    # Normalize chunks to plain text strings
     chunk_texts = [
-        c["text"] if isinstance(c, dict) else c for c in chunks_state
+        c["text"] if isinstance(c, dict) else c
+        for c in chunks_state
     ]
 
     try:
-        # Step 1: Retrieve relevant chunks
+        # Step 1 — Retrieve
         retrieval = retrieve_relevant_chunks(
             query=query,
             chunks=chunk_texts,
             faiss_index=index_state,
             top_k=int(top_k),
         )
-
         retrieved_chunks = retrieval["retrieved_chunks"]
         scores = retrieval["scores"]
         is_relevant = retrieval["is_relevant"]
 
-        # Step 2: Generate grounded answer
+        # Step 2 — Generate
         generation = generate_answer(
             query=query,
             context_chunks=retrieved_chunks,
             scores=scores,
             is_relevant=is_relevant,
         )
-
         answer = generation["answer"]
         prompt_tokens = generation["prompt_tokens"]
         response_tokens = generation["response_tokens"]
@@ -160,7 +147,7 @@ def answer_question(
         model_used = generation.get("model_used", "unknown")
         fallback_used = generation["fallback_used"]
 
-        # Step 3: Evaluate
+        # Step 3 — Evaluate
         eval_scores = run_evaluation(
             query=query,
             answer=answer,
@@ -168,7 +155,7 @@ def answer_question(
             retrieval_scores=scores,
         )
 
-        # Step 4: Record metrics
+        # Step 4 — Record metrics
         record_query_metrics(
             retrieval_latency_ms=retrieval["retrieval_latency_ms"],
             generation_latency_ms=gen_latency,
@@ -178,7 +165,7 @@ def answer_question(
             fallback_used=fallback_used,
         )
 
-        # Step 5: Trace to Langfuse + local log
+        # Step 5 — Trace
         trace_rag_query(
             query=query,
             answer=answer,
@@ -193,35 +180,30 @@ def answer_question(
             fallback_used=fallback_used,
         )
 
-        # ── Format outputs for Gradio panels ──────────────────────────────
+        # ── Format right-panel outputs ─────────────────────────────────────
 
-        # Retrieved chunks panel
-        retrieval_warning = f"\n\n⚠️ {retrieval['warning']}" if retrieval.get("warning") else ""
-        chunks_display = (
-            format_retrieved_chunks(retrieved_chunks, scores) + retrieval_warning
-        )
+        warning_text = f"\n\n⚠️ {retrieval['warning']}" if retrieval.get("warning") else ""
+        chunks_display = format_retrieved_chunks(retrieved_chunks, scores) + warning_text
 
-        # Metrics panel
         metrics_display = get_metrics_summary()
 
-        # Evaluation panel
-        eval_display = f"""**🧪 Answer Quality Scores**
-- Faithfulness: `{eval_scores['faithfulness']:.3f}` *(grounded in context)*
-- Answer Relevance: `{eval_scores['answer_relevance']:.3f}` *(answers the question)*
-- Context Precision: `{eval_scores['context_precision']:.3f}` *(retrieval quality)*
-- **Overall: `{eval_scores['overall']:.3f}`** — {eval_scores['quality_label']}
-
-{eval_scores.get('note', '')}"""
+        eval_display = (
+            f"**Answer Quality Scores**\n\n"
+            f"- Faithfulness: `{eval_scores['faithfulness']:.3f}` — grounded in context\n"
+            f"- Answer Relevance: `{eval_scores['answer_relevance']:.3f}` — answers the question\n"
+            f"- Context Precision: `{eval_scores['context_precision']:.3f}` — retrieval quality\n"
+            f"- **Overall: `{eval_scores['overall']:.3f}`** {eval_scores['quality_label']}\n\n"
+            f"{eval_scores.get('note', '')}"
+        )
 
-        # Observability panel
         obs_display = (
             f"{get_observability_status()}\n\n"
-            f"**Last trace:**\n"
-            f"• Model: `{model_used}`\n"
-            f"• Retrieval: `{retrieval['retrieval_latency_ms']:.0f}ms`\n"
-            f"• Generation: `{gen_latency:.0f}ms`\n"
-            f"• Tokens: `{prompt_tokens + response_tokens}`\n"
-            f"• Fallback: `{'Yes' if fallback_used else 'No'}`"
+            f"**Last trace**\n"
+            f"- Model: `{model_used}`\n"
+            f"- Retrieval: `{retrieval['retrieval_latency_ms']:.0f}ms`\n"
+            f"- Generation: `{gen_latency:.0f}ms`\n"
+            f"- Total tokens: `{prompt_tokens + response_tokens}`\n"
+            f"- Fallback used: `{'Yes' if fallback_used else 'No'}`"
         )
 
         return answer, chunks_display, metrics_display, eval_display, obs_display
@@ -232,65 +214,64 @@ def answer_question(
 
 
 # ─────────────────────────────────────────────────────────────────────────────
-# GRADIO UI
+# GRADIO 5 UI
 # ─────────────────────────────────────────────────────────────────────────────
 
-CSS = """
-.panel-header { font-size: 13px; font-weight: 600; color: #666; }
-.answer-box textarea { font-size: 15px !important; line-height: 1.7 !important; }
-footer { display: none !important; }
-"""
-
 with gr.Blocks(
     title="Enterprise RAG System",
     theme=gr.themes.Soft(primary_hue="blue"),
-    css=CSS,
 ) as demo:
 
-    # ── Session state (per-user, isolated) ──────────────────────────────────
+    # Per-session state — each user gets isolated chunks and FAISS index
     chunks_state = gr.State(None)
     index_state = gr.State(None)
 
-    # ── Header ───────────────────────────────────────────────────────────────
     gr.Markdown(
-        """# 🏢 Enterprise Knowledge Retrieval System
-        **RAG pipeline with evaluation & observability** | Mistral-7B · FAISS · Sentence-Transformers
-        """,
+        "# 🏢 Enterprise Knowledge Retrieval System\n"
+        "**RAG pipeline · Groq LLM · FAISS · Evaluation · Observability**"
     )
 
     with gr.Row():
 
-        # ── LEFT PANEL: Document Upload ───────────────────────────────────
-        with gr.Column(scale=1, min_width=280):
-            gr.Markdown("### 📁 Document Upload", elem_classes="panel-header")
+        # ── LEFT: Document Upload ─────────────────────────────────────────
+        with gr.Column(scale=1, min_width=260):
+            gr.Markdown("### 📁 Document Upload")
 
             pdf_input = gr.File(
                 label="Upload PDF",
                 file_types=[".pdf"],
-                type="filepath",
             )
 
             with gr.Accordion("⚙️ Chunking Settings", open=False):
                 chunk_size_slider = gr.Slider(
-                    minimum=128, maximum=1024, value=512, step=64,
+                    minimum=128,
+                    maximum=1024,
+                    value=512,
+                    step=64,
                     label="Chunk Size (tokens)",
-                    info="Larger = more context per chunk, but noisier embeddings",
+                    info="Larger = more context per chunk",
                 )
                 chunk_overlap_slider = gr.Slider(
-                    minimum=0, maximum=256, value=64, step=32,
+                    minimum=0,
+                    maximum=256,
+                    value=64,
+                    step=32,
                     label="Chunk Overlap (tokens)",
-                    info="Overlap prevents answer loss at chunk boundaries",
+                    info="Prevents answer loss at boundaries",
                 )
                 top_k_slider = gr.Slider(
-                    minimum=1, maximum=10, value=5, step=1,
+                    minimum=1,
+                    maximum=10,
+                    value=5,
+                    step=1,
                     label="Top-K Retrieval",
-                    info="Number of chunks to retrieve per query",
+                    info="Chunks returned per query",
                 )
 
             process_btn = gr.Button("📥 Process Document", variant="primary")
 
             doc_status = gr.Textbox(
-                label="Processing Status",
+                label="Status",
                 lines=6,
                 interactive=False,
                 value="No document loaded.",
@@ -298,9 +279,9 @@ with gr.Blocks(
 
             doc_info_md = gr.Markdown("")
 
-        # ── CENTER PANEL: Query & Answer ─────────────────────────────────
-        with gr.Column(scale=2, min_width=400):
-            gr.Markdown("### 💬 Query Interface", elem_classes="panel-header")
+        # ── CENTER: Query & Answer ────────────────────────────────────────
+        with gr.Column(scale=2, min_width=380):
+            gr.Markdown("### 💬 Ask Questions")
 
             query_input = gr.Textbox(
                 label="Your Question",
@@ -311,46 +292,44 @@ with gr.Blocks(
             ask_btn = gr.Button("🔍 Get Answer", variant="primary", size="lg")
 
             answer_output = gr.Markdown(
-                label="AI Answer",
-                value="*Upload a document and ask a question to get started.*",
-                elem_classes="answer-box",
+                value="*Upload a document and ask a question to get started.*"
             )
 
             gr.Markdown(
-                """---
-**Sample Questions** (after uploading a relevant document):
-- *What are the main topics covered in this document?*
-- *Summarize the key findings.*
-- *What does the document say about [specific topic]?*
-"""
+                "---\n"
+                "**Example questions after uploading:**\n"
+                "- What are the main topics covered?\n"
+                "- Summarize the key findings.\n"
+                "- What risks or challenges are mentioned?\n"
+                "- What are the specific numbers or statistics?"
             )
 
-        # ── RIGHT PANEL: Retrieval + Metrics + Evaluation ─────────────────
-        with gr.Column(scale=1, min_width=300):
-            gr.Markdown("### 📊 Observability Panel", elem_classes="panel-header")
+        # ── RIGHT: Observability Panel ────────────────────────────────────
+        with gr.Column(scale=1, min_width=280):
+            gr.Markdown("### 📊 Observability")
 
             with gr.Tabs():
-                with gr.Tab("📄 Retrieved Chunks"):
+                with gr.Tab("📄 Chunks"):
                     chunks_output = gr.Markdown(
-                        value="*Retrieved context will appear here after a query.*"
+                        value="*Retrieved context appears here after a query.*"
                     )
 
                 with gr.Tab("📈 Metrics"):
                     metrics_output = gr.Markdown(
-                        value="*Metrics will appear after the first query.*"
+                        value="*Metrics appear after the first query.*"
                     )
 
                 with gr.Tab("🧪 Evaluation"):
                     eval_output = gr.Markdown(
-                        value="*Evaluation scores will appear after a query.*"
+                        value="*Evaluation scores appear after a query.*"
                     )
 
                 with gr.Tab("🔭 Traces"):
                     obs_output = gr.Markdown(
-                        value=f"{get_observability_status()}"
+                        value=get_observability_status()
                     )
 
-    # ── Event Handlers ───────────────────────────────────────────────────────
+    # ── Event handlers ────────────────────────────────────────────────────
 
     process_btn.click(
         fn=process_pdf,
@@ -364,7 +343,6 @@ with gr.Blocks(
         outputs=[answer_output, chunks_output, metrics_output, eval_output, obs_output],
     )
 
-    # Allow pressing Enter in the query box
     query_input.submit(
         fn=answer_question,
         inputs=[query_input, chunks_state, index_state, top_k_slider],