DAI-1839

.gitignore

@@ -162,4 +162,5 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 .idea/
 
-.DS_Store
+.DS_Store
+.vscode/

app.py

@@ -12,13 +12,14 @@ API_BASE_URL = os.environ.get("BRAIN_API_BASE_URL", "http://127.0.0.1:8000")
 CALL_QUALITY_API_URL = f"{API_BASE_URL}/api/v1/call-quality/"
 EMOTION_ANALYSIS_API_URL = f"{API_BASE_URL}/api/v1/emotion-analysis/"
 KB_IMPROVEMENTS_API_URL = f"{API_BASE_URL}/api/v1/kb-improvements/"
+EVALUATION_API_URL = f"{API_BASE_URL}/api/v1/evaluation/"
 
 BRAIN_API_TOKEN = os.environ.get("BRAIN_API_TOKEN")
 
 st.set_page_config(
     page_title="Call Quality Analysis & KB Management",
     layout="wide",
-    initial_sidebar_state="expanded"
+    initial_sidebar_state="expanded",
 )
 
 APP_USERNAME = os.environ.get("USERNAME")
@@ -30,6 +31,7 @@ if "logged_in" not in st.session_state:
 if "current_page" not in st.session_state:
     st.session_state.current_page = "call_analysis"
 
+
 def login_form():
     with st.form("login"):
         st.subheader("🔐 Login")
@@ -45,12 +47,14 @@ def login_form():
             else:
                 st.error("❌ Invalid username or password.")
 
+
 if not st.session_state.logged_in:
     login_form()
     st.stop()
 
 # --- Enhanced CSS Styling ---
-st.markdown("""
+st.markdown(
+    """
 <style>
     /* Base Card Styles */
     .metric-card, .recommendation, .finding, .kb-improvement, .prompt-improvement,
@@ -251,8 +255,28 @@ st.markdown("""
         background-color: #4e8df5;
         color: white;
     }
+    
+    /* Assistant Leaderboard Styles */
+    .leaderboard-card {
+        background-color: #f8f9fa;
+        border-radius: 10px;
+        padding: 15px;
+        margin-bottom: 10px;
+        border-left: 5px solid #4e8df5;
+    }
+    .leaderboard-rank {
+        font-size: 24px;
+        font-weight: bold;
+        color: #4e8df5;
+    }
+    .hallucination-high { border-left-color: #F44336; }
+    .hallucination-medium { border-left-color: #FFC107; }
+    .hallucination-low { border-left-color: #4CAF50; }
 </style>
-""", unsafe_allow_html=True)
+""",
+    unsafe_allow_html=True,
+)
+
 
 # --- KB Improvements API Functions ---
 def fetch_pending_kb_improvements(limit=50, skip=0):
@@ -266,17 +290,20 @@ def fetch_pending_kb_improvements(limit=50, skip=0):
         response = requests.get(
             f"{KB_IMPROVEMENTS_API_URL}audits",
             headers=headers,
-            params={"limit": limit, "skip": skip}
+            params={"limit": limit, "skip": skip},
         )
         response.raise_for_status()
         return response.json()
     except requests.exceptions.HTTPError as e:
-        st.error(f"❌ KB Improvements API Error: {e.response.status_code} - {e.response.text}")
+        st.error(
+            f"❌ KB Improvements API Error: {e.response.status_code} - {e.response.text}"
+        )
         return None
     except requests.exceptions.RequestException as e:
         st.error(f"⚠️ KB Improvements API request failed: {e}")
         return None
 
+
 def fetch_audit_kb_improvements(call_id):
     """Fetch specific audit with KB improvements."""
     if not BRAIN_API_TOKEN:
@@ -286,8 +313,7 @@ def fetch_audit_kb_improvements(call_id):
     headers = {"Authorization": f"Bearer {BRAIN_API_TOKEN}"}
     try:
         response = requests.get(
-            f"{KB_IMPROVEMENTS_API_URL}audits/{call_id}",
-            headers=headers
+            f"{KB_IMPROVEMENTS_API_URL}audits/{call_id}", headers=headers
         )
         response.raise_for_status()
         return response.json()
@@ -295,13 +321,18 @@ def fetch_audit_kb_improvements(call_id):
         if e.response.status_code == 404:
             st.error(f"❌ Audit not found for call ID: {call_id}")
         else:
-            st.error(f"❌ KB Improvements API Error: {e.response.status_code} - {e.response.text}")
+            st.error(
+                f"❌ KB Improvements API Error: {e.response.status_code} - {e.response.text}"
+            )
         return None
     except requests.exceptions.RequestException as e:
         st.error(f"⚠️ KB Improvements API request failed: {e}")
         return None
 
-def submit_kb_review(call_id, improvement_index, action, edited_content=None, review_notes=None):
+
+def submit_kb_review(
+    call_id, improvement_index, action, edited_content=None, review_notes=None
+):
     """Submit KB improvement review."""
     if not BRAIN_API_TOKEN:
         st.error("🚨 BRAIN_API_TOKEN environment variable is not set.")
@@ -313,24 +344,25 @@ def submit_kb_review(call_id, improvement_index, action, edited_content=None, re
         "improvement_index": improvement_index,
         "action": action,
         "edited_content": edited_content,
-        "review_notes": review_notes
+        "review_notes": review_notes,
     }
 
     try:
         response = requests.post(
-            f"{KB_IMPROVEMENTS_API_URL}review",
-            headers=headers,
-            json=payload
+            f"{KB_IMPROVEMENTS_API_URL}review", headers=headers, json=payload
         )
         response.raise_for_status()
         return response.json()
     except requests.exceptions.HTTPError as e:
-        st.error(f"❌ KB Review API Error: {e.response.status_code} - {e.response.text}")
+        st.error(
+            f"❌ KB Review API Error: {e.response.status_code} - {e.response.text}"
+        )
         return None
     except requests.exceptions.RequestException as e:
         st.error(f"⚠️ KB Review API request failed: {e}")
         return None
 
+
 def fetch_kb_stats():
     """Fetch KB improvement statistics."""
     if not BRAIN_API_TOKEN:
@@ -339,10 +371,7 @@ def fetch_kb_stats():
 
     headers = {"Authorization": f"Bearer {BRAIN_API_TOKEN}"}
     try:
-        response = requests.get(
-            f"{KB_IMPROVEMENTS_API_URL}stats",
-            headers=headers
-        )
+        response = requests.get(f"{KB_IMPROVEMENTS_API_URL}stats", headers=headers)
         response.raise_for_status()
         return response.json()
     except requests.exceptions.HTTPError as e:
@@ -352,6 +381,7 @@ def fetch_kb_stats():
         st.error(f"⚠️ KB Stats API request failed: {e}")
         return None
 
+
 def fetch_pending_count():
     """Fetch count of pending KB improvements."""
     if not BRAIN_API_TOKEN:
@@ -360,14 +390,156 @@ def fetch_pending_count():
     headers = {"Authorization": f"Bearer {BRAIN_API_TOKEN}"}
     try:
         response = requests.get(
-            f"{KB_IMPROVEMENTS_API_URL}pending-count",
-            headers=headers
+            f"{KB_IMPROVEMENTS_API_URL}pending-count", headers=headers
         )
         response.raise_for_status()
         return response.json().get("pending_count", 0)
     except:
         return 0
 
+
+# --- Hallucination Evaluation API Functions ---
+def fetch_eval_aggregates(assistant_id=None, topic=None, limit=50):
+    """Fetch hallucination aggregates."""
+    if not BRAIN_API_TOKEN:
+        st.error("🚨 BRAIN_API_TOKEN environment variable is not set.")
+        return None
+
+    headers = {"Authorization": f"Bearer {BRAIN_API_TOKEN}"}
+    params = {"limit": limit}
+    if assistant_id:
+        params["assistant_id"] = assistant_id
+    if topic:
+        params["topic"] = topic
+
+    try:
+        response = requests.get(
+            f"{EVALUATION_API_URL}aggregates", headers=headers, params=params
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.HTTPError as e:
+        st.error(
+            f"❌ Hallucination Aggregates API Error: {e.response.status_code} - {e.response.text}"
+        )
+        return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"⚠️ Hallucination Aggregates API request failed: {e}")
+        return None
+
+
+def fetch_top_hallucinators(assistant_id=None, topic=None, limit=10):
+    """Fetch top hallucinators."""
+    if not BRAIN_API_TOKEN:
+        st.error("🚨 BRAIN_API_TOKEN environment variable is not set.")
+        return None
+
+    headers = {"Authorization": f"Bearer {BRAIN_API_TOKEN}"}
+    params = {"limit": limit}
+    if assistant_id:
+        params["assistant_id"] = assistant_id
+    if topic:
+        params["topic"] = topic
+
+    try:
+        response = requests.get(
+            f"{EVALUATION_API_URL}top-hallucinators", headers=headers, params=params
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.HTTPError as e:
+        st.error(
+            f"❌ Top Hallucinators API Error: {e.response.status_code} - {e.response.text}"
+        )
+        return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"⚠️ Top Hallucinators API request failed: {e}")
+        return None
+
+
+def fetch_assistant_leaderboard(topic=None, limit=20):
+    """Fetch assistant leaderboard with hallucination metrics."""
+    if not BRAIN_API_TOKEN:
+        st.error("🚨 BRAIN_API_TOKEN environment variable is not set.")
+        return None
+
+    headers = {"Authorization": f"Bearer {BRAIN_API_TOKEN}"}
+    params = {"limit": limit}
+    if topic:
+        params["topic"] = topic
+
+    try:
+        response = requests.get(
+            f"{EVALUATION_API_URL}assistant-leaderboard", headers=headers, params=params
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.HTTPError as e:
+        st.error(
+            f"❌ Assistant Leaderboard API Error: {e.response.status_code} - {e.response.text}"
+        )
+        return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"⚠️ Assistant Leaderboard API request failed: {e}")
+        return None
+
+
+def fetch_sample_unsupported(assistant_id=None, topic=None, limit=20):
+    """Fetch sample of unsupported claims."""
+    if not BRAIN_API_TOKEN:
+        st.error("🚨 BRAIN_API_TOKEN environment variable is not set.")
+        return None
+
+    headers = {"Authorization": f"Bearer {BRAIN_API_TOKEN}"}
+    params = {"limit": limit}
+    if assistant_id:
+        params["assistant_id"] = assistant_id
+    if topic:
+        params["topic"] = topic
+
+    try:
+        response = requests.get(
+            f"{EVALUATION_API_URL}sample-unsupported", headers=headers, params=params
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.HTTPError as e:
+        st.error(
+            f"❌ Sample Unsupported API Error: {e.response.status_code} - {e.response.text}"
+        )
+        return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"⚠️ Sample Unsupported API request failed: {e}")
+        return None
+
+
+def submit_annotation(run_id, claim_idx, label, assistant_id=None):
+    """Submit annotation for a claim."""
+    if not BRAIN_API_TOKEN:
+        st.error("🚨 BRAIN_API_TOKEN environment variable is not set.")
+        return None
+
+    headers = {"Authorization": f"Bearer {BRAIN_API_TOKEN}"}
+    payload = {"run_id": run_id, "claim_idx": claim_idx, "label": label}
+    if assistant_id:
+        payload["assistant_id"] = assistant_id
+
+    try:
+        response = requests.post(
+            f"{EVALUATION_API_URL}annotate", headers=headers, json=payload
+        )
+        response.raise_for_status()
+        return True
+    except requests.exceptions.HTTPError as e:
+        st.error(
+            f"❌ Annotation API Error: {e.response.status_code} - {e.response.text}"
+        )
+        return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"⚠️ Annotation API request failed: {e}")
+        return None
+
+
 # --- KB Improvements UI Functions ---
 def display_kb_stats():
     """Display KB improvement statistics."""
@@ -381,36 +553,49 @@ def display_kb_stats():
     col1, col2, col3, col4 = st.columns(4)
 
     with col1:
-        st.markdown(f"""
+        st.markdown(
+            f"""
         <div class="kb-stats-card">
-            <h3>{stats.get('total_audits_with_improvements', 0)}</h3>
+            <h3>{stats.get("total_audits_with_improvements", 0)}</h3>
             <p>Total Audits with Improvements</p>
         </div>
-        """, unsafe_allow_html=True)
+        """,
+            unsafe_allow_html=True,
+        )
 
     with col2:
-        st.markdown(f"""
+        st.markdown(
+            f"""
         <div class="kb-stats-card">
-            <h3>{stats.get('total_chunks_updated', 0)}</h3>
+            <h3>{stats.get("total_chunks_updated", 0)}</h3>
             <p>Chunks Updated</p>
         </div>
-        """, unsafe_allow_html=True)
+        """,
+            unsafe_allow_html=True,
+        )
 
     with col3:
-        st.markdown(f"""
+        st.markdown(
+            f"""
         <div class="kb-stats-card">
-            <h3>{stats.get('approval_rate', 0):.1%}</h3>
+            <h3>{stats.get("approval_rate", 0):.1%}</h3>
             <p>Approval Rate</p>
         </div>
-        """, unsafe_allow_html=True)
+        """,
+            unsafe_allow_html=True,
+        )
 
     with col4:
-        st.markdown(f"""
+        st.markdown(
+            f"""
         <div class="kb-stats-card">
-            <h3>{stats.get('avg_time_to_update_hours', 0):.1f}h</h3>
+            <h3>{stats.get("avg_time_to_update_hours", 0):.1f}h</h3>
             <p>Avg. Time to Update</p>
         </div>
-        """, unsafe_allow_html=True)
+        """,
+            unsafe_allow_html=True,
+        )
+
 
 def display_kb_improvements_list():
     """Display list of pending KB improvements."""
@@ -428,22 +613,27 @@ def display_kb_improvements_list():
 
         if isinstance(created_at, str):
             try:
-                created_date = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+                created_date = datetime.fromisoformat(created_at.replace("Z", "+00:00"))
                 formatted_date = created_date.strftime("%Y-%m-%d %H:%M")
             except:
                 formatted_date = created_at
         else:
             formatted_date = str(created_at)
 
-        with st.expander(f"📞 Call ID: {call_id} | {len(kb_improvements)} improvements | {formatted_date}"):
+        with st.expander(
+            f"📞 Call ID: {call_id} | {len(kb_improvements)} improvements | {formatted_date}"
+        ):
             st.markdown(f"**Summary:** {audit.get('summary', 'No summary available')}")
-            st.markdown(f"**Resolution Status:** {audit.get('resolution_status', 'Unknown')}")
+            st.markdown(
+                f"**Resolution Status:** {audit.get('resolution_status', 'Unknown')}"
+            )
 
             if st.button(f"Review Improvements for {call_id}", key=f"review_{call_id}"):
                 st.session_state.current_page = "kb_review"
                 st.session_state.selected_call_id = call_id
                 st.rerun()
 
+
 def display_kb_review_interface(call_id):
     """Display KB improvement review interface for a specific call."""
     st.markdown(f"## 🔍 Reviewing KB Improvements for Call: {call_id}")
@@ -462,15 +652,23 @@ def display_kb_review_interface(call_id):
         st.info("No KB improvements found for this call.")
         return
 
-    st.markdown(f"**Call Summary:** {audit_data.get('summary', 'No summary available')}")
-    st.markdown(f"**Resolution Status:** {audit_data.get('resolution_status', 'Unknown')}")
+    st.markdown(
+        f"**Call Summary:** {audit_data.get('summary', 'No summary available')}"
+    )
+    st.markdown(
+        f"**Resolution Status:** {audit_data.get('resolution_status', 'Unknown')}"
+    )
     st.markdown("---")
 
     for idx, improvement in enumerate(kb_improvements):
         chunk_id = improvement.get("chunk_id", "Unknown")
         issue = improvement.get("issue", "No issue description")
-        suggested_improvement = improvement.get("suggested_improvement", "No suggestion provided")
-        current_content = improvement.get("current_kb_content", "No current content available")
+        suggested_improvement = improvement.get(
+            "suggested_improvement", "No suggestion provided"
+        )
+        current_content = improvement.get(
+            "current_kb_content", "No current content available"
+        )
         rationale = improvement.get("rationale", "No rationale provided")
 
         # Check if already processed
@@ -484,36 +682,47 @@ def display_kb_review_interface(call_id):
             elif processed_action == "reject":
                 status_badge = '<span class="kb-rejected-badge">❌ Rejected</span>'
             elif processed_action == "edit":
-                status_badge = '<span class="kb-processed-badge">✏️ Edited & Applied</span>'
+                status_badge = (
+                    '<span class="kb-processed-badge">✏️ Edited & Applied</span>'
+                )
         else:
             status_badge = '<span class="kb-pending-badge">⏳ Pending Review</span>'
 
-        st.markdown(f"""
+        st.markdown(
+            f"""
         <div class="kb-review-card">
             <h4>Improvement #{idx + 1} - Chunk ID: {chunk_id} {status_badge}</h4>
             <p><strong>Issue Identified:</strong> {issue}</p>
             <p><strong>Rationale:</strong> {rationale}</p>
         </div>
-        """, unsafe_allow_html=True)
+        """,
+            unsafe_allow_html=True,
+        )
 
         if not is_processed:
             col1, col2 = st.columns(2)
 
             with col1:
                 st.markdown("### 📄 Current Content")
-                st.markdown(f"""
+                st.markdown(
+                    f"""
                 <div class="kb-current-content">
                     {current_content}
                 </div>
-                """, unsafe_allow_html=True)
+                """,
+                    unsafe_allow_html=True,
+                )
 
             with col2:
                 st.markdown("### 💡 Suggested Improvement")
-                st.markdown(f"""
+                st.markdown(
+                    f"""
                 <div class="kb-suggested-content">
                     {suggested_improvement}
                 </div>
-                """, unsafe_allow_html=True)
+                """,
+                    unsafe_allow_html=True,
+                )
 
             # Review interface
             st.markdown("### 🎯 Review Actions")
@@ -525,20 +734,28 @@ def display_kb_review_interface(call_id):
                     with st.spinner("Approving improvement..."):
                         result = submit_kb_review(call_id, idx, "approve")
                         if result and result.get("success"):
-                            st.success(f"✅ Improvement approved! {result.get('message', '')}")
+                            st.success(
+                                f"✅ Improvement approved! {result.get('message', '')}"
+                            )
                             st.rerun()
                         else:
-                            st.error(f"❌ Failed to approve: {result.get('message', 'Unknown error') if result else 'No response'}")
+                            st.error(
+                                f"❌ Failed to approve: {result.get('message', 'Unknown error') if result else 'No response'}"
+                            )
 
             with col_reject:
                 if st.button(f"❌ Reject", key=f"reject_{call_id}_{idx}"):
                     with st.spinner("Rejecting improvement..."):
                         result = submit_kb_review(call_id, idx, "reject")
                         if result and result.get("success"):
-                            st.success(f"✅ Improvement rejected! {result.get('message', '')}")
+                            st.success(
+                                f"✅ Improvement rejected! {result.get('message', '')}"
+                            )
                             st.rerun()
                         else:
-                            st.error(f"❌ Failed to reject: {result.get('message', 'Unknown error') if result else 'No response'}")
+                            st.error(
+                                f"❌ Failed to reject: {result.get('message', 'Unknown error') if result else 'No response'}"
+                            )
 
             with col_edit:
                 with st.expander("✏️ Edit & Apply"):
@@ -546,47 +763,62 @@ def display_kb_review_interface(call_id):
                         "Edit the suggested content:",
                         value=suggested_improvement,
                         key=f"edit_content_{call_id}_{idx}",
-                        height=200
+                        height=200,
                     )
 
                     review_notes = st.text_input(
-                        "Review notes (optional):",
-                        key=f"review_notes_{call_id}_{idx}"
+                        "Review notes (optional):", key=f"review_notes_{call_id}_{idx}"
                     )
 
-                    if st.button(f"Apply Edited Content", key=f"apply_edit_{call_id}_{idx}"):
+                    if st.button(
+                        f"Apply Edited Content", key=f"apply_edit_{call_id}_{idx}"
+                    ):
                         if edited_content.strip():
                             with st.spinner("Applying edited content..."):
-                                result = submit_kb_review(call_id, idx, "edit", edited_content, review_notes)
+                                result = submit_kb_review(
+                                    call_id, idx, "edit", edited_content, review_notes
+                                )
                                 if result and result.get("success"):
-                                    st.success(f"✅ Edited content applied! {result.get('message', '')}")
+                                    st.success(
+                                        f"✅ Edited content applied! {result.get('message', '')}"
+                                    )
                                     st.rerun()
                                 else:
-                                    st.error(f"❌ Failed to apply edit: {result.get('message', 'Unknown error') if result else 'No response'}")
+                                    st.error(
+                                        f"❌ Failed to apply edit: {result.get('message', 'Unknown error') if result else 'No response'}"
+                                    )
                         else:
                             st.warning("⚠️ Please provide edited content.")
         else:
             # Show processed status
-            st.info(f"✅ This improvement has been {processed_action}ed and is no longer pending review.")
+            st.info(
+                f"✅ This improvement has been {processed_action}ed and is no longer pending review."
+            )
 
         st.markdown("---")
 
+
 # --- Original Call Analysis Functions (keeping all existing functionality) ---
 def fetch_emotion_analysis(call_id, num_chunks):
     """Fetches emotion analysis results from the API."""
     headers = {"Authorization": f"Bearer {BRAIN_API_TOKEN}"}
     payload = {"call_id": call_id, "num_chunks": num_chunks}
     try:
-        response = requests.post(EMOTION_ANALYSIS_API_URL, json=payload, headers=headers)
+        response = requests.post(
+            EMOTION_ANALYSIS_API_URL, json=payload, headers=headers
+        )
         response.raise_for_status()
         return response.json()
     except requests.exceptions.HTTPError as e:
-        st.error(f"❌ Emotion Analysis API Error: {e.response.status_code} - {e.response.text}")
+        st.error(
+            f"❌ Emotion Analysis API Error: {e.response.status_code} - {e.response.text}"
+        )
         return None
     except requests.exceptions.RequestException as e:
         st.error(f"⚠️ Emotion Analysis API request failed: {e}")
         return None
 
+
 def fetch_call_analysis(call_id, custom_prompt, analysis_focus, emotion_results=None):
     """Fetches call quality analysis data from the API."""
     if not call_id:
@@ -603,33 +835,46 @@ def fetch_call_analysis(call_id, custom_prompt, analysis_focus, emotion_results=
         payload = {
             "call_id": call_id,
             "custom_prompt": custom_prompt if custom_prompt else "",
-            "analysis_focus": analysis_focus
+            "analysis_focus": analysis_focus,
         }
         if emotion_results:
             payload["emotion_analysis_result"] = emotion_results
             st.info("Including emotion analysis results in call quality assessment.")
 
         try:
-            response = requests.post(CALL_QUALITY_API_URL, json=payload, headers=headers)
+            response = requests.post(
+                CALL_QUALITY_API_URL, json=payload, headers=headers
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.HTTPError as e:
-            st.error(f"❌ Call Quality API Error: {e.response.status_code} - {e.response.text}")
+            st.error(
+                f"❌ Call Quality API Error: {e.response.status_code} - {e.response.text}"
+            )
             return None
         except requests.exceptions.RequestException as e:
             st.error(f"⚠️ Call Quality API request failed: {e}")
             return None
 
+
 def create_issues_chart(issues):
     """Creates a bar chart of issues by area and severity."""
-    if not issues: return None
+    if not issues:
+        return None
     df = pd.DataFrame(issues)
-    fig = px.bar(df, x='area', y=None, color='severity', title='Issues by Area and Severity',
-                 labels={'area': 'Issue Area', 'count': 'Number of Issues'},
-                 color_discrete_map={'high': '#ff4b4b', 'medium': '#ffa64b', 'low': '#ffee4b'})
-    fig.update_layout(plot_bgcolor='rgba(0,0,0,0)')
+    fig = px.bar(
+        df,
+        x="area",
+        y=None,
+        color="severity",
+        title="Issues by Area and Severity",
+        labels={"area": "Issue Area", "count": "Number of Issues"},
+        color_discrete_map={"high": "#ff4b4b", "medium": "#ffa64b", "low": "#ffee4b"},
+    )
+    fig.update_layout(plot_bgcolor="rgba(0,0,0,0)")
     return fig
 
+
 def display_issues(issues):
     """Displays issues with styled cards."""
     if not issues:
@@ -637,82 +882,132 @@ def display_issues(issues):
         return
     for issue in issues:
         severity_class = f"{issue.get('severity', 'unknown').lower()}-severity"
-        st.markdown(f"""
+        st.markdown(
+            f"""
         <div class="metric-card {severity_class}">
-            <h4>{issue.get('issue', 'Unknown Issue')}</h4>
-            <p><strong>Severity:</strong> {issue.get('severity', 'N/A').upper()} | <strong>Area:</strong> {issue.get('area', 'N/A').replace('_', ' ').title()}</p>
-            <p><strong>Details:</strong> {issue.get('details', 'No details provided.')}</p>
+            <h4>{issue.get("issue", "Unknown Issue")}</h4>
+            <p><strong>Severity:</strong> {issue.get("severity", "N/A").upper()} | <strong>Area:</strong> {issue.get("area", "N/A").replace("_", " ").title()}</p>
+            <p><strong>Details:</strong> {issue.get("details", "No details provided.")}</p>
         </div>
-        """, unsafe_allow_html=True)
+        """,
+            unsafe_allow_html=True,
+        )
+
 
 def get_resolution_card_class(status):
     status = status.lower() if status else ""
     class_map = {
-        "solved": "resolution-solved", "partially solved": "resolution-partially-solved",
-        "not solve": "resolution-not-solved", "did not solve": "resolution-not-solved",
-        "escalation": "resolution-escalation", "abandoned": "resolution-abandoned",
-        "technical": "resolution-technical"
+        "solved": "resolution-solved",
+        "partially solved": "resolution-partially-solved",
+        "not solve": "resolution-not-solved",
+        "did not solve": "resolution-not-solved",
+        "escalation": "resolution-escalation",
+        "abandoned": "resolution-abandoned",
+        "technical": "resolution-technical",
     }
     for key, value in class_map.items():
-        if key in status: return value
+        if key in status:
+            return value
     return "resolution-incomplete"
 
+
 def display_resolution_status(resolution_status, resolution_evidence):
     """Displays resolution status with styling."""
     card_class = get_resolution_card_class(resolution_status)
-    st.markdown(f'<div class="resolution-card {card_class}"><h2>{resolution_status}</h2></div>', unsafe_allow_html=True)
+    st.markdown(
+        f'<div class="resolution-card {card_class}"><h2>{resolution_status}</h2></div>',
+        unsafe_allow_html=True,
+    )
     if resolution_evidence:
-        st.markdown(f'''
+        st.markdown(
+            f"""
         <div class="resolution-evidence">
             <h4>Supporting Evidence:</h4>
             <p>{resolution_evidence}</p>
-        </div>''', unsafe_allow_html=True)
+        </div>""",
+            unsafe_allow_html=True,
+        )
+
 
 def display_emotion_assessment(emotion_data):
     """Displays emotion assessment data."""
-    if not emotion_data: return
+    if not emotion_data:
+        return
     st.markdown("### 😀 Emotional Assessment")
     with st.container(border=True):
-        col1, col2 = st.columns([2,1])
+        col1, col2 = st.columns([2, 1])
         with col1:
             st.markdown(f"**Emotional Journey:**")
-            st.markdown(f'<div class="emotion-journey">{emotion_data.get("emotional_journey", "N/A")}</div>', unsafe_allow_html=True)
+            st.markdown(
+                f'<div class="emotion-journey">{emotion_data.get("emotional_journey", "N/A")}</div>',
+                unsafe_allow_html=True,
+            )
         with col2:
-            shift = emotion_data.get('emotional_shift', 'Unknown').title()
-            shift_color = {'Improved': '#4CAF50', 'Worsened': '#F44336', 'Neutral': '#607D8B', 'Fluctuated': '#FFC107'}.get(shift, '#9E9E9E')
+            shift = emotion_data.get("emotional_shift", "Unknown").title()
+            shift_color = {
+                "Improved": "#4CAF50",
+                "Worsened": "#F44336",
+                "Neutral": "#607D8B",
+                "Fluctuated": "#FFC107",
+            }.get(shift, "#9E9E9E")
             st.metric("Emotional Shift", shift)
-            st.markdown(f'<div style="width:100%; height: 5px; background-color:{shift_color}; border-radius: 5px;"></div>', unsafe_allow_html=True)
+            st.markdown(
+                f'<div style="width:100%; height: 5px; background-color:{shift_color}; border-radius: 5px;"></div>',
+                unsafe_allow_html=True,
+            )
 
         st.markdown(f"**Assessment Notes**:")
-        st.markdown(f'<div class="emotion-journey">{emotion_data.get("assessment_notes", "N/A")}</div>', unsafe_allow_html=True)
+        st.markdown(
+            f'<div class="emotion-journey">{emotion_data.get("assessment_notes", "N/A")}</div>',
+            unsafe_allow_html=True,
+        )
 
-        primary_emotions = emotion_data.get('primary_emotions', [])
+        primary_emotions = emotion_data.get("primary_emotions", [])
         if primary_emotions:
             st.markdown("**Primary Emotions Detected:**")
-            emotion_html = "".join(f'<span class="emotion-tag">{e.title()}</span>' for e in primary_emotions)
+            emotion_html = "".join(
+                f'<span class="emotion-tag">{e.title()}</span>'
+                for e in primary_emotions
+            )
             st.markdown(f"<div>{emotion_html}</div>", unsafe_allow_html=True)
 
-        resp = emotion_data.get('ai_responsiveness', 'Unknown').title()
-        resp_color = {'Excellent': '#4CAF50', 'Good': '#8BC34A', 'Adequate': '#FFC107', 'Poor': '#FF5722', 'Inappropriate': '#F44336'}.get(resp, '#9E9E9E')
-        st.markdown(f"**AI Responsiveness to Emotion:** <span style='color: {resp_color}; font-weight: bold;'>{resp}</span>", unsafe_allow_html=True)
+        resp = emotion_data.get("ai_responsiveness", "Unknown").title()
+        resp_color = {
+            "Excellent": "#4CAF50",
+            "Good": "#8BC34A",
+            "Adequate": "#FFC107",
+            "Poor": "#FF5722",
+            "Inappropriate": "#F44336",
+        }.get(resp, "#9E9E9E")
+        st.markdown(
+            f"**AI Responsiveness to Emotion:** <span style='color: {resp_color}; font-weight: bold;'>{resp}</span>",
+            unsafe_allow_html=True,
+        )
+
 
 def display_single_assessment(data):
     """Displays a single category assessment card."""
-    if not data: return
-    is_correct = data.get('is_correct', True)
+    if not data:
+        return
+    is_correct = data.get("is_correct", True)
     card_class = "assessment-correct" if is_correct else "assessment-incorrect"
     status_icon = "✅" if is_correct else "❌"
-    st.markdown(f"""
+    st.markdown(
+        f"""
     <div class="assessment-card {card_class}">
-        <p><strong>Status:</strong> {status_icon} {'Correct' if is_correct else 'Incorrect'}</p>
-        <p><strong>Original:</strong> {data.get('original', 'N/A')}</p>
-        {'<p><strong>Suggested:</strong> ' + data.get('suggested', 'N/A') + '</p>' if not is_correct else ''}
-        Reasoning: {data.get('reasoning', 'No reasoning provided.')}
-    </div>""", unsafe_allow_html=True)
+        <p><strong>Status:</strong> {status_icon} {"Correct" if is_correct else "Incorrect"}</p>
+        <p><strong>Original:</strong> {data.get("original", "N/A")}</p>
+        {"<p><strong>Suggested:</strong> " + data.get("suggested", "N/A") + "</p>" if not is_correct else ""}
+        Reasoning: {data.get("reasoning", "No reasoning provided.")}
+    </div>""",
+        unsafe_allow_html=True,
+    )
+
 
 def display_categorization_assessment(assessment_data):
     """Displays the categorization assessment section."""
-    if not assessment_data: return
+    if not assessment_data:
+        return
     st.markdown("---")
     st.markdown("## 🏷️ Call Categorization Assessment")
     col1, col2 = st.columns(2)
@@ -723,6 +1018,7 @@ def display_categorization_assessment(assessment_data):
         st.markdown("### Subcategory")
         display_single_assessment(assessment_data.get("subcategory_assessment"))
 
+
 # --- Sidebar Navigation ---
 with st.sidebar:
     st.title("🧠 BrAIn Dashboard")
@@ -738,11 +1034,19 @@ with st.sidebar:
         st.session_state.current_page = "call_analysis"
         st.rerun()
 
-    kb_button_text = f"🔧 KB Improvements ({pending_count})" if pending_count > 0 else "🔧 KB Improvements"
+    kb_button_text = (
+        f"🔧 KB Improvements ({pending_count})"
+        if pending_count > 0
+        else "🔧 KB Improvements"
+    )
     if st.button(kb_button_text, use_container_width=True):
         st.session_state.current_page = "kb_improvements"
         st.rerun()
 
+    if st.button("🚦 Hallucination Metrics", use_container_width=True):
+        st.session_state.current_page = "hallucinations"
+        st.rerun()
+
     st.markdown("---")
 
     # Page-specific sidebar content
@@ -754,14 +1058,14 @@ with st.sidebar:
             "full_analysis": "Full Analysis",
             "end_reason_analysis": "Call End Reason Analysis",
             "kb_improvements": "Knowledge Base Improvements",
-            "prompt_improvements": "System Prompt Improvements"
+            "prompt_improvements": "System Prompt Improvements",
         }
 
         analysis_focus = st.selectbox(
             "Analysis Focus",
             options=list(analysis_focus_options.keys()),
             format_func=lambda x: analysis_focus_options[x],
-            index=0
+            index=0,
         )
 
         st.markdown("---")
@@ -769,25 +1073,33 @@ with st.sidebar:
         use_emotion_recognition = st.toggle(
             "Include audio emotion recognition",
             value=False,
-            help="When enabled, audio will be analyzed for emotional content before call quality analysis."
+            help="When enabled, audio will be analyzed for emotional content before call quality analysis.",
         )
 
         if use_emotion_recognition:
-            st.info("Audio emotion analysis results will be incorporated into the main call quality analysis.")
-            num_emotion_chunks = st.slider("Number of audio chunks", min_value=2, max_value=5, value=3)
-
-        custom_prompt = st.text_area("Custom Analysis Prompt (Optional)",
-                                     placeholder="Enter any specific analysis questions...")
+            st.info(
+                "Audio emotion analysis results will be incorporated into the main call quality analysis."
+            )
+            num_emotion_chunks = st.slider(
+                "Number of audio chunks", min_value=2, max_value=5, value=3
+            )
+
+        custom_prompt = st.text_area(
+            "Custom Analysis Prompt (Optional)",
+            placeholder="Enter any specific analysis questions...",
+        )
 
-        analyze_button = st.button("Analyze Call", type="primary", use_container_width=True)
+        analyze_button = st.button(
+            "Analyze Call", type="primary", use_container_width=True
+        )
 
         st.markdown("---")
         st.subheader("Display Options")
         show_json = st.checkbox("Show Raw JSON", value=False)
 
         if st.button("Clear Results", type="secondary", use_container_width=True):
-            if 'analysis_result' in st.session_state:
-                del st.session_state['analysis_result']
+            if "analysis_result" in st.session_state:
+                del st.session_state["analysis_result"]
             st.rerun()
 
     elif st.session_state.current_page == "kb_improvements":
@@ -808,7 +1120,7 @@ with st.sidebar:
 if st.session_state.current_page == "call_analysis":
     st.title("📊 Call Quality Analysis Dashboard")
 
-    if analyze_button or ('analysis_result' in st.session_state):
+    if analyze_button or ("analysis_result" in st.session_state):
         if analyze_button:
             emotion_results = None
             # if use_emotion_recognition:
@@ -819,27 +1131,34 @@ if st.session_state.current_page == "call_analysis":
             #         else:
             #             st.error("Could not complete emotion analysis. Continuing without it.")
 
-            result = fetch_call_analysis(call_id, custom_prompt, analysis_focus, emotion_results)
+            result = fetch_call_analysis(
+                call_id, custom_prompt, analysis_focus, emotion_results
+            )
             if result:
-                st.session_state['analysis_result'] = result
-                st.session_state['current_focus'] = analysis_focus
+                st.session_state["analysis_result"] = result
+                st.session_state["current_focus"] = analysis_focus
                 st.success("✅ Analysis complete!")
 
-        if 'analysis_result' in st.session_state:
-            analysis = st.session_state['analysis_result']
-            current_focus = st.session_state.get('current_focus', 'full_analysis')
+        if "analysis_result" in st.session_state:
+            analysis = st.session_state["analysis_result"]
+            current_focus = st.session_state.get("current_focus", "full_analysis")
 
             st.metric("Call ID", analysis.get("call_id", call_id))
 
-            if current_focus != 'full_analysis':
-                st.info(f"🔍 Analysis focused on: **{analysis_focus_options.get(current_focus, current_focus).upper()}**")
+            if current_focus != "full_analysis":
+                st.info(
+                    f"🔍 Analysis focused on: **{analysis_focus_options.get(current_focus, current_focus).upper()}**"
+                )
 
             # --- Section: Resolution & Emotion ---
             st.markdown("## 🎯 Resolution & Emotion")
             col1, col2 = st.columns([1, 1])
             with col1:
                 st.markdown("### Resolution Status")
-                display_resolution_status(analysis.get("resolution_status"), analysis.get("resolution_evidence"))
+                display_resolution_status(
+                    analysis.get("resolution_status"),
+                    analysis.get("resolution_evidence"),
+                )
             with col2:
                 if "emotion_assessment" in analysis:
                     display_emotion_assessment(analysis.get("emotion_assessment"))
@@ -850,19 +1169,29 @@ if st.session_state.current_page == "call_analysis":
             col1, col2 = st.columns(2)
             with col1:
                 st.markdown("### Call Summary")
-                st.markdown(f'<div class="finding">{analysis.get("summary", "No summary.")}</div>', unsafe_allow_html=True)
+                st.markdown(
+                    f'<div class="finding">{analysis.get("summary", "No summary.")}</div>',
+                    unsafe_allow_html=True,
+                )
             with col2:
                 st.markdown("### Key Findings")
                 findings = analysis.get("key_findings", [])
                 if findings:
                     for finding in findings:
-                        st.markdown(f'<div class="finding">✅ {finding}</div>', unsafe_allow_html=True)
+                        st.markdown(
+                            f'<div class="finding">✅ {finding}</div>',
+                            unsafe_allow_html=True,
+                        )
                 else:
                     st.info("No key findings identified.")
 
             # --- Section: Categorization Assessment ---
-            if "categorization_assessment" in analysis and analysis.get("categorization_assessment"):
-                display_categorization_assessment(analysis.get("categorization_assessment"))
+            if "categorization_assessment" in analysis and analysis.get(
+                "categorization_assessment"
+            ):
+                display_categorization_assessment(
+                    analysis.get("categorization_assessment")
+                )
 
             # --- Section: Focused Analysis Displays ---
             if current_focus == "full_analysis":
@@ -873,7 +1202,8 @@ if st.session_state.current_page == "call_analysis":
                     chart_col, list_col = st.columns([1, 2])
                     with chart_col:
                         issues_chart = create_issues_chart(issues)
-                        if issues_chart: st.plotly_chart(issues_chart, use_container_width=True)
+                        if issues_chart:
+                            st.plotly_chart(issues_chart, use_container_width=True)
                     with list_col:
                         display_issues(issues)
                 else:
@@ -881,19 +1211,29 @@ if st.session_state.current_page == "call_analysis":
 
             if current_focus in ["full_analysis", "end_reason_analysis"]:
                 st.markdown("---")
-                st.markdown(f"<div class='{'focus-section' if current_focus == 'end_reason_analysis' else ''}'>", unsafe_allow_html=True)
+                st.markdown(
+                    f"<div class='{'focus-section' if current_focus == 'end_reason_analysis' else ''}'>",
+                    unsafe_allow_html=True,
+                )
                 st.markdown("## 🛑 Call End Reason Analysis")
                 end_analysis = analysis.get("end_reason_analysis", {})
                 if end_analysis:
-                    st.metric("Call End Reason", end_analysis.get('end_reason', 'N/A').replace('-', ' ').title())
-                    st.markdown(f"**Assessment:** {end_analysis.get('assessment', 'N/A')}")
+                    st.metric(
+                        "Call End Reason",
+                        end_analysis.get("end_reason", "N/A").replace("-", " ").title(),
+                    )
+                    st.markdown(
+                        f"**Assessment:** {end_analysis.get('assessment', 'N/A')}"
+                    )
                     col1, col2 = st.columns(2)
                     with col1:
                         st.markdown("#### Contributing Factors")
-                        for factor in end_analysis.get("contributing_factors", []): st.markdown(f"- {factor}")
+                        for factor in end_analysis.get("contributing_factors", []):
+                            st.markdown(f"- {factor}")
                     with col2:
                         st.markdown("#### Improvement Opportunities")
-                        for opp in end_analysis.get("improvement_opportunities", []): st.markdown(f"💡 {opp}")
+                        for opp in end_analysis.get("improvement_opportunities", []):
+                            st.markdown(f"💡 {opp}")
                 else:
                     st.info("No end reason analysis available.")
                 st.markdown("</div>", unsafe_allow_html=True)
@@ -904,7 +1244,13 @@ if st.session_state.current_page == "call_analysis":
 
             # Define tabs based on analysis focus
             if current_focus == "full_analysis":
-                tab_names = ["General", "Conversation Flow", "Escalation", "Prompt", "Knowledge Base"]
+                tab_names = [
+                    "General",
+                    "Conversation Flow",
+                    "Escalation",
+                    "Prompt",
+                    "Knowledge Base",
+                ]
             elif current_focus == "kb_improvements":
                 tab_names = ["Knowledge Base", "General"]
             elif current_focus == "prompt_improvements":
@@ -920,51 +1266,76 @@ if st.session_state.current_page == "call_analysis":
                 with tab_map["General"]:
                     recs = analysis.get("general_recommendations", [])
                     if recs:
-                        for rec in recs: st.markdown(f'<div class="recommendation">🔹 {rec}</div>', unsafe_allow_html=True)
-                    else: st.info("No general recommendations.")
+                        for rec in recs:
+                            st.markdown(
+                                f'<div class="recommendation">🔹 {rec}</div>',
+                                unsafe_allow_html=True,
+                            )
+                    else:
+                        st.info("No general recommendations.")
 
             if "Conversation Flow" in tab_map:
                 with tab_map["Conversation Flow"]:
                     recs = analysis.get("conversation_recommendations", [])
                     if recs:
-                        for rec in recs: st.markdown(f'<div class="conversation-recommendation">💬 {rec}</div>', unsafe_allow_html=True)
-                    else: st.info("No conversation flow recommendations.")
+                        for rec in recs:
+                            st.markdown(
+                                f'<div class="conversation-recommendation">💬 {rec}</div>',
+                                unsafe_allow_html=True,
+                            )
+                    else:
+                        st.info("No conversation flow recommendations.")
 
             if "Escalation" in tab_map:
                 with tab_map["Escalation"]:
                     recs = analysis.get("escalation_recommendations", [])
                     if recs:
-                        for rec in recs: st.markdown(f'<div class="escalation-recommendation">📈 {rec}</div>', unsafe_allow_html=True)
-                    else: st.info("No escalation recommendations.")
+                        for rec in recs:
+                            st.markdown(
+                                f'<div class="escalation-recommendation">📈 {rec}</div>',
+                                unsafe_allow_html=True,
+                            )
+                    else:
+                        st.info("No escalation recommendations.")
 
             if "Prompt" in tab_map:
                 with tab_map["Prompt"]:
                     improvements = analysis.get("prompt_improvements", [])
                     if improvements:
                         for imp in improvements:
-                            st.markdown(f"""
+                            st.markdown(
+                                f"""
                             <div class="prompt-improvement">
-                                <h4>Issue: {imp.get('issue', 'N/A')}</h4>
-                                <p><strong>Current Section:</strong> {imp.get('current_section', 'N/A')}</p>
-                                <p><strong>Suggested Change:</strong> {imp.get('suggested_change', 'N/A')}</p>
-                                <p><strong>Expected Outcome:</strong> {imp.get('expected_outcome', 'N/A')}</p>
-                            </div>""", unsafe_allow_html=True)
-                    else: st.info("No prompt improvements found.")
+                                <h4>Issue: {imp.get("issue", "N/A")}</h4>
+                                <p><strong>Current Section:</strong> {imp.get("current_section", "N/A")}</p>
+                                <p><strong>Suggested Change:</strong> {imp.get("suggested_change", "N/A")}</p>
+                                <p><strong>Expected Outcome:</strong> {imp.get("expected_outcome", "N/A")}</p>
+                            </div>""",
+                                unsafe_allow_html=True,
+                            )
+                    else:
+                        st.info("No prompt improvements found.")
 
             if "Knowledge Base" in tab_map:
                 with tab_map["Knowledge Base"]:
                     improvements = analysis.get("kb_improvements", [])
                     if improvements:
                         for imp in improvements:
-                            with st.expander(f"**Query:** '{imp.get('query', 'Unknown')}'"):
-                                st.markdown(f"""
+                            with st.expander(
+                                f"**Query:** '{imp.get('query', 'Unknown')}'"
+                            ):
+                                st.markdown(
+                                    f"""
                                 <div class="kb-improvement">
-                                    <p><strong>Issue:</strong> {imp.get('issue', 'N/A')}</p>
-                                    <p><strong>Suggestion:</strong> {imp.get('suggested_improvement', 'N/A')}</p>
-                                    <p><strong>Rationale:</strong> {imp.get('rationale', 'N/A')}</p>
-                                    <p><strong>Current Content:</strong> {imp.get('current_kb_content', 'N/A')}</p>
-                                </div>""", unsafe_allow_html=True)
-                    else: st.info("No KB improvements found.")
+                                    <p><strong>Issue:</strong> {imp.get("issue", "N/A")}</p>
+                                    <p><strong>Suggestion:</strong> {imp.get("suggested_improvement", "N/A")}</p>
+                                    <p><strong>Rationale:</strong> {imp.get("rationale", "N/A")}</p>
+                                    <p><strong>Current Content:</strong> {imp.get("current_kb_content", "N/A")}</p>
+                                </div>""",
+                                    unsafe_allow_html=True,
+                                )
+                    else:
+                        st.info("No KB improvements found.")
 
             if show_json:
                 st.markdown("---")
@@ -981,28 +1352,363 @@ if st.session_state.current_page == "call_analysis":
         4. Click **Analyze Call** to generate the report.
         """)
 
+elif st.session_state.current_page == "hallucinations":
+    st.title("🚦 Hallucination Metrics")
+
+    if not BRAIN_API_TOKEN:
+        st.error("🚨 BRAIN_API_TOKEN environment variable is not set.")
+        st.stop()
+
+    # Initialize session state for hallucination page
+    if "hallucination_leaderboard" not in st.session_state:
+        st.session_state.hallucination_leaderboard = None
+    if "hallucination_aggregates" not in st.session_state:
+        st.session_state.hallucination_aggregates = None
+    if "hallucination_top" not in st.session_state:
+        st.session_state.hallucination_top = None
+    if "hallucination_samples" not in st.session_state:
+        st.session_state.hallucination_samples = None
+    if "selected_assistant_id" not in st.session_state:
+        st.session_state.selected_assistant_id = None
+
+    # Fetch leaderboard first to populate assistant filter
+    if st.session_state.hallucination_leaderboard is None:
+        st.session_state.hallucination_leaderboard = fetch_assistant_leaderboard(
+            limit=50
+        )
+
+    leaderboard_data = st.session_state.hallucination_leaderboard
+    leaderboard_list = []
+    if leaderboard_data:
+        leaderboard_list = (
+            leaderboard_data.get("leaderboard", [])
+            if isinstance(leaderboard_data, dict)
+            else leaderboard_data
+        )
+
+    # Build assistant options from leaderboard
+    assistant_options = ["All Assistants"]
+    assistant_id_map = {"All Assistants": None}
+    for item in leaderboard_list:
+        asst_name = item.get("assistant_name", "Unknown")
+        asst_id = item.get("assistant_id", "")
+        display_name = f"{asst_name} ({asst_id[:8]}...)" if asst_id else asst_name
+        assistant_options.append(display_name)
+        assistant_id_map[display_name] = asst_id
+
+    # Filters
+    col_filter1, col_filter2 = st.columns(2)
+    with col_filter1:
+        selected_assistant_display = st.selectbox(
+            "Filter by Assistant",
+            options=assistant_options,
+            index=0,
+        )
+        assistant_filter = assistant_id_map.get(selected_assistant_display)
+    with col_filter2:
+        topic_filter = st.text_input(
+            "Topic (optional filter)",
+            value=st.session_state.get("hallucination_topic", ""),
+        )
+
+    col1, col2 = st.columns(2)
+    with col1:
+        aggregate_limit = st.number_input(
+            "Rows (aggregates)", min_value=1, max_value=200, value=50, step=1
+        )
+    with col2:
+        top_n = st.number_input(
+            "Top hallucinators", min_value=1, max_value=50, value=10, step=1
+        )
+
+    if st.button("Refresh metrics", type="primary", use_container_width=True):
+        st.session_state.hallucination_topic = topic_filter
+        with st.spinner("Loading hallucination metrics..."):
+            st.session_state.hallucination_leaderboard = fetch_assistant_leaderboard(
+                topic_filter or None, limit=50
+            )
+            st.session_state.hallucination_aggregates = fetch_eval_aggregates(
+                assistant_filter, topic_filter or None, aggregate_limit
+            )
+            st.session_state.hallucination_top = fetch_top_hallucinators(
+                assistant_filter, topic_filter or None, top_n
+            )
+            st.session_state.hallucination_samples = fetch_sample_unsupported(
+                assistant_filter, topic_filter or None, 20
+            )
+        st.rerun()
+
+    # --- Assistant Leaderboard Section ---
+    st.markdown("---")
+    st.subheader("🏆 Assistant Leaderboard")
+    st.caption("Ranking of assistants by hallucination rate (highest first)")
+
+    leaderboard_data = st.session_state.get("hallucination_leaderboard")
+    if leaderboard_data:
+        leaderboard_rows = (
+            leaderboard_data.get("leaderboard", [])
+            if isinstance(leaderboard_data, dict)
+            else leaderboard_data
+        )
+        if leaderboard_rows:
+            # Create DataFrame for display
+            lb_df = pd.DataFrame(leaderboard_rows)
+
+            # Display summary metrics
+            if not lb_df.empty:
+                metric_cols = st.columns(4)
+                with metric_cols[0]:
+                    avg_hallucination = (
+                        lb_df["unsupported_claim_rate"].mean()
+                        if "unsupported_claim_rate" in lb_df.columns
+                        else 0
+                    )
+                    st.metric("Avg Hallucination Rate", f"{avg_hallucination:.1%}")
+                with metric_cols[1]:
+                    total_claims = (
+                        lb_df["total_claims"].sum()
+                        if "total_claims" in lb_df.columns
+                        else 0
+                    )
+                    st.metric("Total Claims Evaluated", f"{total_claims:,}")
+                with metric_cols[2]:
+                    total_unsupported = (
+                        lb_df["unsupported_claims"].sum()
+                        if "unsupported_claims" in lb_df.columns
+                        else 0
+                    )
+                    st.metric("Total Unsupported Claims", f"{total_unsupported:,}")
+                with metric_cols[3]:
+                    num_assistants = len(lb_df)
+                    st.metric("Assistants Tracked", num_assistants)
+
+            # Display leaderboard chart
+            if not lb_df.empty and "unsupported_claim_rate" in lb_df.columns:
+                # Create bar chart
+                chart_df = lb_df.head(15).copy()
+                chart_df["assistant_label"] = chart_df.apply(
+                    lambda x: x.get("assistant_name", "Unknown")[:20], axis=1
+                )
+                chart_df["hallucination_pct"] = chart_df["unsupported_claim_rate"] * 100
+
+                fig = px.bar(
+                    chart_df,
+                    x="assistant_label",
+                    y="hallucination_pct",
+                    title="Hallucination Rate by Assistant",
+                    labels={
+                        "assistant_label": "Assistant",
+                        "hallucination_pct": "Hallucination Rate (%)",
+                    },
+                    color="hallucination_pct",
+                    color_continuous_scale=["green", "yellow", "red"],
+                )
+                fig.update_layout(
+                    xaxis_tickangle=-45,
+                    showlegend=False,
+                    plot_bgcolor="rgba(0,0,0,0)",
+                )
+                st.plotly_chart(fig, use_container_width=True)
+
+            # Display leaderboard table
+            st.markdown("#### Detailed Leaderboard")
+            display_df = lb_df.copy()
+            if "unsupported_claim_rate" in display_df.columns:
+                display_df["Hallucination Rate"] = display_df[
+                    "unsupported_claim_rate"
+                ].apply(lambda x: f"{x:.1%}")
+            if "grounded_claim_rate" in display_df.columns:
+                display_df["Grounded Rate"] = display_df["grounded_claim_rate"].apply(
+                    lambda x: f"{x:.1%}"
+                )
+
+            # Select columns for display
+            display_cols = [
+                "assistant_name",
+                "total_claims",
+                "unsupported_claims",
+                "supported_claims",
+                "Hallucination Rate",
+                "Grounded Rate",
+            ]
+            available_cols = [c for c in display_cols if c in display_df.columns]
+            if available_cols:
+                st.dataframe(
+                    display_df[available_cols].rename(
+                        columns={
+                            "assistant_name": "Assistant",
+                            "total_claims": "Total Claims",
+                            "unsupported_claims": "Unsupported",
+                            "supported_claims": "Supported",
+                        }
+                    ),
+                    use_container_width=True,
+                    hide_index=True,
+                )
+        else:
+            st.info("No leaderboard data available. Run some evaluations first.")
+    else:
+        st.info("Click 'Refresh metrics' to load the assistant leaderboard.")
+
+    # --- Aggregates Section ---
+    aggregates = st.session_state.get("hallucination_aggregates")
+    if aggregates is not None:
+        st.markdown("---")
+        st.subheader("📊 Run Aggregates")
+        agg_rows = (
+            aggregates.get("aggregates")
+            if isinstance(aggregates, dict) and "aggregates" in aggregates
+            else aggregates
+        )
+        if agg_rows:
+            agg_df = pd.DataFrame(agg_rows)
+            if not agg_df.empty:
+                # Format rates as percentages for display
+                display_agg_df = agg_df.copy()
+                if "unsupported_claim_rate" in display_agg_df.columns:
+                    display_agg_df["unsupported_claim_rate"] = display_agg_df[
+                        "unsupported_claim_rate"
+                    ].apply(lambda x: f"{x:.1%}" if pd.notna(x) else "N/A")
+                if "grounded_claim_rate" in display_agg_df.columns:
+                    display_agg_df["grounded_claim_rate"] = display_agg_df[
+                        "grounded_claim_rate"
+                    ].apply(lambda x: f"{x:.1%}" if pd.notna(x) else "N/A")
+                if "citation_precision" in display_agg_df.columns:
+                    display_agg_df["citation_precision"] = display_agg_df[
+                        "citation_precision"
+                    ].apply(lambda x: f"{x:.1%}" if pd.notna(x) else "N/A")
+
+                st.dataframe(display_agg_df, use_container_width=True, hide_index=True)
+        else:
+            st.info("No aggregate data available.")
+
+    # --- Top Hallucinators Section ---
+    top_hallucinators = st.session_state.get("hallucination_top")
+    if top_hallucinators is not None:
+        st.markdown("---")
+        st.subheader("🔝 Top Hallucinators (by Run)")
+        st.caption("Runs with the highest count of unsupported claims")
+        top_rows = (
+            top_hallucinators.get("top_prompts")
+            if isinstance(top_hallucinators, dict)
+            and "top_prompts" in top_hallucinators
+            else top_hallucinators
+        )
+        if top_rows:
+            for idx, item in enumerate(top_rows):
+                assistant_name = item.get("assistant_name", "Unknown Assistant")
+                prompt_id = item.get("prompt_id", "Unknown")
+                unsupported_count = item.get("unsupported_count", 0)
+                run_id = item.get("run_id", "")
+
+                # Determine severity class
+                if unsupported_count >= 5:
+                    severity_class = "hallucination-high"
+                elif unsupported_count >= 3:
+                    severity_class = "hallucination-medium"
+                else:
+                    severity_class = "hallucination-low"
+
+                st.markdown(
+                    f"""
+                    <div class="leaderboard-card {severity_class}">
+                        <span class="leaderboard-rank">#{idx + 1}</span>
+                        <strong>{assistant_name}</strong> - {unsupported_count} unsupported claims
+                        <br><small>Prompt: {prompt_id[:30]}{"..." if len(str(prompt_id)) > 30 else ""}</small>
+                    </div>
+                    """,
+                    unsafe_allow_html=True,
+                )
+        else:
+            st.info("No top hallucinators found.")
+
+    # --- Sample Unsupported Claims Section ---
+    samples = st.session_state.get("hallucination_samples")
+    if samples is not None:
+        st.markdown("---")
+        st.subheader("🔍 Sample Unsupported Claims")
+        st.caption("Random sample of claims marked as unsupported for review")
+        sample_rows = (
+            samples.get("samples")
+            if isinstance(samples, dict) and "samples" in samples
+            else samples
+        )
+        if sample_rows:
+            for sample in sample_rows:
+                assistant_name = sample.get("assistant_name", "Unknown Assistant")
+                claim_text = sample.get("claim_text", "No claim text")
+                run_id = sample.get("run_id", "")
+                claim_idx = sample.get("claim_idx", 0)
+                citations = sample.get("citations_json", [])
+                notes = sample.get("notes", "")
+                assistant_id = sample.get("assistant_id")
+
+                with st.expander(
+                    f"[{assistant_name}] {claim_text[:60]}{'...' if len(claim_text) > 60 else ''}"
+                ):
+                    st.markdown(f"**Assistant:** {assistant_name}")
+                    st.markdown(f"**Claim:** {claim_text}")
+                    st.markdown(f"**Citations:** {citations if citations else 'None'}")
+                    if notes:
+                        st.markdown(f"**Notes:** {notes}")
+
+                    # Annotation buttons
+                    st.markdown("**Annotate this claim:**")
+                    col_tp, col_fp, col_skip = st.columns(3)
+                    with col_tp:
+                        if st.button(
+                            "✅ True Positive",
+                            key=f"tp_{run_id}_{claim_idx}_{assistant_id or ''}",
+                        ):
+                            result = submit_annotation(
+                                run_id, claim_idx, "true_positive", assistant_id
+                            )
+                            if result:
+                                st.success("Marked as true positive!")
+                    with col_fp:
+                        if st.button(
+                            "❌ False Positive",
+                            key=f"fp_{run_id}_{claim_idx}_{assistant_id or ''}",
+                        ):
+                            result = submit_annotation(
+                                run_id, claim_idx, "false_positive", assistant_id
+                            )
+                            if result:
+                                st.success("Marked as false positive!")
+                    with col_skip:
+                        if st.button(
+                            "⏭️ Skip",
+                            key=f"skip_{run_id}_{claim_idx}_{assistant_id or ''}",
+                        ):
+                            result = submit_annotation(
+                                run_id, claim_idx, "skipped", assistant_id
+                            )
+                            if result:
+                                st.info("Skipped.")
+        else:
+            st.info("No sample unsupported claims found.")
+
 elif st.session_state.current_page == "kb_improvements":
     st.title("🔧 Knowledge Base Improvements")
 
-    # Initialize kb_view if not exists
-    if "kb_view" not in st.session_state:
-        st.session_state.kb_view = "stats"
+    kb_view = st.session_state.get("kb_view", "list")
 
-    # Display based on current view
-    if st.session_state.kb_view == "stats":
+    if kb_view == "stats":
         display_kb_stats()
         st.markdown("---")
         display_kb_improvements_list()
-    elif st.session_state.kb_view == "list":
+    elif kb_view == "list":
         display_kb_improvements_list()
 
 elif st.session_state.current_page == "kb_review":
-    if "selected_call_id" in st.session_state:
-        display_kb_review_interface(st.session_state.selected_call_id)
+    selected_call_id = st.session_state.get("selected_call_id")
+    if selected_call_id:
+        display_kb_review_interface(selected_call_id)
     else:
-        st.error("No call ID selected for review.")
-        st.session_state.current_page = "kb_improvements"
-        st.rerun()
+        st.warning("No call selected for review.")
+        if st.button("Go back to KB Improvements"):
+            st.session_state.current_page = "kb_improvements"
+            st.rerun()
 
 st.markdown("---")
-st.caption(f"🧠 BrAIn Dashboard | Last updated: {datetime.now().strftime('%B %d, %Y')}")
+st.caption(f"🧠 BrAIn Dashboard | Last updated: {datetime.now().strftime('%B %d, %Y')}")