refactor + add gemini

app.py

@@ -10,6 +10,7 @@ import uuid
 import logging
 import traceback
 from pathlib import Path
+
 from collections import Counter
 from typing import List, Dict, Any, Optional
 
@@ -19,10 +20,11 @@ import streamlit as st
 import plotly.express as px
 from langchain_core.messages import HumanMessage, AIMessage
 
-from multi_agent_chatbot import get_multi_agent_chatbot
-from smart_chatbot import get_chatbot as get_smart_chatbot
-from src.reporting.snowflake_connector import save_to_snowflake
-from src.reporting.feedback_schema import create_feedback_from_dict
+
+from src.agents import get_multi_agent_chatbot, get_smart_chatbot, get_gemini_chatbot
+from src.feedback import FeedbackManager
+from src.ui_components import get_custom_css, display_chunk_statistics_charts, display_chunk_statistics_table, extract_chunk_statistics
+
 from src.config.paths import (
     IS_DEPLOYED,
     PROJECT_DIR,
@@ -90,116 +92,9 @@ st.set_page_config(
     page_title="Intelligent Audit Report Chatbot"
 )
 
-# Custom CSS
-st.markdown("""
-<style>
-    .main-header {
-        font-size: 2.5rem;
-        font-weight: bold;
-        color: #1f77b4;
-        text-align: center;
-        margin-bottom: 1rem;
-        width: 100%;
-        display: block;
-    }
-    
-    .subtitle {
-        font-size: 1.2rem;
-        color: #666;
-        text-align: center;
-        margin-bottom: 2rem;
-        width: 100%;
-        display: block;
-    }
-    
-    .session-info {
-        background-color: #f0f2f6;
-        padding: 10px;
-        border-radius: 5px;
-        margin-bottom: 20px;
-        font-size: 0.9rem;
-    }
-    
-    .user-message {
-        background-color: #007bff;
-        color: white;
-        padding: 12px 16px;
-        border-radius: 18px 18px 4px 18px;
-        margin: 8px 0;
-        margin-left: 20%;
-        word-wrap: break-word;
-    }
-    
-    .bot-message {
-        background-color: #f1f3f4;
-        color: #333;
-        padding: 12px 16px;
-        border-radius: 18px 18px 18px 4px;
-        margin: 8px 0;
-        margin-right: 20%;
-        word-wrap: break-word;
-        border: 1px solid #e0e0e0;
-    }
-    
-    .filter-section {
-        margin-bottom: 20px;
-        padding: 15px;
-        background-color: #f8f9fa;
-        border-radius: 8px;
-        border: 1px solid #e9ecef;
-    }
-    
-    .filter-title {
-        font-weight: bold;
-        margin-bottom: 10px;
-        color: #495057;
-    }
-    
-    .feedback-section {
-        background-color: #f8f9fa;
-        padding: 20px;
-        border-radius: 10px;
-        margin-top: 30px;
-        border: 2px solid #dee2e6;
-    }
-    
-    .retrieval-history {
-        background-color: #ffffff;
-        padding: 15px;
-        border-radius: 5px;
-        margin: 10px 0;
-        border-left: 4px solid #007bff;
-    }
-    
-    .retrieval-distribution-container {
-        background-color: #ffffff;
-        padding: 25px;
-        border-radius: 10px;
-        margin: 20px 0;
-        border: 2px solid #e0e0e0;
-        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1), 0 2px 4px rgba(0, 0, 0, 0.06);
-    }
-    
-    .metric-label {
-        font-size: 0.9rem;
-        color: #555;
-        margin-bottom: 5px;
-        text-align: center;
-    }
-    
-    .metric-value {
-        font-size: 1.8rem;
-        font-weight: bold;
-        color: #000000;
-        text-align: center;
-    }
-    
-    .metric-container {
-        text-align: center;
-        padding: 10px;
-    }
-</style>
-""", unsafe_allow_html=True)
+
+st.markdown(get_custom_css(), unsafe_allow_html=True)
+
 
 def get_system_type():
     """Get the current system type"""
@@ -209,14 +104,17 @@ def get_system_type():
     else:
         return "Multi-Agent System"
 
-def get_chatbot():
-    """Initialize and return the chatbot based on system type"""
-    # Check environment variable for system type
-    system = os.environ.get('CHATBOT_SYSTEM', 'multi-agent')
-    if system == 'smart':
-        return get_smart_chatbot()
+def get_chatbot(version: str = "v1"):
+    """Initialize and return the chatbot based on version"""
+    if version == "beta":
+        return get_gemini_chatbot()
     else:
-        return get_multi_agent_chatbot()
+        # Check environment variable for system type (v1)
+        system = os.environ.get('CHATBOT_SYSTEM', 'multi-agent')
+        if system == 'smart':
+            return get_smart_chatbot()
+        else:
+            return get_multi_agent_chatbot()
 
 def serialize_messages(messages):
     """Serialize LangChain messages to dictionaries"""
@@ -262,372 +160,9 @@ def serialize_documents(sources):
     return serialized
 
 
-def extract_transcript(messages: List[Any]) -> List[Dict[str, str]]:
-    """Extract transcript from messages - only user and bot messages, no extra metadata"""
-    transcript = []
-    for msg in messages:
-        if isinstance(msg, HumanMessage):
-            transcript.append({
-                "role": "user",
-                "content": str(msg.content) if hasattr(msg, 'content') else str(msg)
-            })
-        elif isinstance(msg, AIMessage):
-            transcript.append({
-                "role": "assistant",
-                "content": str(msg.content) if hasattr(msg, 'content') else str(msg)
-            })
-    return transcript
+feedback_manager = FeedbackManager()
 
 
-def build_retrievals_structure(rag_retrieval_history: List[Dict[str, Any]], messages: List[Any]) -> List[Dict[str, Any]]:
-    """Build retrievals structure from retrieval history"""
-    retrievals = []
-    
-    for entry in rag_retrieval_history:
-        # Get the user message that triggered this retrieval
-        # The entry has conversation_up_to which includes messages up to that point
-        conversation_up_to = entry.get("conversation_up_to", [])
-        
-        # Find the last user message in conversation_up_to (this is the trigger)
-        user_message_trigger = ""
-        for msg_dict in reversed(conversation_up_to):
-            if msg_dict.get("type") == "HumanMessage":
-                user_message_trigger = msg_dict.get("content", "")
-                break
-        
-        # Fallback: if not found in conversation_up_to, get from actual messages
-        # This handles edge cases where conversation_up_to might be incomplete
-        if not user_message_trigger:
-            # Find which retrieval this is (0-indexed)
-            retrieval_idx = rag_retrieval_history.index(entry)
-            # The user message that triggered this retrieval is at position (retrieval_idx * 2)
-            # because each retrieval is preceded by: user message, bot response, user message, ...
-            # But we need to account for the fact that the first retrieval happens after the first user message
-            user_msgs = [msg for msg in messages if isinstance(msg, HumanMessage)]
-            if retrieval_idx < len(user_msgs):
-                user_message_trigger = str(user_msgs[retrieval_idx].content)
-            elif user_msgs:
-                # Fallback to last user message
-                user_message_trigger = str(user_msgs[-1].content)
-        
-        # Get retrieved documents and truncate content to 100 chars
-        docs_retrieved = entry.get("docs_retrieved", [])
-        retrieved_docs = []
-        for doc in docs_retrieved:
-            doc_copy = doc.copy()
-            # Truncate content to 100 characters (keep all other fields)
-            if "content" in doc_copy:
-                doc_copy["content"] = doc_copy["content"][:100]
-            retrieved_docs.append(doc_copy)
-        
-        retrievals.append({
-            "retrieved_docs": retrieved_docs,
-            "user_message_trigger": user_message_trigger
-        })
-    
-    return retrievals
-
-
-def build_feedback_score_related_retrieval_docs(
-    is_feedback_about_last_retrieval: bool,
-    messages: List[Any],
-    rag_retrieval_history: List[Dict[str, Any]]
-) -> Optional[Dict[str, Any]]:
-    """Build feedback_score_related_retrieval_docs structure"""
-    if not rag_retrieval_history:
-        return None
-    
-    # Get the relevant retrieval entry
-    if is_feedback_about_last_retrieval:
-        relevant_entry = rag_retrieval_history[-1]
-    else:
-        # If feedback is about all retrievals, use the last one as default
-        relevant_entry = rag_retrieval_history[-1]
-    
-    # Get conversation up to that point
-    conversation_up_to = relevant_entry.get("conversation_up_to", [])
-    
-    # Convert to transcript format (role/content)
-    conversation_up_to_point = []
-    for msg_dict in conversation_up_to:
-        if msg_dict.get("type") == "HumanMessage":
-            conversation_up_to_point.append({
-                "role": "user",
-                "content": msg_dict.get("content", "")
-            })
-        elif msg_dict.get("type") == "AIMessage":
-            conversation_up_to_point.append({
-                "role": "assistant",
-                "content": msg_dict.get("content", "")
-            })
-    
-    # Get retrieved docs with full content (not truncated)
-    retrieved_docs = relevant_entry.get("docs_retrieved", [])
-    
-    return {
-        "conversation_up_to_point": conversation_up_to_point,
-        "retrieved_docs": retrieved_docs
-    }
-
-def extract_chunk_statistics(sources: List[Any]) -> Dict[str, Any]:
-    """Extract statistics from retrieved chunks."""
-    if not sources:
-        return {}
-    
-    sources_list = []
-    years = []
-    filenames = []
-    districts = []
-    
-    for doc in sources:
-        metadata = getattr(doc, 'metadata', {})
-        
-        # Extract source
-        source = metadata.get('source', 'Unknown')
-        sources_list.append(source)
-        
-        # Extract year
-        year = metadata.get('year', 'Unknown')
-        if year and year != 'Unknown':
-            try:
-                # Convert to int first, then back to string to ensure it's a proper year
-                year_int = int(float(year))  # Handle both int and float strings
-                if 1900 <= year_int <= 2030:  # Reasonable year range
-                    years.append(str(year_int))
-                else:
-                    years.append('Unknown')
-            except (ValueError, TypeError):
-                years.append('Unknown')
-        else:
-            years.append('Unknown')
-        
-        # Extract filename
-        filename = metadata.get('filename', 'Unknown')
-        filenames.append(filename)
-        
-        # Extract district
-        district = metadata.get('district', 'Unknown')
-        if district and district != 'Unknown':
-            districts.append(district)
-        else:
-            districts.append('Unknown')
-    
-    # Count occurrences
-    source_counts = Counter(sources_list)
-    year_counts = Counter(years)
-    filename_counts = Counter(filenames)
-    district_counts = Counter(districts)
-    
-    return {
-        'total_chunks': len(sources),
-        'unique_sources': len(source_counts),
-        'unique_years': len([y for y in year_counts.keys() if y != 'Unknown']),
-        'unique_filenames': len(filename_counts),
-        'unique_districts': len([d for d in district_counts.keys() if d != 'Unknown']),
-        'source_distribution': dict(source_counts),
-        'year_distribution': dict(year_counts),
-        'filename_distribution': dict(filename_counts),
-        'district_distribution': dict(district_counts),
-        'sources': sources_list,
-        'years': years,
-        'filenames': filenames,
-        'districts': districts
-    }
-
-def display_chunk_statistics_charts(stats: Dict[str, Any], title: str = "Retrieval Statistics"):
-    """Display statistics as interactive charts for 10+ results."""
-    if not stats or stats.get('total_chunks', 0) == 0:
-        return
-    
-    # Wrap everything in one styled container - open it
-    st.markdown(f"""
-    <div class="retrieval-distribution-container">
-        <h3 style="margin-top: 0;">📊 {title}</h3>
-        <div style="display: flex; justify-content: space-around; align-items: center; padding: 15px 0; border-bottom: 1px solid #e0e0e0; margin-bottom: 20px;">
-            <div class="metric-container">
-                <div class="metric-label">Total Chunks</div>
-                <div class="metric-value">{stats['total_chunks']}</div>
-            </div>
-            <div class="metric-container">
-                <div class="metric-label">Unique Sources</div>
-                <div class="metric-value">{stats['unique_sources']}</div>
-            </div>
-            <div class="metric-container">
-                <div class="metric-label">Unique Years</div>
-                <div class="metric-value">{stats['unique_years']}</div>
-            </div>
-            <div class="metric-container">
-                <div class="metric-label">Unique Files</div>
-                <div class="metric-value">{stats['unique_filenames']}</div>
-            </div>
-        </div>
-    """, unsafe_allow_html=True)
-    
-    # Charts - three columns to include Districts
-    col1, col2, col3 = st.columns(3)
-    
-    with col1:
-        # Source distribution chart
-        if stats['source_distribution']:
-            source_df = pd.DataFrame(
-                list(stats['source_distribution'].items()),
-                columns=['Source', 'Count']
-            )
-            fig_source = px.bar(
-                source_df,
-                x='Count',
-                y='Source',
-                orientation='h',
-                title='Distribution by Source',
-                color='Count',
-                color_continuous_scale='viridis'
-            )
-            fig_source.update_layout(height=400, showlegend=False)
-            st.plotly_chart(fig_source, use_container_width=True)
-    
-    with col2:
-        # Year distribution chart
-        if stats['year_distribution']:
-            # Filter out 'Unknown' years for the chart
-            year_dist_filtered = {k: v for k, v in stats['year_distribution'].items() if k != 'Unknown'}
-            if year_dist_filtered:
-                year_df = pd.DataFrame(
-                    list(year_dist_filtered.items()),
-                    columns=['Year', 'Count']
-                )
-                # Sort by year as integer but keep as string for categorical display
-                year_df['Year_Int'] = year_df['Year'].astype(int)
-                year_df = year_df.sort_values('Year_Int').drop('Year_Int', axis=1)
-                
-                fig_year = px.bar(
-                    year_df,
-                    x='Year',
-                    y='Count',
-                    title='Distribution by Year',
-                    color='Count',
-                    color_continuous_scale='plasma'
-                )
-                # Ensure years are treated as categorical (discrete) not continuous
-                fig_year.update_xaxes(type='category')
-                fig_year.update_layout(height=400, showlegend=False)
-                st.plotly_chart(fig_year, use_container_width=True)
-            else:
-                st.info("No valid years found in the results")
-    
-    with col3:
-        # District distribution chart
-        if stats.get('district_distribution'):
-            district_dist_filtered = {k: v for k, v in stats['district_distribution'].items() if k != 'Unknown'}
-            if district_dist_filtered:
-                district_df = pd.DataFrame(
-                    list(district_dist_filtered.items()),
-                    columns=['District', 'Count']
-                )
-                district_df = district_df.sort_values('Count', ascending=False)
-                
-                fig_district = px.bar(
-                    district_df,
-                    x='Count',
-                    y='District',
-                    orientation='h',
-                    title='Distribution by District',
-                    color='Count',
-                    color_continuous_scale='blues'
-                )
-                fig_district.update_layout(height=400, showlegend=False)
-                st.plotly_chart(fig_district, use_container_width=True)
-            else:
-                st.info("No valid districts found in the results")
-    
-    # Close the container
-    st.markdown('</div>', unsafe_allow_html=True)
-
-def display_chunk_statistics_table(stats: Dict[str, Any], title: str = "Retrieval Distribution"):
-    """Display statistics as tables for smaller results with fixed alignment."""
-    if not stats or stats.get('total_chunks', 0) == 0:
-        return
-    
-    # Wrap in styled container
-
-    st.markdown('<div class="retrieval-distribution-container">', unsafe_allow_html=True)
-    # st.markdown('<div class="retrieval-distribution-container">', unsafe_allow_html=True)
-
-    
-    st.subheader(f"📊 {title}")
-    
-    # Create a container with fixed height for alignment
-    stats_container = st.container()
-    
-    with stats_container:
-        # Create 4 equal columns for consistent alignment
-        col1, col2, col3, col4 = st.columns(4)
-        
-        with col1:
-            st.markdown("**🏘️ Districts**")
-            if stats.get('district_distribution'):
-                district_dist_filtered = {k: v for k, v in stats['district_distribution'].items() if k != 'Unknown'}
-                if district_dist_filtered:
-                    district_data = {
-                        "District": list(district_dist_filtered.keys()),
-                        "Count": list(district_dist_filtered.values())
-                    }
-                    district_df = pd.DataFrame(district_data).sort_values('Count', ascending=False)
-                    st.dataframe(district_df, hide_index=True, use_container_width=True)
-                else:
-                    st.write("No district data")
-            else:
-                st.write("No district data")
-        
-        with col2:
-            st.markdown("**📂 Sources**")
-            if stats['source_distribution']:
-                source_data = {
-                    "Source": list(stats['source_distribution'].keys()),
-                    "Count": list(stats['source_distribution'].values())
-                }
-                source_df = pd.DataFrame(source_data).sort_values('Count', ascending=False)
-                st.dataframe(source_df, hide_index=True, use_container_width=True)
-            else:
-                st.write("No source data")
-        
-        with col3:
-            st.markdown("**📅 Years**")
-            if stats['year_distribution']:
-                year_dist_filtered = {k: v for k, v in stats['year_distribution'].items() if k != 'Unknown'}
-                if year_dist_filtered:
-                    year_data = {
-                        "Year": list(year_dist_filtered.keys()),
-                        "Count": list(year_dist_filtered.values())
-                    }
-                    year_df = pd.DataFrame(year_data)
-                    # Sort by year as integer but display as string
-                    year_df['Year_Int'] = year_df['Year'].astype(int)
-                    year_df = year_df.sort_values('Year_Int')[['Year', 'Count']]
-                    st.dataframe(year_df, hide_index=True, use_container_width=True)
-                else:
-                    st.write("No year data")
-            else:
-                st.write("No year data")
-        
-        with col4:
-            st.markdown("**📄 Files**")
-            if stats['filename_distribution']:
-                filename_items = list(stats['filename_distribution'].items())
-                filename_items.sort(key=lambda x: x[1], reverse=True)
-                
-                # Show top files with truncated names
-                file_data = {
-                    "File": [f[:30] + "..." if len(f) > 30 else f for f, c in filename_items[:5]],
-                    "Count": [c for f, c in filename_items[:5]]
-                }
-                file_df = pd.DataFrame(file_data)
-                st.dataframe(file_df, hide_index=True, use_container_width=True)
-            else:
-                st.write("No file data")
-    
-    # Close container
-    st.markdown('</div>', unsafe_allow_html=True)
-
 @st.cache_data
 def load_filter_options():
     try:
@@ -652,11 +187,30 @@ def main():
     # Track RAG retrieval history for feedback
     if 'rag_retrieval_history' not in st.session_state:
         st.session_state.rag_retrieval_history = []
-    # Initialize chatbot only once per app session (cached)
-    if 'chatbot' not in st.session_state:
-        with st.spinner("🔄 Loading AI models and connecting to database..."):
-            st.session_state.chatbot = get_chatbot()
-        st.success("✅ AI system ready!")
+    # Version selection (v1 or beta)
+    if 'chatbot_version' not in st.session_state:
+        st.session_state.chatbot_version = "v1"
+    
+    # Initialize chatbot based on version (reinitialize if version changes)
+    chatbot_version_key = f"chatbot_{st.session_state.chatbot_version}"
+    if chatbot_version_key not in st.session_state or st.session_state.get('_last_version') != st.session_state.chatbot_version:
+        try:
+            with st.spinner("🔄 Loading AI models and connecting to database..."):
+                st.session_state[chatbot_version_key] = get_chatbot(st.session_state.chatbot_version)
+                st.session_state['_last_version'] = st.session_state.chatbot_version
+                st.session_state.chatbot = st.session_state[chatbot_version_key]
+            st.success("✅ AI system ready!")
+        except Exception as e:
+            st.error(f"❌ Failed to initialize chatbot: {str(e)}")
+            st.error("Please check your environment variables (GEMINI_API_KEY, GEMINI_FILESTORE_NAME for beta)")
+            # Reset to v1 to prevent infinite loop
+            st.session_state.chatbot_version = "v1"
+            st.session_state['_last_version'] = "v1"
+            if 'chatbot' in st.session_state:
+                del st.session_state['chatbot']
+            st.stop()  # Stop execution to prevent infinite loop
+    else:
+        st.session_state.chatbot = st.session_state[chatbot_version_key]
     
     # Reset conversation history if needed (but keep chatbot cached)
     if 'reset_conversation' in st.session_state and st.session_state.reset_conversation:
@@ -668,10 +222,13 @@ def main():
         st.session_state.reset_conversation = False
         st.rerun()
 
-    # Header - fully center aligned
-    st.markdown('<h1 class="main-header">🤖 Intelligent Audit Report Chatbot</h1>', unsafe_allow_html=True)
+
     st.markdown('<p class="subtitle">Ask questions about audit reports. Use the sidebar filters to narrow down your search!</p>', unsafe_allow_html=True)
     
+    # Show version info
+    if st.session_state.chatbot_version == "beta":
+        st.info("🔬 **Beta Mode**: Using Google Gemini File Search API")
+    
     # Session info
     duration = int(time.time() - st.session_state.session_start_time)
     duration_str = f"{duration // 60}m {duration % 60}s"
@@ -829,7 +386,7 @@ def main():
             )
         
         with col2:
-            send_button = st.button("Send", key="send_button", use_container_width=True)
+            send_button = st.button("Send", key="send_button", width='stretch')
         
         # Clear chat button
         if st.button("🗑️ Clear Chat", key="clear_chat_button"):
@@ -890,10 +447,20 @@ def main():
                             else:
                                 formatted_query = "No RAG query available"
                             
+                            # Extract filters from active filters
+                            filters_used = {
+                                "sources": st.session_state.active_filters.get('sources', []),
+                                "years": st.session_state.active_filters.get('years', []),
+                                "districts": st.session_state.active_filters.get('districts', []),
+                                "filenames": st.session_state.active_filters.get('filenames', [])
+                            }
+                            
                             retrieval_entry = {
                                 "conversation_up_to": serialize_messages(st.session_state.messages),
                                 "rag_query_expansion": formatted_query,
-                                "docs_retrieved": serialize_documents(sources)
+                                "docs_retrieved": serialize_documents(sources),
+                                "filters_applied": filters_used,
+                                "timestamp": time.time()
                             }
                             st.session_state.rag_retrieval_history.append(retrieval_entry)
                     else:
@@ -954,9 +521,18 @@ def main():
                 for i, doc in enumerate(sources):  # Show all documents
                     # Get relevance score and ID if available
                     metadata = getattr(doc, 'metadata', {})
-                    score = metadata.get('reranked_score', metadata.get('original_score', None))
-                    chunk_id = metadata.get('_id', 'Unknown')
-                    score_text = f" (Score: {score:.3f}, ID: {chunk_id[:8]}...)" if score is not None else f" (ID: {chunk_id[:8]}...)"
+                    # Handle both standard RAG scores and Gemini scores
+                    score = metadata.get('reranked_score') or metadata.get('original_score') or metadata.get('score')
+                    chunk_id = metadata.get('_id') or metadata.get('chunk_id', 'Unknown')
+                    if score is not None:
+                        try:
+                            score_text = f" (Score: {float(score):.3f})"
+                        except (ValueError, TypeError):
+                            score_text = ""
+                    else:
+                        score_text = ""
+                    if chunk_id and chunk_id != 'Unknown':
+                        score_text += f" (ID: {str(chunk_id)[:8]}...)" if score_text else f" (ID: {str(chunk_id)[:8]}...)"
                     
                     with st.expander(f"📄 Document {i+1}: {getattr(doc, 'metadata', {}).get('filename', 'Unknown')[:50]}...{score_text}"):
                         # Display document metadata with emojis
@@ -1034,7 +610,7 @@ def main():
                 
                 submitted = st.form_submit_button(
                     "📤 Submit Feedback", 
-                    use_container_width=True,
+                    width='stretch',
                     disabled=submit_disabled
                 )
                 
@@ -1046,16 +622,18 @@ def main():
                     st.write("🔍 **Debug: Feedback Data Being Submitted:**")
                     
                     # Extract transcript from messages
-                    transcript = extract_transcript(st.session_state.messages)
+                    transcript = feedback_manager.extract_transcript(st.session_state.messages)
                     
                     # Build retrievals structure
-                    retrievals = build_retrievals_structure(
+                    retrievals = feedback_manager.build_retrievals_structure(
+
                         st.session_state.rag_retrieval_history.copy() if st.session_state.rag_retrieval_history else [],
                         st.session_state.messages
                     )
                     
                     # Build feedback_score_related_retrieval_docs
-                    feedback_score_related_retrieval_docs = build_feedback_score_related_retrieval_docs(
+
+                    feedback_score_related_retrieval_docs = feedback_manager.build_feedback_score_related_retrieval_docs(
                         is_feedback_about_last_retrieval,
                         st.session_state.messages,
                         st.session_state.rag_retrieval_history.copy() if st.session_state.rag_retrieval_history else []
@@ -1085,7 +663,7 @@ def main():
                     # Create UserFeedback dataclass instance
                     feedback_obj = None  # Initialize outside try block
                     try:
-                        feedback_obj = create_feedback_from_dict(feedback_dict)
+                        feedback_obj = feedback_manager.create_feedback_from_dict(feedback_dict)
                         print(f"✅ FEEDBACK SUBMISSION: Feedback object created - ID={feedback_obj.feedback_id}")
                         st.write(f"✅ **Feedback Object Created**")
                         st.write(f"- Feedback ID: {feedback_obj.feedback_id}")
@@ -1141,7 +719,7 @@ def main():
                                         logger.info("📤 SNOWFLAKE UI: Attempting to save feedback to Snowflake...")
                                         print("📤 SNOWFLAKE UI: Attempting to save feedback to Snowflake...")
                                         
-                                        snowflake_success = save_to_snowflake(feedback_obj)
+                                        snowflake_success = feedback_manager.save_to_snowflake(feedback_obj)
                                         if snowflake_success:
                                             logger.info("✅ SNOWFLAKE UI: Successfully saved to Snowflake")
                                             print("✅ SNOWFLAKE UI: Successfully saved to Snowflake")
@@ -1214,20 +792,111 @@ def main():
         st.markdown("---")
         st.markdown("#### 📊 Retrieval History")
         
-        with st.expander(f"View {len(st.session_state.rag_retrieval_history)} retrieval entries", expanded=False):
+        with st.expander(f"View {len(st.session_state.rag_retrieval_history)} retrieval entries", expanded=True):
             for idx, entry in enumerate(st.session_state.rag_retrieval_history, 1):
-                st.markdown(f"**Retrieval #{idx}**")
+                st.markdown(f"### **Retrieval #{idx}**")
+                
+                # Display timestamp if available
+                if entry.get("timestamp"):
+                    timestamp_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(entry["timestamp"]))
+                    st.caption(f"🕐 {timestamp_str}")
                 
                 # Display the actual RAG query
                 rag_query_expansion = entry.get("rag_query_expansion", "No query available")
+                st.markdown("**🔍 RAG Query:**")
                 st.code(rag_query_expansion, language="text")
                 
+                # Display filters used
+                filters_applied = entry.get("filters_applied", {})
+                if filters_applied and any(filters_applied.values()):
+                    st.markdown("**🎯 Filters Applied:**")
+                    filter_display = {}
+                    if filters_applied.get("sources"):
+                        filter_display["Sources"] = filters_applied["sources"]
+                    if filters_applied.get("years"):
+                        filter_display["Years"] = filters_applied["years"]
+                    if filters_applied.get("districts"):
+                        filter_display["Districts"] = filters_applied["districts"]
+                    if filters_applied.get("filenames"):
+                        filter_display["Filenames"] = filters_applied["filenames"]
+                    
+                    if filter_display:
+                        st.json(filter_display)
+                    else:
+                        st.info("No filters applied")
+                else:
+                    st.info("No filters applied")
+                
+                # Display conversation history up to retrieval point
+                conversation_up_to = entry.get("conversation_up_to", [])
+                if conversation_up_to:
+                    st.markdown("**💬 Conversation History (up to retrieval point):**")
+                    with st.expander(f"View {len(conversation_up_to)} messages", expanded=False):
+                        for msg_idx, msg in enumerate(conversation_up_to, 1):
+                            role = msg.get("type", "unknown")
+                            content = msg.get("content", "")
+                            
+                            if role == "HumanMessage" or role == "human":
+                                st.markdown(f"**👤 User {msg_idx}:** {content[:200]}{'...' if len(content) > 200 else ''}")
+                            elif role == "AIMessage" or role == "ai":
+                                st.markdown(f"**🤖 Assistant {msg_idx}:** {content[:200]}{'...' if len(content) > 200 else ''}")
+                else:
+                    st.info("No conversation history available")
+                
+                # Display documents retrieved
+                docs_retrieved = entry.get("docs_retrieved", [])
+                if docs_retrieved:
+                    st.markdown(f"**📄 Documents Retrieved ({len(docs_retrieved)}):**")
+                    with st.expander(f"View {len(docs_retrieved)} documents", expanded=False):
+                        for doc_idx, doc in enumerate(docs_retrieved, 1):
+                            st.markdown(f"**Document {doc_idx}:**")
+                            
+                            # Display metadata
+                            metadata = doc.get("metadata", {})
+                            if metadata:
+                                col1, col2, col3 = st.columns(3)
+                                with col1:
+                                    st.write(f"📄 **File:** {metadata.get('filename', 'Unknown')}")
+                                with col2:
+                                    st.write(f"🏛️ **Source:** {metadata.get('source', 'Unknown')}")
+                                with col3:
+                                    st.write(f"📅 **Year:** {metadata.get('year', 'Unknown')}")
+                                
+                                # Additional metadata
+                                if metadata.get('district'):
+                                    st.write(f"📍 **District:** {metadata.get('district')}")
+                                if metadata.get('page'):
+                                    st.write(f"📖 **Page:** {metadata.get('page')}")
+                                if metadata.get('score') is not None:
+                                    st.write(f"⭐ **Score:** {metadata.get('score'):.3f}" if isinstance(metadata.get('score'), (int, float)) else f"⭐ **Score:** {metadata.get('score')}")
+                            
+                            # Display content preview (first 200 chars)
+                            content = doc.get("content", doc.get("page_content", ""))
+                            if content:
+                                st.markdown("**Content Preview:**")
+                                st.text_area(
+                                    "Content Preview",
+                                    value=content[:200] + ("..." if len(content) > 200 else ""),
+                                    height=100,
+                                    disabled=True,
+                                    label_visibility="collapsed",
+                                    key=f"retrieval_{idx}_doc_{doc_idx}_preview"
+                                )
+                            
+                            if doc_idx < len(docs_retrieved):
+                                st.markdown("---")
+                else:
+                    st.info("No documents retrieved")
+                
                 # Display summary stats
+                st.markdown("**📊 Summary:**")
                 st.json({
-                    "conversation_length": len(entry.get("conversation_up_to", [])),
-                    "documents_retrieved": len(entry.get("docs_retrieved", []))
+                    "conversation_length": len(conversation_up_to),
+                    "documents_retrieved": len(docs_retrieved)
                 })
-                st.markdown("---")
+                
+                if idx < len(st.session_state.rag_retrieval_history):
+                    st.markdown("---")
     
     # Example Questions Section
     st.markdown("---")
@@ -1307,93 +976,6 @@ def main():
         st.caption("💡 Tip: Use specific terms from the documents (e.g., 'PDM', 'SACCOs', 'FY 2022/23')")
     
 
-    # Store selected question for next render (handled in input section above)
-    # This ensures the question populates the input field correctly
-    
-    # Example Questions Section
-    st.markdown("---")
-    st.markdown(
-        "<h3 class='example-questions-header'>💡 Example Questions</h3>",
-        unsafe_allow_html=True
-    )
-    st.markdown(
-        "<p class='example-questions-description'>Click on any question below to use it, or modify the editable examples:</p>",
-        unsafe_allow_html=True
-    )
-    
-    # Initialize example question state
-    if 'custom_question_1' not in st.session_state:
-        st.session_state.custom_question_1 = "How were administrative costs managed in the PDM implementation, and what issues arose with budget execution regarding staff salaries?"
-    if 'custom_question_2' not in st.session_state:
-        st.session_state.custom_question_2 = "What did the National Coordinator say about the release of funds for PDM administrative costs in the letter dated 29th September 2022 and how did the funding received affect the activities of the PDCs and PDM SACCOs in the FY 2022/23?"
-    
-    # Question 1: Filename insights (fixed, clickable)
-    st.markdown("#### 📄 Question 1: List insights from a specific file")
-    col1, col2 = st.columns([3, 1])
-    with col1:
-        example_q1 = "List couple of insights from the filename."
-        st.markdown(f"**Example:** `{example_q1}`")
-        st.info("💡 **Filter to apply:** Select a Filename from the sidebar panel before asking this question.")
-    with col2:
-        if st.button("📋 Use This Question", key="use_example_1", use_container_width=True):
-            st.session_state.pending_question = example_q1
-            st.session_state.input_counter = (st.session_state.get('input_counter', 0) + 1) % 1000
-            st.rerun()
-    
-    st.markdown("---")
-    
-    # Questions 2 & 3: Editable examples
-    st.markdown("#### ✏️ Customizable Questions (Edit and use)")
-    
-    # Question 2
-    # st.markdown("**Question 2:**")
-    custom_q1 = st.text_area(
-        "Edit question 2:",
-        value=st.session_state.custom_question_1,
-        height=80,
-        key="edit_question_2",
-        help="Modify this question to fit your needs, then click 'Use This Question'"
-    )
-    col1, col2 = st.columns([1, 4])
-    with col1:
-        if st.button("📋 Use Question 2", key="use_custom_1", use_container_width=True):
-            if custom_q1.strip():
-                st.session_state.pending_question = custom_q1.strip()
-                st.session_state.custom_question_1 = custom_q1.strip()
-                st.session_state.input_counter = (st.session_state.get('input_counter', 0) + 1) % 1000
-                st.rerun()
-            else:
-                st.warning("Please enter a question first!")
-    with col2:
-        st.caption("💡 Tip: Add specific details like dates, names, or amounts to get more precise answers")
-    
-    st.info("💡 **Filter to apply:** Select District(s) and Year(s) sidebar panel before asking this question.")
-
-    st.markdown("---")
-    
-    # Question 3
-    # st.markdown("**Question 3:**")
-    custom_q2 = st.text_area(
-        "Edit question 3:",
-        value=st.session_state.custom_question_2,
-        height=80,
-        key="edit_question_3",
-        help="Modify this question to fit your needs, then click 'Use This Question'"
-    )
-    col1, col2 = st.columns([1, 4])
-    with col1:
-        if st.button("📋 Use Question 3", key="use_custom_2", use_container_width=True):
-            if custom_q2.strip():
-                st.session_state.pending_question = custom_q2.strip()
-                st.session_state.custom_question_2 = custom_q2.strip()
-                st.session_state.input_counter = (st.session_state.get('input_counter', 0) + 1) % 1000
-                st.rerun()
-            else:
-                st.warning("Please enter a question first!")
-    with col2:
-        st.caption("💡 Tip: Use specific terms from the documents (e.g., 'PDM', 'SACCOs', 'FY 2022/23')")
-    
-
     # Store selected question for next render (handled in input section above)
     # This ensures the question populates the input field correctly
     

src/agents/__init__.py

@@ -0,0 +1,10 @@
+"""
+Agent modules for chatbot implementations
+"""
+
+from .smart_chatbot import get_chatbot as get_smart_chatbot
+from .multi_agent_chatbot import get_multi_agent_chatbot
+from .gemini_chatbot import get_gemini_chatbot
+
+__all__ = ["get_smart_chatbot", "get_multi_agent_chatbot", "get_gemini_chatbot"]
+

src/agents/gemini_chatbot.py

@@ -0,0 +1,372 @@
+"""
+Gemini File Search Chatbot (Beta Version)
+
+This chatbot uses Google Gemini File Search API for RAG.
+It provides a simpler architecture: Main Agent + Gemini Agent
+"""
+
+import os
+import json
+import time
+import logging
+import traceback
+from pathlib import Path
+from typing import Dict, List, Any, Optional, TypedDict
+
+from langgraph.graph import StateGraph, END
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+
+from src.gemini.file_search import GeminiFileSearchClient, GeminiFileSearchResult
+from src.config.paths import CONVERSATIONS_DIR
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+class GeminiState(TypedDict):
+    """State for Gemini chatbot conversation flow"""
+    conversation_id: str
+    messages: List[Any]
+    current_query: str
+    query_context: Optional[Dict[str, Any]]
+    gemini_result: Optional[GeminiFileSearchResult]
+    final_response: Optional[str]
+    agent_logs: List[str]
+    conversation_context: Dict[str, Any]
+    session_start_time: float
+    last_ai_message_time: float
+    filters: Optional[Dict[str, Any]]
+
+
+class GeminiRAGChatbot:
+    """Gemini File Search RAG chatbot (Beta version)"""
+    
+    def __init__(self):
+        """Initialize the Gemini chatbot"""
+        logger.info("🤖 INITIALIZING: Gemini File Search Chatbot (Beta)")
+        
+        # Initialize Gemini File Search client
+        try:
+            self.gemini_client = GeminiFileSearchClient()
+            logger.info("✅ Gemini File Search client initialized")
+        except Exception as e:
+            logger.error(f"❌ Failed to initialize Gemini client: {e}")
+            raise RuntimeError(f"Gemini client initialization failed: {e}")
+        
+        # Build the LangGraph with LangSmith tracing if enabled
+        self.graph = self._build_graph()
+        
+        # Enable LangSmith tracing if configured
+        langsmith_enabled = os.getenv("LANGCHAIN_TRACING_V2", "false").lower() == "true"
+        if langsmith_enabled:
+            logger.info("🔍 LangSmith tracing enabled")
+            langsmith_project = os.getenv("LANGCHAIN_PROJECT", "gemini-chatbot")
+            logger.info(f"📊 LangSmith project: {langsmith_project}")
+        
+        # Conversations directory
+        self.conversations_dir = CONVERSATIONS_DIR
+        try:
+            self.conversations_dir.mkdir(parents=True, mode=0o777, exist_ok=True)
+        except (PermissionError, OSError) as e:
+            logger.warning(f"Could not create conversations directory: {e}")
+            self.conversations_dir = Path("conversations")
+            self.conversations_dir.mkdir(parents=True, mode=0o777, exist_ok=True)
+        
+        logger.info("✅ Gemini File Search Chatbot initialized")
+    
+    def _build_graph(self) -> StateGraph:
+        """Build the LangGraph for Gemini chatbot"""
+        graph = StateGraph(GeminiState)
+        
+        # Add nodes
+        graph.add_node("main_agent", self._main_agent)
+        graph.add_node("gemini_agent", self._gemini_agent)
+        
+        # Define the flow
+        graph.set_entry_point("main_agent")
+        graph.add_edge("main_agent", "gemini_agent")
+        graph.add_edge("gemini_agent", END)
+        
+        return graph.compile()
+    
+    def _main_agent(self, state: GeminiState) -> GeminiState:
+        """Main Agent: Extracts filters and prepares query"""
+        logger.info("🎯 MAIN AGENT: Processing query")
+        
+        query = state["current_query"]
+        messages = state["messages"]
+        
+        # Extract UI filters if present in query
+        ui_filters = self._extract_ui_filters(query)
+        
+        # Extract context from conversation
+        context = self._extract_context_from_conversation(messages, ui_filters)
+        
+        # Store context and filters
+        state["query_context"] = context
+        state["filters"] = context.get("filters", {})
+        
+        logger.info(f"🎯 MAIN AGENT: Filters extracted: {state['filters']}")
+        
+        return state
+    
+    def _gemini_agent(self, state: GeminiState) -> GeminiState:
+        """Gemini Agent: Performs file search and generates response"""
+        logger.info("🔍 GEMINI AGENT: Starting file search")
+        
+        query = state["current_query"]
+        filters = state.get("filters", {})
+        
+        # Perform Gemini file search
+        try:
+            result = self.gemini_client.search(query=query, filters=filters)
+            logger.info(f"✅ GEMINI AGENT: Search completed, {len(result.sources)} sources found")
+            
+            # Enhance response with document references
+            enhanced_response = self._enhance_response_with_references(
+                result.answer, 
+                result.sources,
+                query
+            )
+            
+            state["gemini_result"] = result
+            state["final_response"] = enhanced_response
+            state["last_ai_message_time"] = time.time()
+            
+            state["agent_logs"].append(f"GEMINI AGENT: Found {len(result.sources)} sources")
+            
+        except Exception as e:
+            logger.error(f"❌ GEMINI AGENT ERROR: {e}")
+            traceback.print_exc()
+            state["final_response"] = "I apologize, but I encountered an error while searching. Please try again."
+            state["last_ai_message_time"] = time.time()
+        
+        return state
+    
+    def _enhance_response_with_references(self, answer: str, sources: List[Any], query: str) -> str:
+        """Enhance Gemini response to include document references"""
+        if not sources or not answer:
+            return answer
+        
+        # Use LLM to intelligently add document references
+        try:
+            from src.llm.adapters import get_llm_client
+            llm = get_llm_client()
+            
+            # Prepare document summaries for the LLM
+            doc_summaries = []
+            for idx, doc in enumerate(sources, 1):
+                metadata = getattr(doc, 'metadata', {}) if hasattr(doc, 'metadata') else (doc if isinstance(doc, dict) else {})
+                content = getattr(doc, 'page_content', '') if hasattr(doc, 'page_content') else (doc.get('content', '') if isinstance(doc, dict) else '')
+                
+                filename = metadata.get('filename', 'Unknown') if isinstance(metadata, dict) else 'Unknown'
+                year = metadata.get('year', 'Unknown') if isinstance(metadata, dict) else 'Unknown'
+                source = metadata.get('source', 'Unknown') if isinstance(metadata, dict) else 'Unknown'
+                
+                doc_summaries.append(f"[Doc {idx}] {filename} ({year}, {source}): {content[:300]}...")
+            
+            prompt = f"""You are enhancing a response from a document search system. The original response is:
+
+{answer}
+
+The following documents were retrieved and used to generate this response:
+
+{chr(10).join(doc_summaries)}
+
+CRITICAL RULES:
+1. The response should ONLY contain information from the retrieved documents listed above
+2. If the response mentions information NOT found in the retrieved documents, you must REMOVE or CORRECT that information
+3. Add document references [Doc i] at the end of sentences that use information from specific documents
+4. Only reference documents that are actually used in the response
+5. If the response mentions years, sources, or data that don't match the retrieved documents, you must correct it
+6. Keep the response natural and conversational
+7. Don't change the core content that matches the documents, just add references where appropriate
+8. If multiple documents support the same claim, use [Doc i, Doc j] format
+9. If the response contains information that cannot be verified in the retrieved documents, add a note like: "Note: This information may not be in the retrieved documents."
+
+Return ONLY the enhanced response with references added and any corrections made. Do not include any explanation or meta-commentary."""
+
+            enhanced = llm.invoke(prompt).content if hasattr(llm.invoke(prompt), 'content') else str(llm.invoke(prompt))
+            
+            # Fallback: if LLM fails, just return original
+            if not enhanced or len(enhanced) < len(answer) * 0.5:
+                logger.warning("LLM enhancement failed, using original response")
+                return answer
+            
+            return enhanced
+            
+        except Exception as e:
+            logger.warning(f"Failed to enhance response with references: {e}")
+            # Fallback: add basic references at the end
+            if sources:
+                ref_list = ", ".join([f"[Doc {i+1}]" for i in range(min(len(sources), 5))])
+                return f"{answer}\n\n*Based on documents: {ref_list}*"
+            return answer
+    
+    def _extract_ui_filters(self, query: str) -> Dict[str, List[str]]:
+        """Extract UI filters from query if present"""
+        filters = {}
+        
+        if "FILTER CONTEXT:" in query:
+            filter_section = query.split("FILTER CONTEXT:")[1]
+            if "USER QUERY:" in filter_section:
+                filter_section = filter_section.split("USER QUERY:")[0]
+            filter_section = filter_section.strip()
+            
+            if "Sources:" in filter_section:
+                sources_line = [line for line in filter_section.split('\n') if line.strip().startswith('Sources:')]
+                if sources_line:
+                    sources_str = sources_line[0].split("Sources:")[1].strip()
+                    if sources_str and sources_str != "None":
+                        filters["sources"] = [s.strip() for s in sources_str.split(",")]
+            
+            if "Years:" in filter_section:
+                years_line = [line for line in filter_section.split('\n') if line.strip().startswith('Years:')]
+                if years_line:
+                    years_str = years_line[0].split("Years:")[1].strip()
+                    if years_str and years_str != "None":
+                        filters["year"] = [y.strip() for y in years_str.split(",")]
+            
+            if "Districts:" in filter_section:
+                districts_line = [line for line in filter_section.split('\n') if line.strip().startswith('Districts:')]
+                if districts_line:
+                    districts_str = districts_line[0].split("Districts:")[1].strip()
+                    if districts_str and districts_str != "None":
+                        filters["district"] = [d.strip() for d in districts_str.split(",")]
+            
+            if "Filenames:" in filter_section:
+                filenames_line = [line for line in filter_section.split('\n') if line.strip().startswith('Filenames:')]
+                if filenames_line:
+                    filenames_str = filenames_line[0].split("Filenames:")[1].strip()
+                    if filenames_str and filenames_str != "None":
+                        filters["filenames"] = [f.strip() for f in filenames_str.split(",")]
+        
+        return filters
+    
+    def _extract_context_from_conversation(
+        self,
+        messages: List[Any],
+        ui_filters: Dict[str, List[str]]
+    ) -> Dict[str, Any]:
+        """Extract context from conversation history"""
+        # Use UI filters if available
+        filters = ui_filters.copy() if ui_filters else {}
+        
+        # For Gemini, we pass filters directly to the search function
+        # The filters will be used to add context to the query
+        
+        return {
+            "filters": filters,
+            "has_filters": bool(filters)
+        }
+    
+    def chat(self, user_input: str, conversation_id: str = "default") -> Dict[str, Any]:
+        """Main chat interface"""
+        logger.info(f"💬 GEMINI CHAT: Processing '{user_input[:50]}...'")
+        
+        # Load conversation
+        conversation_file = self.conversations_dir / f"{conversation_id}.json"
+        conversation = self._load_conversation(conversation_file)
+        
+        # Add user message
+        conversation["messages"].append(HumanMessage(content=user_input))
+        
+        # Prepare state
+        state = GeminiState(
+            conversation_id=conversation_id,
+            messages=conversation["messages"],
+            current_query=user_input,
+            query_context=None,
+            gemini_result=None,
+            final_response=None,
+            agent_logs=[],
+            conversation_context=conversation.get("context", {}),
+            session_start_time=conversation["session_start_time"],
+            last_ai_message_time=conversation["last_ai_message_time"],
+            filters=None
+        )
+        
+        # Run graph
+        final_state = self.graph.invoke(state)
+        
+        # Add AI response to conversation
+        if final_state["final_response"]:
+            conversation["messages"].append(AIMessage(content=final_state["final_response"]))
+        
+        # Update conversation
+        conversation["last_ai_message_time"] = final_state["last_ai_message_time"]
+        conversation["context"] = final_state["conversation_context"]
+        
+        # Save conversation
+        self._save_conversation(conversation_file, conversation)
+        
+        # Format sources for display
+        sources = []
+        if final_state.get("gemini_result"):
+            sources = self.gemini_client.format_sources_for_display(final_state["gemini_result"])
+        
+        return {
+            'response': final_state["final_response"] or "I apologize, but I couldn't process your request.",
+            'rag_result': {
+                'sources': sources,
+                'answer': final_state["final_response"]
+            },
+            'agent_logs': final_state["agent_logs"],
+            'actual_rag_query': final_state["current_query"]
+        }
+    
+    def _load_conversation(self, conversation_file: Path) -> Dict[str, Any]:
+        """Load conversation from file"""
+        if conversation_file.exists():
+            try:
+                with open(conversation_file) as f:
+                    data = json.load(f)
+                    messages = []
+                    for msg_data in data.get("messages", []):
+                        if msg_data["type"] == "human":
+                            messages.append(HumanMessage(content=msg_data["content"]))
+                        elif msg_data["type"] == "ai":
+                            messages.append(AIMessage(content=msg_data["content"]))
+                    data["messages"] = messages
+                    return data
+            except Exception as e:
+                logger.warning(f"Could not load conversation: {e}")
+        
+        return {
+            "messages": [],
+            "session_start_time": time.time(),
+            "last_ai_message_time": time.time(),
+            "context": {}
+        }
+    
+    def _save_conversation(self, conversation_file: Path, conversation: Dict[str, Any]):
+        """Save conversation to file"""
+        try:
+            conversation_file.parent.mkdir(parents=True, mode=0o777, exist_ok=True)
+            
+            messages_data = []
+            for msg in conversation["messages"]:
+                if isinstance(msg, HumanMessage):
+                    messages_data.append({"type": "human", "content": msg.content})
+                elif isinstance(msg, AIMessage):
+                    messages_data.append({"type": "ai", "content": msg.content})
+            
+            conversation_data = {
+                "messages": messages_data,
+                "session_start_time": conversation["session_start_time"],
+                "last_ai_message_time": conversation["last_ai_message_time"],
+                "context": conversation.get("context", {})
+            }
+            
+            with open(conversation_file, 'w') as f:
+                json.dump(conversation_data, f, indent=2)
+                
+        except Exception as e:
+            logger.error(f"Could not save conversation: {e}")
+
+
+def get_gemini_chatbot():
+    """Get Gemini chatbot instance"""
+    return GeminiRAGChatbot()
+

multi_agent_chatbot.py → src/agents/multi_agent_chatbot.py

@@ -208,6 +208,59 @@ class MultiAgentRAGChatbot:
         logger.info(f"   Sources: {self.source_whitelist}")
         logger.info(f"   Districts: {len(self.district_whitelist)} districts (first 10: {self.district_whitelist[:10]})")
     
+    def _normalize_district_name(self, district: str) -> Optional[str]:
+        """Normalize district name with fuzzy matching for common misspellings."""
+        if not district:
+            return None
+        
+        district = district.strip()
+        
+        # Direct match
+        if district in self.district_whitelist:
+            return district
+        
+        # Remove "District" suffix
+        district_name = district.replace(" District", "").replace(" district", "").strip()
+        if district_name in self.district_whitelist:
+            return district_name
+        
+        # Common misspellings mapping
+        misspelling_map = {
+            "kalagala": "Kalangala",
+            "Kalagala": "Kalangala",
+            "KALAGALA": "Kalangala",
+            "kalangala": "Kalangala",
+            "gulu": "Gulu",
+            "GULU": "Gulu",
+            "kampala": "Kampala",
+            "KAMPALA": "Kampala",
+        }
+        
+        # Check misspelling map (case-insensitive)
+        district_lower = district_name.lower()
+        if district_lower in misspelling_map:
+            corrected = misspelling_map[district_lower]
+            if corrected in self.district_whitelist:
+                return corrected
+        
+        # Fuzzy matching for similar names (simple Levenshtein-like check)
+        # Check if the district name is very similar to any whitelist entry
+        for whitelist_district in self.district_whitelist:
+            # Case-insensitive comparison
+            if district_name.lower() == whitelist_district.lower():
+                return whitelist_district
+            
+            # Check if one is a substring of the other (for partial matches)
+            if len(district_name) >= 4 and len(whitelist_district) >= 4:
+                if district_name.lower() in whitelist_district.lower() or whitelist_district.lower() in district_name.lower():
+                    # Only return if it's a strong match (at least 80% of characters match)
+                    min_len = min(len(district_name), len(whitelist_district))
+                    max_len = max(len(district_name), len(whitelist_district))
+                    if min_len / max_len >= 0.8:
+                        return whitelist_district
+        
+        return None
+    
     def _build_graph(self) -> StateGraph:
         """Build the multi-agent LangGraph"""
         graph = StateGraph(MultiAgentState)
@@ -512,6 +565,10 @@ class MultiAgentRAGChatbot:
    - If user mentions "Lwengo, Kiboga and Namutumba" - extract ["Lwengo", "Kiboga", "Namutumba"] (as JSON array)
    - If user mentions "Lwengo District and Kiboga District" - extract ["Lwengo", "Kiboga"] (as JSON array, remove "District" suffix)
    - Always return districts as JSON arrays when multiple districts are mentioned
+   - **COMMON MISSPELLINGS**: Handle common misspellings intelligently:
+     * "Kalagala" (missing 'n') should be extracted as "Kalangala"
+     * "kalagala", "Kalagala", "KALAGALA" should all be normalized to "Kalangala"
+     * Similar case-insensitive variations should be normalized to the correct district name
    - If no exact matches found, set extracted values to null
 
 4. **FILENAME FILTERING (MUTUALLY EXCLUSIVE)**:
@@ -656,13 +713,9 @@ Analyze this query using ONLY the exact values provided above:""")
                     # Validate each district in the array
                     valid_districts = []
                     for district in extracted_district:
-                        if district in self.district_whitelist:
-                            valid_districts.append(district)
-                        else:
-                            # Try removing "District" suffix
-                            district_name = district.replace(" District", "").replace(" district", "")
-                            if district_name in self.district_whitelist:
-                                valid_districts.append(district_name)
+                        normalized = self._normalize_district_name(district)
+                        if normalized:
+                            valid_districts.append(normalized)
                     
                     if valid_districts:
                         extracted_district = valid_districts[0] if len(valid_districts) == 1 else valid_districts
@@ -671,16 +724,15 @@ Analyze this query using ONLY the exact values provided above:""")
                         logger.warning(f"⚠️ No valid districts found in: '{extracted_district}'")
                         extracted_district = None
                 else:
-                    # Single district validation
-                    if extracted_district not in self.district_whitelist:
-                        # Try removing "District" suffix
-                        district_name = extracted_district.replace(" District", "").replace(" district", "")
-                        if district_name in self.district_whitelist:
-                            logger.info(f"🔍 QUERY ANALYSIS: Normalized district '{extracted_district}' to '{district_name}'")
-                            extracted_district = district_name
-                        else:
-                            logger.warning(f"⚠️ Invalid district extracted: '{extracted_district}' not in whitelist")
-                            extracted_district = None
+                    # Single district validation with fuzzy matching
+                    normalized = self._normalize_district_name(extracted_district)
+                    if normalized:
+                        if normalized != extracted_district:
+                            logger.info(f"🔍 QUERY ANALYSIS: Normalized district '{extracted_district}' to '{normalized}'")
+                        extracted_district = normalized
+                    else:
+                        logger.warning(f"⚠️ Invalid district extracted: '{extracted_district}' not in whitelist")
+                        extracted_district = None
             
             # Validate source (handle both single values and arrays)
             if extracted_source:
@@ -918,6 +970,23 @@ Rewrite the best retrieval query:""")
                 logger.info(f"🔧 FILTER BUILDING: Added districts filter from UI: {context.ui_filters['districts']} → normalized: {normalized_districts}")
             
             # Merge with extracted context for missing filters
+            if not filters.get("district") and context.extracted_district:
+                # Normalize district names using the normalization function
+                if isinstance(context.extracted_district, list):
+                    normalized_districts = []
+                    for d in context.extracted_district:
+                        normalized = self._normalize_district_name(d)
+                        if normalized:
+                            normalized_districts.append(normalized)
+                    if normalized_districts:
+                        filters["district"] = normalized_districts
+                        logger.info(f"🔧 FILTER BUILDING: Added districts filter from context: {context.extracted_district} → normalized: {normalized_districts}")
+                else:
+                    normalized = self._normalize_district_name(context.extracted_district)
+                    if normalized:
+                        filters["district"] = [normalized]
+                        logger.info(f"🔧 FILTER BUILDING: Added district filter from context: {context.extracted_district} → normalized: {normalized}")
+            
             if not filters.get("year") and context.extracted_year:
                 # Handle both single values and arrays
                 if isinstance(context.extracted_year, list):
@@ -926,16 +995,6 @@ Rewrite the best retrieval query:""")
                     filters["year"] = [context.extracted_year]
                 logger.info(f"🔧 FILTER BUILDING: Added extracted year filter (UI missing): {context.extracted_year}")
             
-            if not filters.get("district") and context.extracted_district:
-                # Handle both single values and arrays
-                if isinstance(context.extracted_district, list):
-                    # Normalize district names to title case (match Qdrant metadata format)
-                    normalized = [d.title() for d in context.extracted_district]
-                    filters["district"] = normalized
-                else:
-                    filters["district"] = [context.extracted_district.title()]
-                logger.info(f"🔧 FILTER BUILDING: Added extracted district filter (UI missing): {context.extracted_district}")
-            
             if not filters.get("sources") and context.extracted_source:
                 # Handle both single values and arrays
                 if isinstance(context.extracted_source, list):
@@ -963,12 +1022,21 @@ Rewrite the best retrieval query:""")
                 logger.info(f"🔧 FILTER BUILDING: Added extracted year filter: {context.extracted_year}")
             
             if context.extracted_district:
-                # Handle both single values and arrays
+                # Normalize district names using the normalization function
                 if isinstance(context.extracted_district, list):
-                    filters["district"] = context.extracted_district
+                    normalized_districts = []
+                    for d in context.extracted_district:
+                        normalized = self._normalize_district_name(d)
+                        if normalized:
+                            normalized_districts.append(normalized)
+                    if normalized_districts:
+                        filters["district"] = normalized_districts
+                        logger.info(f"🔧 FILTER BUILDING: Added districts filter from context: {context.extracted_district} → normalized: {normalized_districts}")
                 else:
-                    filters["district"] = [context.extracted_district]
-                logger.info(f"🔧 FILTER BUILDING: Added extracted district filter: {context.extracted_district}")
+                    normalized = self._normalize_district_name(context.extracted_district)
+                    if normalized:
+                        filters["district"] = [normalized]
+                        logger.info(f"🔧 FILTER BUILDING: Added district filter from context: {context.extracted_district} → normalized: {normalized}")
         
         logger.info(f"🔧 FILTER BUILDING: Final filters: {filters}")
         return filters
@@ -978,49 +1046,233 @@ Rewrite the best retrieval query:""")
         logger.info("💬 RESPONSE GENERATION: Starting conversational response generation")
         logger.info(f"💬 RESPONSE GENERATION: Processing {len(documents)} documents")
         logger.info(f"💬 RESPONSE GENERATION: Query: '{query[:50]}...'")
+        logger.info(f"💬 RESPONSE GENERATION: Conversation history: {len(messages)} messages")
+        
+        # Build conversation history context
+        conversation_context = self._build_conversation_context(messages)
+        
+        # Build detailed document information
+        document_details = self._build_document_details(documents)
+        
+        # Extract correct district/source/year names from documents (to correct misspellings)
+        correct_names = self._extract_correct_names_from_documents(documents)
         
         # Create response prompt
         logger.info(f"💬 RESPONSE GENERATION: Building response prompt")
         response_prompt = ChatPromptTemplate.from_messages([
             SystemMessage(content="""You are a helpful audit report assistant. Generate a natural, conversational response.
 
+CRITICAL RULES - NO HALLUCINATION:
+1. **ONLY use information from the retrieved documents provided below**
+2. **EVERY sentence with facts, numbers, or specific claims MUST have a [Doc i] reference**
+3. **If a document doesn't contain the information, DO NOT make it up**
+4. **If the user asks about a year/district that's NOT in the retrieved documents, explicitly state that**
+5. **Check the document years/districts before making any claims about them**
+6. **USE CORRECT NAMES**: If the conversation mentions a misspelled district/source name (e.g., "Kalagala"), use the CORRECT spelling from the document metadata (e.g., "Kalangala"). Always use the exact names from document metadata, not misspellings from conversation.
+
 RULES:
 1. Answer the user's question directly and clearly
-2. Use the retrieved documents as evidence
+2. Use ONLY the retrieved documents as evidence - DO NOT use your training data
 3. Be conversational, not technical
 4. Don't mention scores, retrieval details, or technical implementation
 5. If relevant documents were found, reference them naturally
-6. If no relevant documents, explain based on your knowledge (if you have it) or just say you do not have enough information.
-7. If the passages have useful facts or numbers, use them in your answer.
-8. When you use information from a passage, mention where it came from by using [Doc i] at the end of the sentence. i stands for the number of the document.
+6. If no relevant documents, say you do not have enough information - DO NOT hallucinate
+7. If the passages have useful facts or numbers, use them in your answer WITH references
+8. **MANDATORY**: When you use information from a passage, mention where it came from by using [Doc i] at the end of the sentence. i stands for the number of the document.
 9. Do not use the sentence 'Doc i says ...' to say where information came from.
 10. If the same thing is said in more than one document, you can mention all of them like this: [Doc i, Doc j, Doc k]
 11. Do not just summarize each passage one by one. Group your summaries to highlight the key parts in the explanation.
 12. If it makes sense, use bullet points and lists to make your answers easier to understand.
 13. You do not need to use every passage. Only use the ones that help answer the question.
-14. If the documents do not have the information needed to answer the question, just say you do not have enough information.
-
+14. **VERIFY**: Before mentioning any year, district, or number, check that it exists in the retrieved documents. If it doesn't, say "I don't have information about [year/district] in the retrieved documents."
+15. **NO HALLUCINATION**: If documents show years 2021, 2022, 2023 but user asks about 2020, DO NOT provide 2020 data. Instead say "The retrieved documents cover 2021-2023, but I don't have information for 2020."
+16. **USE CORRECT SPELLING**: Always use the district/source names exactly as they appear in the document metadata below, even if the conversation history has misspellings.
 
 TONE: Professional but friendly, like talking to a colleague."""),
-            HumanMessage(content=f"""User Question: {query}
+            HumanMessage(content=f"""Conversation History:
+{conversation_context}
+
+Current User Question: {query}
 
 Retrieved Documents: {len(documents)} documents found
 
+CORRECT NAMES TO USE (from document metadata - use these exact spellings):
+{correct_names}
+
+Full Document Details:
+{document_details}
+
 RAG Answer: {rag_answer}
 
-Generate a conversational response:""")
+CRITICAL: 
+- Responses should be grounded to what is available in the retrieved documents
+- If user asks about a specific year but documents show other years, or districts or sources then explicitly state "can't provide response on ... because ..."
+- Every factual claim MUST have [Doc i] reference
+- If information is not in documents, explicitly state it's not available
+- **USE THE CORRECT DISTRICT/SOURCE NAMES from the document metadata above, not misspellings from conversation**
+
+Generate a conversational response with proper document references:""")
         ])
         
         try:
             logger.info(f"💬 RESPONSE GENERATION: Calling LLM for final response")
             response = self.llm.invoke(response_prompt.format_messages())
             logger.info(f"💬 RESPONSE GENERATION: LLM response received: {response.content[:100]}...")
-            return response.content.strip()
+            
+            # Post-process response to ensure no hallucination
+            final_response = self._validate_and_enhance_response(
+                response.content.strip(),
+                documents,
+                query
+            )
+            
+            return final_response
         except Exception as e:
             logger.error(f"❌ RESPONSE GENERATION: Error during generation: {e}")
             logger.info(f"💬 RESPONSE GENERATION: Using RAG answer as fallback")
             return rag_answer  # Fallback to RAG answer
     
+    def _build_conversation_context(self, messages: List[Any]) -> str:
+        """Build conversation history context for response generation."""
+        if not messages:
+            return "No previous conversation."
+        
+        context_lines = []
+        # Show last 6 messages for context (to capture the current exchange)
+        for msg in messages[-6:]:
+            if isinstance(msg, HumanMessage):
+                context_lines.append(f"User: {msg.content}")
+            elif isinstance(msg, AIMessage):
+                context_lines.append(f"Assistant: {msg.content}")
+        
+        return "\n".join(context_lines) if context_lines else "No previous conversation."
+    
+    def _build_document_details(self, documents: List[Any]) -> str:
+        """Build detailed document information for response generation."""
+        if not documents:
+            return "No documents retrieved."
+        
+        details = []
+        for i, doc in enumerate(documents[:15], 1):  # Show up to 15 documents
+            metadata = getattr(doc, 'metadata', {}) if hasattr(doc, 'metadata') else (doc if isinstance(doc, dict) else {})
+            content = getattr(doc, 'page_content', '') if hasattr(doc, 'page_content') else (doc.get('content', '') if isinstance(doc, dict) else '')
+            
+            if isinstance(metadata, dict):
+                filename = metadata.get('filename', 'Unknown')
+                year = metadata.get('year', 'Unknown')
+                district = metadata.get('district', 'Unknown')
+                source = metadata.get('source', 'Unknown')
+                page = metadata.get('page', metadata.get('page_label', 'Unknown'))
+                
+                doc_info = f"[Doc {i}]"
+                doc_info += f"\n  Filename: {filename}"
+                doc_info += f"\n  Year: {year}"
+                doc_info += f"\n  District: {district}"
+                doc_info += f"\n  Source: {source}"
+                if page != 'Unknown':
+                    doc_info += f"\n  Page: {page}"
+                doc_info += f"\n  Content: {content[:300]}{'...' if len(content) > 300 else ''}"
+                details.append(doc_info)
+        
+        return "\n\n".join(details) if details else "No document details available."
+    
+    def _extract_correct_names_from_documents(self, documents: List[Any]) -> str:
+        """Extract correct district/source names from documents to correct misspellings."""
+        districts = set()
+        sources = set()
+        years = set()
+        
+        for doc in documents:
+            metadata = getattr(doc, 'metadata', {}) if hasattr(doc, 'metadata') else (doc if isinstance(doc, dict) else {})
+            if isinstance(metadata, dict):
+                if metadata.get('district'):
+                    districts.add(str(metadata['district']))
+                if metadata.get('source'):
+                    sources.add(str(metadata['source']))
+                if metadata.get('year'):
+                    years.add(str(metadata['year']))
+        
+        result = []
+        if districts:
+            result.append(f"Districts: {', '.join(sorted(districts))}")
+        if sources:
+            result.append(f"Sources: {', '.join(sorted(sources))}")
+        if years:
+            result.append(f"Years: {', '.join(sorted(years))}")
+        
+        if result:
+            return "\n".join(result) + "\n\nIMPORTANT: Use these EXACT spellings in your response, even if the conversation history has misspellings."
+        return "No metadata available."
+    
+    def _validate_and_enhance_response(self, response: str, documents: List[Any], query: str) -> str:
+        """Validate response and ensure all claims are referenced."""
+        # Extract years and districts from documents
+        doc_years = set()
+        doc_districts = set()
+        doc_sources = set()
+        
+        for doc in documents:
+            metadata = getattr(doc, 'metadata', {}) if hasattr(doc, 'metadata') else (doc if isinstance(doc, dict) else {})
+            if isinstance(metadata, dict):
+                if metadata.get('year'):
+                    doc_years.add(str(metadata['year']))
+                if metadata.get('district'):
+                    doc_districts.add(str(metadata['district']))
+                if metadata.get('source'):
+                    doc_sources.add(str(metadata['source']))
+        
+        # Correct misspellings in response using correct names from documents
+        response = self._correct_misspellings_in_response(response, doc_districts, doc_sources)
+        
+        # Check if response mentions years not in documents
+        year_pattern = r'\b(20\d{2})\b'
+        mentioned_years = set(re.findall(year_pattern, response))
+        
+        # Check if user query mentions a year
+        query_years = set(re.findall(year_pattern, query))
+        
+        # If user asks about a year not in documents, add a warning
+        missing_years = query_years - doc_years
+        if missing_years and doc_years:
+            warning = f"\n\n⚠️ Note: The retrieved documents cover years {', '.join(sorted(doc_years))}, but I don't have information for {', '.join(sorted(missing_years))} in the retrieved documents."
+            if warning not in response:
+                response = response + warning
+        
+        # Check if response has document references
+        doc_ref_pattern = r'\[Doc\s+\d+\]'
+        has_refs = bool(re.search(doc_ref_pattern, response))
+        
+        # If response has factual claims but no references, add a note
+        if not has_refs and len(documents) > 0:
+            # Check if response has numbers or specific claims (simple heuristic)
+            has_numbers = bool(re.search(r'\d+', response))
+            if has_numbers and len(response) > 50:
+                logger.warning("⚠️ Response contains factual claims but no document references")
+                # Don't modify response, but log the issue
+        
+        return response
+    
+    def _correct_misspellings_in_response(self, response: str, correct_districts: set, correct_sources: set) -> str:
+        """Correct common misspellings in response using correct names from documents."""
+        # Common misspelling mappings (e.g., "Kalagala" -> "Kalangala")
+        # We'll use fuzzy matching if needed, but first try direct corrections
+        
+        corrected = response
+        
+        # Correct district names
+        for correct_district in correct_districts:
+            # Try common misspellings
+            if correct_district.lower() == "kalangala":
+                # Replace "Kalagala" (missing 'n') with "Kalangala"
+                corrected = re.sub(r'\bKalagala\b', 'Kalangala', corrected, flags=re.IGNORECASE)
+            # Add more common misspellings as needed
+            # For now, we rely on the LLM to use correct names from the prompt
+        
+        # Correct source names if needed
+        # Add source corrections as needed in the future
+        
+        return corrected
+    
     def _generate_conversational_response_without_docs(self, query: str, messages: List[Any]) -> str:
         """Generate conversational response using only LLM knowledge and conversation history"""
         logger.info("💬 RESPONSE GENERATION (NO DOCS): Starting response generation without documents")

src/feedback/__init__.py

@@ -0,0 +1,152 @@
+"""
+Feedback Management Module
+
+This module provides a unified interface for handling user feedback,
+including data preparation, validation, and Snowflake storage.
+"""
+
+from typing import Dict, Any, List, Optional
+from langchain_core.messages import HumanMessage, AIMessage
+
+from .feedback_schema import UserFeedback, create_feedback_from_dict, generate_snowflake_schema_sql
+from .snowflake_connector import SnowflakeFeedbackConnector, save_to_snowflake, get_snowflake_connector_from_env
+
+
+class FeedbackManager:
+    """
+    Unified manager for feedback operations.
+    
+    This class provides a single interface for all feedback-related functionality,
+    including data preparation, validation, and storage.
+    """
+    
+    def __init__(self):
+        """Initialize the FeedbackManager"""
+        pass
+    
+    @staticmethod
+    def extract_transcript(messages: List[Any]) -> List[Dict[str, str]]:
+        """Extract transcript from messages - only user and bot messages, no extra metadata"""
+        transcript = []
+        for msg in messages:
+            if isinstance(msg, HumanMessage):
+                transcript.append({
+                    "role": "user",
+                    "content": str(msg.content) if hasattr(msg, 'content') else str(msg)
+                })
+            elif isinstance(msg, AIMessage):
+                transcript.append({
+                    "role": "assistant",
+                    "content": str(msg.content) if hasattr(msg, 'content') else str(msg)
+                })
+        return transcript
+    
+    @staticmethod
+    def build_retrievals_structure(rag_retrieval_history: List[Dict[str, Any]], messages: List[Any]) -> List[Dict[str, Any]]:
+        """Build retrievals structure from retrieval history"""
+        retrievals = []
+        
+        for entry in rag_retrieval_history:
+            # Get the user message that triggered this retrieval
+            # The entry has conversation_up_to which includes messages up to that point
+            conversation_up_to = entry.get("conversation_up_to", [])
+            
+            # Find the last user message in conversation_up_to (this is the trigger)
+            user_message_trigger = ""
+            for msg_dict in reversed(conversation_up_to):
+                if msg_dict.get("type") == "HumanMessage":
+                    user_message_trigger = msg_dict.get("content", "")
+                    break
+            
+            # Fallback: if not found in conversation_up_to, get from actual messages
+            # This handles edge cases where conversation_up_to might be incomplete
+            if not user_message_trigger:
+                # Find which retrieval this is (0-indexed)
+                retrieval_idx = rag_retrieval_history.index(entry)
+                # The user message that triggered this retrieval is at position (retrieval_idx * 2)
+                # because each retrieval is preceded by: user message, bot response, user message, ...
+                # But we need to account for the fact that the first retrieval happens after the first user message
+                user_msgs = [msg for msg in messages if isinstance(msg, HumanMessage)]
+                if retrieval_idx < len(user_msgs):
+                    user_message_trigger = str(user_msgs[retrieval_idx].content)
+                elif user_msgs:
+                    # Fallback to last user message
+                    user_message_trigger = str(user_msgs[-1].content)
+            
+            # Get retrieved documents and truncate content to 100 chars
+            docs_retrieved = entry.get("docs_retrieved", [])
+            retrieved_docs = []
+            for doc in docs_retrieved:
+                doc_copy = doc.copy()
+                # Truncate content to 100 characters (keep all other fields)
+                if "content" in doc_copy:
+                    doc_copy["content"] = doc_copy["content"][:100]
+                retrieved_docs.append(doc_copy)
+            
+            retrievals.append({
+                "retrieved_docs": retrieved_docs,
+                "user_message_trigger": user_message_trigger
+            })
+        
+        return retrievals
+    
+    @staticmethod
+    def build_feedback_score_related_retrieval_docs(
+        is_feedback_about_last_retrieval: bool,
+        messages: List[Any],
+        rag_retrieval_history: List[Dict[str, Any]]
+    ) -> Optional[Dict[str, Any]]:
+        """Build feedback_score_related_retrieval_docs structure"""
+        if not rag_retrieval_history:
+            return None
+        
+        # Get the relevant retrieval entry
+        if is_feedback_about_last_retrieval:
+            relevant_entry = rag_retrieval_history[-1]
+        else:
+            # If feedback is about all retrievals, use the last one as default
+            relevant_entry = rag_retrieval_history[-1]
+        
+        # Get conversation up to that point
+        conversation_up_to = relevant_entry.get("conversation_up_to", [])
+        
+        # Convert to transcript format (role/content)
+        conversation_up_to_point = []
+        for msg_dict in conversation_up_to:
+            if msg_dict.get("type") == "HumanMessage":
+                conversation_up_to_point.append({
+                    "role": "user",
+                    "content": msg_dict.get("content", "")
+                })
+            elif msg_dict.get("type") == "AIMessage":
+                conversation_up_to_point.append({
+                    "role": "assistant",
+                    "content": msg_dict.get("content", "")
+                })
+        
+        # Get retrieved docs with full content (not truncated)
+        retrieved_docs = relevant_entry.get("docs_retrieved", [])
+        
+        return {
+            "conversation_up_to_point": conversation_up_to_point,
+            "retrieved_docs": retrieved_docs
+        }
+    
+    @staticmethod
+    def create_feedback_from_dict(data: Dict[str, Any]) -> UserFeedback:
+        """Create UserFeedback instance from dictionary"""
+        return create_feedback_from_dict(data)
+    
+    @staticmethod
+    def save_to_snowflake(feedback: UserFeedback, table_name: Optional[str] = None) -> bool:
+        """Save feedback to Snowflake"""
+        return save_to_snowflake(feedback, table_name)
+    
+    @staticmethod
+    def generate_snowflake_schema_sql(table_name: Optional[str] = None) -> str:
+        """Generate Snowflake schema SQL"""
+        return generate_snowflake_schema_sql(table_name)
+
+
+__all__ = ["FeedbackManager", "UserFeedback", "save_to_snowflake", "SnowflakeFeedbackConnector"]
+

src/feedback/feedback_schema.py

@@ -0,0 +1,161 @@
+"""
+Feedback Schema for RAG Chatbot
+
+This module defines dataclasses for feedback data structures
+and provides Snowflake schema generation.
+"""
+import os
+from datetime import datetime
+from dataclasses import dataclass, asdict, field
+from typing import List, Optional, Dict, Any, Union
+
+
+
+@dataclass
+class RetrievedDocument:
+    """Single retrieved document metadata"""
+    doc_id: str
+    filename: str
+    page: int
+    score: float
+    content: str
+    metadata: Dict[str, Any]
+    
+
+@dataclass
+class RetrievalEntry:
+    """Single retrieval operation metadata"""
+    rag_query: str
+    documents_retrieved: List[RetrievedDocument]
+    conversation_length: int
+    filters_applied: Optional[Dict[str, Any]] = None
+    timestamp: Optional[float] = None
+    _raw_data: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class UserFeedback:
+    """User feedback submission data"""
+    feedback_id: str
+    open_ended_feedback: Optional[str]
+    score: int
+    is_feedback_about_last_retrieval: bool
+    conversation_id: str
+    timestamp: float
+    message_count: int
+    has_retrievals: bool
+    retrieval_count: int
+    transcript: List[Dict[str, str]]  # List of {"role": "user"/"assistant", "content": "..."}
+    retrievals: List[Dict[str, Any]]  # List of retrieval objects with retrieved_docs and user_message_trigger
+    feedback_score_related_retrieval_docs: Optional[Dict[str, Any]] = None  # Conversation subset + retrieved docs
+    retrieved_data: Optional[List[Dict[str, Any]]] = None  # Preserved old column for backward compatibility
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary with nested data structures"""
+        result = asdict(self)
+        return result
+    
+    def to_snowflake_schema(self) -> Dict[str, Any]:
+        """Generate Snowflake schema for this dataclass"""
+        schema = {
+            "feedback_id": "VARCHAR(255)",
+            "open_ended_feedback": "VARCHAR(16777216)",  # Large text
+            "score": "INTEGER",
+            "is_feedback_about_last_retrieval": "BOOLEAN",
+            "conversation_id": "VARCHAR(255)",
+            "timestamp": "NUMBER(20, 0)",
+            "message_count": "INTEGER",
+            "has_retrievals": "BOOLEAN",
+            "retrieval_count": "INTEGER",
+            "transcript": "VARCHAR(16777216)",  # JSON string of ARRAY of {"role": "user"/"assistant", "content": "..."}
+            "retrievals": "VARCHAR(16777216)",  # JSON string of ARRAY of retrieval objects
+            "feedback_score_related_retrieval_docs": "VARCHAR(16777216)",  # JSON string of OBJECT with conversation subset + retrieved docs
+            "retrieved_data": "VARCHAR(16777216)",  # JSON string - preserved old column for backward compatibility
+            "created_at": "TIMESTAMP_NTZ",
+            # transcript structure: [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}, ...]
+            # retrievals structure: [
+            #   {
+            #     "retrieved_docs": [{"content": "...", "metadata": {...}, ...}],  # content truncated to 100 chars
+            #     "user_message_trigger": "final user message that triggered this retrieval"
+            #   },
+            #   ...
+            # ]
+            # feedback_score_related_retrieval_docs structure: {
+            #   "conversation_up_to_point": [{"role": "user", "content": "..."}, ...],  # subset of transcript
+            #   "retrieved_docs": [{"content": "...", "metadata": {...}, ...}]  # full chunks with all info
+            # }
+        }
+        return schema
+    
+    @classmethod
+    def get_snowflake_create_table_sql(cls, table_name: str = "USER_FEEDBACK_V3") -> str:
+        """Generate CREATE TABLE SQL for Snowflake"""
+        schema = cls.to_snowflake_schema(None)
+        
+        columns = []
+        for col_name, col_type in schema.items():
+            nullable = "NULL" if col_name not in ["feedback_id", "score", "timestamp"] else "NOT NULL"
+            columns.append(f"  {col_name} {col_type} {nullable}")
+        
+        # Build SQL string properly
+        columns_str = ",\n".join(columns)
+        
+        sql = f"""CREATE TABLE IF NOT EXISTS {table_name} (
+{columns_str},
+  PRIMARY KEY (feedback_id)
+)
+CLUSTER BY (timestamp, conversation_id, score);
+-- Note: Snowflake doesn't support traditional indexes on regular tables.
+-- Instead, we use CLUSTER BY to optimize queries on these columns.
+-- Snowflake automatically maintains clustering for efficient querying.
+-- Note: transcript, retrievals, and feedback_score_related_retrieval_docs are stored as VARCHAR (JSON strings),
+-- same approach as the old retrieved_data column. This allows easy storage and retrieval without VARIANT type complexity.
+"""
+        return sql
+
+
+# Snowflake variant schema for retrieved_data array
+RETRIEVAL_ENTRY_SCHEMA = {
+    "rag_query": "VARCHAR",
+    "documents_retrieved": "ARRAY",  # Array of document objects
+    "conversation_length": "INTEGER",
+    "filters_applied": "OBJECT",
+    "timestamp": "NUMBER"
+}
+
+DOCUMENT_SCHEMA = {
+    "doc_id": "VARCHAR",
+    "filename": "VARCHAR",
+    "page": "INTEGER",
+    "score": "DOUBLE",
+    "content": "VARCHAR(16777216)",
+    "metadata": "OBJECT"
+}
+
+
+def generate_snowflake_schema_sql(table_name: Optional[str] = None) -> str:
+    """Generate complete Snowflake schema SQL for feedback system"""
+    if table_name is None:
+        table_name = os.getenv("SNOWFLAKE_FEEDBACK_TABLE", "USER_FEEDBACK_V3")
+    return UserFeedback.get_snowflake_create_table_sql(table_name)
+
+
+def create_feedback_from_dict(data: Dict[str, Any]) -> UserFeedback:
+    """Create UserFeedback instance from dictionary"""
+    return UserFeedback(
+        feedback_id=data.get("feedback_id", f"feedback_{data.get('timestamp', 'unknown')}"),
+        open_ended_feedback=data.get("open_ended_feedback"),
+        score=data["score"],
+        is_feedback_about_last_retrieval=data["is_feedback_about_last_retrieval"],
+        conversation_id=data["conversation_id"],
+        timestamp=data["timestamp"],
+        message_count=data["message_count"],
+        has_retrievals=data["has_retrievals"],
+        retrieval_count=data["retrieval_count"],
+        transcript=data.get("transcript", []),
+        retrievals=data.get("retrievals", []),
+        feedback_score_related_retrieval_docs=data.get("feedback_score_related_retrieval_docs"),
+        retrieved_data=data.get("retrieved_data")
+    )
+

src/feedback/snowflake_connector.py

@@ -0,0 +1,331 @@
+"""
+Snowflake Connector for Feedback System
+
+This module handles inserting user feedback into Snowflake.
+"""
+
+import os
+import json
+import logging
+from typing import Dict, Any, Optional
+from .feedback_schema import UserFeedback
+
+# Try to import snowflake connector
+try:
+    import snowflake.connector
+    SNOWFLAKE_AVAILABLE = True
+except ImportError:
+    SNOWFLAKE_AVAILABLE = False
+    logging.warning("⚠️ snowflake-connector-python not installed. Install with: pip install snowflake-connector-python")
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+class SnowflakeFeedbackConnector:
+    """Connector for inserting feedback into Snowflake"""
+    
+    def __init__(
+        self,
+        user: str,
+        password: str,
+        account: str,
+        warehouse: str,
+        database: str = "SNOWFLAKE_LEARNING",
+        schema: str = "PUBLIC"
+    ):
+        self.user = user
+        self.password = password
+        self.account = account
+        self.warehouse = warehouse
+        self.database = database
+        self.schema = schema
+        self._connection = None
+    
+    def connect(self):
+        """Establish Snowflake connection"""
+        if not SNOWFLAKE_AVAILABLE:
+            raise ImportError("snowflake-connector-python is not installed. Install with: pip install snowflake-connector-python")
+        
+        logger.info("=" * 80)
+        logger.info("🔌 SNOWFLAKE CONNECTION: Attempting to connect...")
+        logger.info(f"   - Account: {self.account}")
+        logger.info(f"   - Warehouse: {self.warehouse}")
+        logger.info(f"   - Database: {self.database}")
+        logger.info(f"   - Schema: {self.schema}")
+        logger.info(f"   - User: {self.user}")
+        
+        try:
+            self._connection = snowflake.connector.connect(
+                user=self.user,
+                password=self.password,
+                account=self.account,
+                warehouse=self.warehouse
+                # Don't set database/schema in connection - we'll do it per query
+            )
+            logger.info("✅ SNOWFLAKE CONNECTION: Successfully connected")
+            logger.info("=" * 80)
+            print(f"✅ Connected to Snowflake: {self.database}.{self.schema}")
+        except Exception as e:
+            logger.error(f"❌ SNOWFLAKE CONNECTION FAILED: {e}")
+            logger.error("=" * 80)
+            print(f"❌ Failed to connect to Snowflake: {e}")
+            raise
+    
+    def disconnect(self):
+        """Close Snowflake connection"""
+        if self._connection:
+            self._connection.close()
+            print("✅ Disconnected from Snowflake")
+    
+    def insert_feedback(self, feedback: UserFeedback, table_name: Optional[str] = None) -> bool:
+        """Insert a single feedback record into Snowflake"""
+        logger.info("=" * 80)
+        logger.info("🔄 SNOWFLAKE INSERT: Starting feedback insertion process")
+        logger.info(f"📝 Feedback ID: {feedback.feedback_id}")
+        
+        # Get table name from parameter, env var, or default
+        if table_name is None:
+            table_name = os.getenv("SNOWFLAKE_FEEDBACK_TABLE", "USER_FEEDBACK_V3")
+        
+        if not self._connection:
+            logger.error("❌ Not connected to Snowflake. Call connect() first.")
+            raise RuntimeError("Not connected to Snowflake. Call connect() first.")
+        
+        try:
+            logger.info("📊 VALIDATION: Validating feedback data structure...")
+            
+            # Validate feedback object
+            validation_errors = []
+            if not feedback.feedback_id:
+                validation_errors.append("Missing feedback_id")
+            if feedback.score is None:
+                validation_errors.append("Missing score")
+            if feedback.timestamp is None:
+                validation_errors.append("Missing timestamp")
+                
+            if validation_errors:
+                logger.error(f"❌ VALIDATION FAILED: {validation_errors}")
+                return False
+            else:
+                logger.info("✅ VALIDATION PASSED: All required fields present")
+            
+            logger.info("📋 Data Summary:")
+            logger.info(f"   - Feedback ID: {feedback.feedback_id}")
+            logger.info(f"   - Score: {feedback.score}")
+            logger.info(f"   - Conversation ID: {feedback.conversation_id}")
+            logger.info(f"   - Has Retrievals: {feedback.has_retrievals}")
+            logger.info(f"   - Retrieval Count: {feedback.retrieval_count}")
+            logger.info(f"   - Message Count: {feedback.message_count}")
+            logger.info(f"   - Timestamp: {feedback.timestamp}")
+            
+            cursor = self._connection.cursor()
+            logger.info("✅ SNOWFLAKE CONNECTION: Cursor created")
+            
+            # Set database and schema context
+            logger.info(f"🔧 SETTING CONTEXT: Database={self.database}, Schema={self.schema}")
+            try:
+                cursor.execute(f'USE DATABASE "{self.database}"')
+                cursor.execute(f'USE SCHEMA "{self.schema}"')
+                cursor.execute("SELECT CURRENT_DATABASE(), CURRENT_SCHEMA()")
+                current_db, current_schema = cursor.fetchone()
+                logger.info(f"✅ Current context verified: Database={current_db}, Schema={current_schema}")
+            except Exception as e:
+                logger.error(f"❌ Could not set context: {e}")
+                raise
+            
+            # Prepare data - convert to JSON strings for VARIANT columns (same approach as old retrieved_data)
+            logger.info("🔧 DATA PREPARATION: Preparing VARIANT columns...")
+            feedback_dict = feedback.to_dict()
+            
+            # Prepare transcript (ARRAY) - convert to JSON string
+            transcript_raw = feedback_dict.get('transcript', [])
+            if transcript_raw:
+                # Convert to JSON string (same approach as old retrieved_data)
+                transcript_for_db = json.dumps(transcript_raw)
+                logger.info(f"   - Transcript: {len(transcript_raw)} messages, JSON length: {len(transcript_for_db)}")
+            else:
+                transcript_for_db = None
+                logger.info("   - Transcript: None")
+            
+            # Prepare retrievals (ARRAY) - convert to JSON string
+            retrievals_raw = feedback_dict.get('retrievals', [])
+            if retrievals_raw:
+                # Convert to JSON string (same approach as old retrieved_data)
+                retrievals_for_db = json.dumps(retrievals_raw)
+                logger.info(f"   - Retrievals: {len(retrievals_raw)} entries, JSON length: {len(retrievals_for_db)}")
+            else:
+                retrievals_for_db = None
+                logger.info("   - Retrievals: None")
+            
+            # Prepare feedback_score_related_retrieval_docs (OBJECT) - convert to JSON string
+            feedback_score_related_raw = feedback_dict.get('feedback_score_related_retrieval_docs')
+            if feedback_score_related_raw:
+                # Convert to JSON string (same approach as old retrieved_data)
+                feedback_score_related_for_db = json.dumps(feedback_score_related_raw)
+                logger.info(f"   - Feedback score related docs: present, JSON length: {len(feedback_score_related_for_db)}")
+            else:
+                feedback_score_related_for_db = None
+                logger.info("   - Feedback score related docs: None")
+            
+            # Prepare retrieved_data (preserved old column) - convert to JSON string
+            retrieved_data_raw = feedback_dict.get('retrieved_data')
+            if retrieved_data_raw:
+                # Convert to JSON string (same approach as old retrieved_data)
+                retrieved_data_for_db = json.dumps(retrieved_data_raw)
+                logger.info(f"   - Retrieved data (preserved): present, JSON length: {len(retrieved_data_for_db)}")
+            else:
+                retrieved_data_for_db = None
+                logger.info("   - Retrieved data (preserved): None")
+            
+            # Build SQL with new column structure
+            # Columns are VARCHAR (storing JSON strings), same approach as old retrieved_data
+            sql = f"""INSERT INTO {table_name} (
+                feedback_id,
+                open_ended_feedback,
+                score,
+                is_feedback_about_last_retrieval,
+                conversation_id,
+                timestamp,
+                message_count,
+                has_retrievals,
+                retrieval_count,
+                transcript,
+                retrievals,
+                feedback_score_related_retrieval_docs,
+                retrieved_data,
+                created_at
+            ) VALUES (
+                %(feedback_id)s, %(open_ended_feedback)s, %(score)s, %(is_feedback_about_last_retrieval)s,
+                %(conversation_id)s, %(timestamp)s, %(message_count)s, %(has_retrievals)s,
+                %(retrieval_count)s, %(transcript)s, %(retrievals)s, %(feedback_score_related_retrieval_docs)s,
+                %(retrieved_data)s, %(created_at)s
+            )"""
+            
+            logger.info("📝 SQL PREPARATION: Building INSERT statement...")
+            logger.info(f"   - Target table: {table_name}")
+            logger.info(f"   - Database: {self.database}")
+            logger.info(f"   - Schema: {self.schema}")
+            
+            # Prepare parameters
+            # Pass JSON strings for VARIANT columns (same approach as old retrieved_data)
+            params = {
+                'feedback_id': feedback.feedback_id,
+                'open_ended_feedback': feedback.open_ended_feedback,
+                'score': feedback.score,
+                'is_feedback_about_last_retrieval': feedback.is_feedback_about_last_retrieval,
+                'conversation_id': feedback.conversation_id,
+                'timestamp': int(feedback.timestamp),
+                'message_count': feedback.message_count,
+                'has_retrievals': feedback.has_retrievals,
+                'retrieval_count': feedback.retrieval_count,
+                'transcript': transcript_for_db,  # JSON string
+                'retrievals': retrievals_for_db,  # JSON string
+                'feedback_score_related_retrieval_docs': feedback_score_related_for_db,  # JSON string
+                'retrieved_data': retrieved_data_for_db,  # JSON string - preserved old column
+                'created_at': feedback.created_at
+            }
+            
+            # Execute insert
+            logger.info("🚀 SQL EXECUTION: Executing INSERT query...")
+            cursor.execute(sql, params)
+            
+            logger.info("✅ SQL EXECUTION: Query executed successfully")
+            logger.info(f"   - Rows affected: 1")
+            logger.info(f"   - Status: SUCCESS")
+            
+            cursor.close()
+            logger.info("✅ SNOWFLAKE INSERT: Feedback inserted successfully")
+            logger.info(f"📝 Inserted feedback: {feedback.feedback_id}")
+            logger.info("=" * 80)
+            return True
+            
+        except Exception as e:
+            # Check if it's a Snowflake error
+            if SNOWFLAKE_AVAILABLE and "ProgrammingError" in str(type(e)):
+                logger.error(f"❌ SQL EXECUTION ERROR: {e}")
+                logger.error(f"   - Error code: {getattr(e, 'errno', 'Unknown')}")
+                logger.error(f"   - SQL state: {getattr(e, 'sqlstate', 'Unknown')}")
+            else:
+                logger.error(f"❌ SNOWFLAKE INSERT FAILED: {type(e).__name__}")
+                logger.error(f"   - Error: {e}")
+            logger.error("=" * 80)
+            return False
+    
+    def __enter__(self):
+        """Context manager entry"""
+        self.connect()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.disconnect()
+
+
+def get_snowflake_connector_from_env() -> Optional[SnowflakeFeedbackConnector]:
+    """Create Snowflake connector from environment variables"""
+    user = os.getenv("SNOWFLAKE_USER")
+    password = os.getenv("SNOWFLAKE_PASSWORD")
+    account = os.getenv("SNOWFLAKE_ACCOUNT")
+    warehouse = os.getenv("SNOWFLAKE_WAREHOUSE")
+    database = os.getenv("SNOWFLAKE_DATABASE", "SNOWFLAKE_LEARN")
+    schema = os.getenv("SNOWFLAKE_SCHEMA", "PUBLIC")
+    
+    if not all([user, password, account, warehouse]):
+        print("⚠️ Snowflake credentials not found in environment variables")
+        print("Required variables: SNOWFLAKE_USER, SNOWFLAKE_PASSWORD, SNOWFLAKE_ACCOUNT, SNOWFLAKE_WAREHOUSE")
+        return None
+    
+    return SnowflakeFeedbackConnector(
+        user=user,
+        password=password,
+        account=account,
+        warehouse=warehouse,
+        database=database,
+        schema=schema
+    )
+
+
+def save_to_snowflake(feedback: UserFeedback, table_name: Optional[str] = None) -> bool:
+    """Helper function to save feedback to Snowflake"""
+    logger.info("=" * 80)
+    logger.info("🔵 SNOWFLAKE SAVE: Starting save process")
+    logger.info(f"📝 Feedback ID: {feedback.feedback_id}")
+    
+    # Get table name from parameter or env var
+    if table_name is None:
+        table_name = os.getenv("SNOWFLAKE_FEEDBACK_TABLE", "USER_FEEDBACK_V3")
+    
+    connector = get_snowflake_connector_from_env()
+    
+    if not connector:
+        logger.warning("⚠️ SNOWFLAKE SAVE: Skipping insertion (credentials not configured)")
+        logger.warning("   Required variables: SNOWFLAKE_USER, SNOWFLAKE_PASSWORD, SNOWFLAKE_ACCOUNT, SNOWFLAKE_WAREHOUSE")
+        logger.info("=" * 80)
+        return False
+    
+    try:
+        logger.info("📡 SNOWFLAKE SAVE: Establishing connection...")
+        connector.connect()
+        logger.info("✅ SNOWFLAKE SAVE: Connection established")
+        
+        logger.info("📥 SNOWFLAKE SAVE: Attempting to insert feedback...")
+        success = connector.insert_feedback(feedback, table_name=table_name)
+        
+        logger.info("🔌 SNOWFLAKE SAVE: Disconnecting...")
+        connector.disconnect()
+        
+        if success:
+            logger.info("✅ SNOWFLAKE SAVE: Successfully saved feedback")
+        else:
+            logger.error("❌ SNOWFLAKE SAVE: Failed to save feedback")
+        
+        logger.info("=" * 80)
+        return success
+    except Exception as e:
+        logger.error(f"❌ SNOWFLAKE SAVE ERROR: {type(e).__name__}")
+        logger.error(f"   - Error: {e}")
+        logger.info("=" * 80)
+        return False
+

src/gemini/__init__.py

@@ -0,0 +1,11 @@
+"""
+Gemini File Search Integration Module
+
+This module provides integration with Google Gemini File Search API
+for RAG functionality using Gemini's built-in file search capabilities.
+"""
+
+from .file_search import GeminiFileSearchClient, GeminiFileSearchResult
+
+__all__ = ["GeminiFileSearchClient", "GeminiFileSearchResult"]
+

src/gemini/file_search.py

@@ -0,0 +1,256 @@
+"""
+Gemini File Search Client
+
+Handles interaction with Google Gemini File Search API for RAG.
+"""
+
+import os
+import logging
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+try:
+    from google import genai
+    from google.genai import types
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+
+
+@dataclass
+class GeminiFileSearchResult:
+    """Result from Gemini File Search query"""
+    answer: str
+    sources: List[Dict[str, Any]]  # List of document references
+    grounding_metadata: Optional[Dict[str, Any]] = None
+    query: str = ""
+
+
+class GeminiFileSearchClient:
+    """Client for interacting with Gemini File Search API"""
+    
+    def __init__(self, api_key: Optional[str] = None, store_name: Optional[str] = None):
+        """
+        Initialize Gemini File Search client.
+        
+        Args:
+            api_key: Gemini API key (defaults to GEMINI_API_KEY env var)
+            store_name: File search store name (defaults to GEMINI_FILESTORE_NAME env var)
+        """
+        if not GEMINI_AVAILABLE:
+            raise ImportError("google-genai package not installed. Install with: pip install google-genai")
+        
+        self.api_key = api_key or os.getenv("GEMINI_API_KEY")
+        if not self.api_key:
+            raise ValueError("GEMINI_API_KEY not found. Set it in .env file or pass as argument.")
+        
+        self.store_name = store_name or os.getenv("GEMINI_FILESTORE_NAME")
+        if not self.store_name:
+            raise ValueError("GEMINI_FILESTORE_NAME not found. Set it in .env file or pass as argument.")
+        
+        self.client = genai.Client(api_key=self.api_key)
+        self.model = "gemini-2.5-flash"  # or "gemini-2.5-pro"
+    
+    def search(
+        self,
+        query: str,
+        filters: Optional[Dict[str, Any]] = None,
+        model: Optional[str] = None
+    ) -> GeminiFileSearchResult:
+        """
+        Search using Gemini File Search.
+        
+        Args:
+            query: User query
+            filters: Optional filters (year, source, district, etc.)
+            model: Model to use (defaults to gemini-2.5-flash)
+        
+        Returns:
+            GeminiFileSearchResult with answer and sources
+        """
+        model = model or self.model
+        
+        # Build filter context for the query if filters are provided
+        # Gemini File Search doesn't support explicit filters in the API,
+        # so we add them as context in the query
+        filter_context = ""
+        if filters:
+            filter_parts = []
+            if filters.get("year"):
+                years = filters["year"] if isinstance(filters["year"], list) else [filters["year"]]
+                filter_parts.append(f"Year: {', '.join(years)}")
+            if filters.get("sources"):
+                sources = filters["sources"] if isinstance(filters["sources"], list) else [filters["sources"]]
+                filter_parts.append(f"Source: {', '.join(sources)}")
+            if filters.get("district"):
+                districts = filters["district"] if isinstance(filters["district"], list) else [filters["district"]]
+                filter_parts.append(f"District: {', '.join(districts)}")
+            if filters.get("filenames"):
+                filenames = filters["filenames"] if isinstance(filters["filenames"], list) else [filters["filenames"]]
+                filter_parts.append(f"Filename: {', '.join(filenames)}")
+            
+            if filter_parts:
+                filter_context = f"\n\nPlease focus on documents matching these criteria: {', '.join(filter_parts)}"
+        
+        # Combine query with filter context
+        # Add explicit instruction to only use information from retrieved documents
+        instruction = "\n\nIMPORTANT: Only use information from the retrieved documents. Do not use information from your training data unless it's explicitly mentioned in the retrieved documents. If the retrieved documents don't contain the requested information, clearly state that.\n\n"
+        full_query = query + filter_context + instruction
+        
+        try:
+            # Generate content with file search
+            # Based on Gemini API docs: https://ai.google.dev/gemini-api/docs/file-search
+            try:
+                # Try the documented format first
+                response = self.client.models.generate_content(
+                    model=model,
+                    contents=full_query,
+                    config=types.GenerateContentConfig(
+                        tools=[
+                            types.Tool(
+                                file_search=types.FileSearch(
+                                    file_search_store_names=[self.store_name]
+                                )
+                            )
+                        ]
+                    )
+                )
+            except (AttributeError, TypeError) as e:
+                # Fallback: try alternative format
+                logger.warning(f"Primary API format failed, trying alternative: {e}")
+                try:
+                    response = self.client.models.generate_content(
+                        model=model,
+                        contents=full_query,
+                        tools=[{
+                            "file_search": {
+                                "file_search_store_names": [self.store_name]
+                            }
+                        }]
+                    )
+                except Exception as e2:
+                    raise Exception(f"Failed to call Gemini API: {e2}")
+            
+            # Extract answer
+            answer = ""
+            if hasattr(response, 'text'):
+                answer = response.text
+            elif hasattr(response, 'candidates') and response.candidates:
+                # Try to get text from first candidate
+                candidate = response.candidates[0]
+                if hasattr(candidate, 'content') and candidate.content:
+                    if hasattr(candidate.content, 'parts'):
+                        text_parts = []
+                        for part in candidate.content.parts:
+                            if hasattr(part, 'text'):
+                                text_parts.append(part.text)
+                        answer = " ".join(text_parts)
+                    elif isinstance(candidate.content, str):
+                        answer = candidate.content
+            else:
+                answer = str(response)
+            
+            # Extract grounding metadata (document references)
+            sources = []
+            grounding_metadata = None
+            
+            if hasattr(response, 'candidates') and response.candidates:
+                candidate = response.candidates[0]
+                
+                # Get grounding metadata
+                if hasattr(candidate, 'grounding_metadata'):
+                    grounding_metadata = candidate.grounding_metadata
+                    
+                    # Extract source documents from grounding metadata
+                    # Handle different response formats
+                    grounding_chunks = None
+                    if hasattr(grounding_metadata, 'grounding_chunks'):
+                        grounding_chunks = grounding_metadata.grounding_chunks
+                    elif isinstance(grounding_metadata, dict) and 'grounding_chunks' in grounding_metadata:
+                        grounding_chunks = grounding_metadata['grounding_chunks']
+                    
+                    if grounding_chunks:
+                        for chunk in grounding_chunks:
+                            # Handle both object and dict formats
+                            try:
+                                if isinstance(chunk, dict):
+                                    chunk_data = chunk
+                                else:
+                                    # Object format - convert to dict-like access
+                                    chunk_data = {}
+                                    if hasattr(chunk, 'chunk'):
+                                        chunk_obj = chunk.chunk
+                                        chunk_data['chunk'] = {
+                                            'text': getattr(chunk_obj, 'text', ''),
+                                            'file_name': getattr(chunk_obj, 'file_name', '')
+                                        }
+                                    if hasattr(chunk, 'relevance_score'):
+                                        score_obj = chunk.relevance_score
+                                        chunk_data['relevance_score'] = {
+                                            'score': getattr(score_obj, 'score', 0.0)
+                                        }
+                                
+                                chunk_info = chunk_data.get('chunk', {})
+                                text = chunk_info.get('text', '') if isinstance(chunk_info, dict) else ''
+                                file_name = chunk_info.get('file_name', '') if isinstance(chunk_info, dict) else ''
+                                
+                                score_data = chunk_data.get('relevance_score', {})
+                                score = score_data.get('score', 0.0) if isinstance(score_data, dict) else 0.0
+                                
+                                if text or file_name:  # Only add if we have content
+                                    source_info = {
+                                        "content": text,
+                                        "filename": file_name,
+                                        "score": score,
+                                    }
+                                    sources.append(source_info)
+                            except Exception as e:
+                                logger.warning(f"Error extracting chunk info: {e}")
+                                continue
+            
+            return GeminiFileSearchResult(
+                answer=answer,
+                sources=sources,
+                grounding_metadata=grounding_metadata,
+                query=query
+            )
+            
+        except Exception as e:
+            # Return error result
+            return GeminiFileSearchResult(
+                answer=f"I apologize, but I encountered an error: {str(e)}",
+                sources=[],
+                query=query
+            )
+    
+    def format_sources_for_display(self, result: GeminiFileSearchResult) -> List[Any]:
+        """
+        Format Gemini sources to match the format expected by the UI.
+        
+        Returns list of document-like objects compatible with existing display code.
+        """
+        from langchain.docstore.document import Document
+        
+        formatted_sources = []
+        
+        for i, source in enumerate(result.sources):
+            # Create a Document object compatible with existing code
+            doc = Document(
+                page_content=source.get("content", ""),
+                metadata={
+                    "filename": source.get("filename", "Unknown"),
+                    "source": "Gemini File Search",
+                    "score": source.get("score"),
+                    "chunk_index": i,
+                    # Add default fields that might be expected
+                    "page": None,
+                    "year": None,
+                    "district": None,
+                }
+            )
+            formatted_sources.append(doc)
+        
+        return formatted_sources
+

src/pipeline.py

@@ -14,7 +14,7 @@ except ModuleNotFoundError as me:
 
 from .logging import log_error
 
-from .loader import chunks_to_documents
+from .llm.loader import chunks_to_documents
 from .vectorstore import VectorStoreManager
 from .reporting.service import ReportService
 from .retrieval.context import ContextRetriever

src/reporting/__init__.py

@@ -1,4 +1,8 @@
-"""Report metadata and utilities."""
+"""Report metadata and utilities.
+
+This module is kept for backward compatibility with pipeline.py.
+For feedback-related functionality, use src.feedback instead.
+"""
 
 from .metadata import get_report_metadata, get_available_sources
 from .service import ReportService

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

src/ui_components/__init__.py

@@ -0,0 +1,21 @@
+"""
+UI Components Module
+
+This module contains UI-related components including styles, visualizations,
+and utility functions for the Streamlit application.
+"""
+
+from .styles import get_custom_css
+from .components import (
+    display_chunk_statistics_charts,
+    display_chunk_statistics_table
+)
+from .utils import extract_chunk_statistics
+
+__all__ = [
+    "get_custom_css",
+    "display_chunk_statistics_charts",
+    "display_chunk_statistics_table",
+    "extract_chunk_statistics"
+]
+

src/ui_components/components.py

@@ -0,0 +1,202 @@
+"""
+UI components for displaying statistics and visualizations
+"""
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from typing import Dict, Any
+
+
+def display_chunk_statistics_charts(stats: Dict[str, Any], title: str = "Retrieval Statistics"):
+    """Display statistics as interactive charts for 10+ results."""
+    if not stats or stats.get('total_chunks', 0) == 0:
+        return
+    
+    # Wrap everything in one styled container - open it
+    st.markdown(f"""
+    <div class="retrieval-distribution-container">
+        <h3 style="margin-top: 0;">📊 {title}</h3>
+        <div style="display: flex; justify-content: space-around; align-items: center; padding: 15px 0; border-bottom: 1px solid #e0e0e0; margin-bottom: 20px;">
+            <div class="metric-container">
+                <div class="metric-label">Total Chunks</div>
+                <div class="metric-value">{stats['total_chunks']}</div>
+            </div>
+            <div class="metric-container">
+                <div class="metric-label">Unique Sources</div>
+                <div class="metric-value">{stats['unique_sources']}</div>
+            </div>
+            <div class="metric-container">
+                <div class="metric-label">Unique Years</div>
+                <div class="metric-value">{stats['unique_years']}</div>
+            </div>
+            <div class="metric-container">
+                <div class="metric-label">Unique Files</div>
+                <div class="metric-value">{stats['unique_filenames']}</div>
+            </div>
+        </div>
+    """, unsafe_allow_html=True)
+    
+    # Charts - three columns to include Districts
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        # Source distribution chart
+        if stats['source_distribution']:
+            source_df = pd.DataFrame(
+                list(stats['source_distribution'].items()),
+                columns=['Source', 'Count']
+            )
+            fig_source = px.bar(
+                source_df,
+                x='Count',
+                y='Source',
+                orientation='h',
+                title='Distribution by Source',
+                color='Count',
+                color_continuous_scale='viridis'
+            )
+            fig_source.update_layout(height=400, showlegend=False)
+            st.plotly_chart(fig_source, use_container_width=True)
+    
+    with col2:
+        # Year distribution chart
+        if stats['year_distribution']:
+            # Filter out 'Unknown' years for the chart
+            year_dist_filtered = {k: v for k, v in stats['year_distribution'].items() if k != 'Unknown'}
+            if year_dist_filtered:
+                year_df = pd.DataFrame(
+                    list(year_dist_filtered.items()),
+                    columns=['Year', 'Count']
+                )
+                # Sort by year as integer but keep as string for categorical display
+                year_df['Year_Int'] = year_df['Year'].astype(int)
+                year_df = year_df.sort_values('Year_Int').drop('Year_Int', axis=1)
+                
+                fig_year = px.bar(
+                    year_df,
+                    x='Year',
+                    y='Count',
+                    title='Distribution by Year',
+                    color='Count',
+                    color_continuous_scale='plasma'
+                )
+                # Ensure years are treated as categorical (discrete) not continuous
+                fig_year.update_xaxes(type='category')
+                fig_year.update_layout(height=400, showlegend=False)
+                st.plotly_chart(fig_year, use_container_width=True)
+            else:
+                st.info("No valid years found in the results")
+    
+    with col3:
+        # District distribution chart
+        if stats.get('district_distribution'):
+            district_dist_filtered = {k: v for k, v in stats['district_distribution'].items() if k != 'Unknown'}
+            if district_dist_filtered:
+                district_df = pd.DataFrame(
+                    list(district_dist_filtered.items()),
+                    columns=['District', 'Count']
+                )
+                district_df = district_df.sort_values('Count', ascending=False)
+                
+                fig_district = px.bar(
+                    district_df,
+                    x='Count',
+                    y='District',
+                    orientation='h',
+                    title='Distribution by District',
+                    color='Count',
+                    color_continuous_scale='blues'
+                )
+                fig_district.update_layout(height=400, showlegend=False)
+                st.plotly_chart(fig_district, use_container_width=True)
+            else:
+                st.info("No valid districts found in the results")
+    
+    # Close the container
+    st.markdown('</div>', unsafe_allow_html=True)
+
+
+def display_chunk_statistics_table(stats: Dict[str, Any], title: str = "Retrieval Distribution"):
+    """Display statistics as tables for smaller results with fixed alignment."""
+    if not stats or stats.get('total_chunks', 0) == 0:
+        return
+    
+    # Wrap in styled container
+    st.markdown('<div class="retrieval-distribution-container">', unsafe_allow_html=True)
+    
+    st.subheader(f"📊 {title}")
+    
+    # Create a container with fixed height for alignment
+    stats_container = st.container()
+    
+    with stats_container:
+        # Create 4 equal columns for consistent alignment
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.markdown("**🏘️ Districts**")
+            if stats.get('district_distribution'):
+                district_dist_filtered = {k: v for k, v in stats['district_distribution'].items() if k != 'Unknown'}
+                if district_dist_filtered:
+                    district_data = {
+                        "District": list(district_dist_filtered.keys()),
+                        "Count": list(district_dist_filtered.values())
+                    }
+                    district_df = pd.DataFrame(district_data).sort_values('Count', ascending=False)
+                    st.dataframe(district_df, hide_index=True, use_container_width=True)
+                else:
+                    st.write("No district data")
+            else:
+                st.write("No district data")
+        
+        with col2:
+            st.markdown("**📂 Sources**")
+            if stats['source_distribution']:
+                source_data = {
+                    "Source": list(stats['source_distribution'].keys()),
+                    "Count": list(stats['source_distribution'].values())
+                }
+                source_df = pd.DataFrame(source_data).sort_values('Count', ascending=False)
+                st.dataframe(source_df, hide_index=True, use_container_width=True)
+            else:
+                st.write("No source data")
+        
+        with col3:
+            st.markdown("**📅 Years**")
+            if stats['year_distribution']:
+                year_dist_filtered = {k: v for k, v in stats['year_distribution'].items() if k != 'Unknown'}
+                if year_dist_filtered:
+                    year_data = {
+                        "Year": list(year_dist_filtered.keys()),
+                        "Count": list(year_dist_filtered.values())
+                    }
+                    year_df = pd.DataFrame(year_data)
+                    # Sort by year as integer but display as string
+                    year_df['Year_Int'] = year_df['Year'].astype(int)
+                    year_df = year_df.sort_values('Year_Int')[['Year', 'Count']]
+                    st.dataframe(year_df, hide_index=True, use_container_width=True)
+                else:
+                    st.write("No year data")
+            else:
+                st.write("No year data")
+        
+        with col4:
+            st.markdown("**📄 Files**")
+            if stats['filename_distribution']:
+                filename_items = list(stats['filename_distribution'].items())
+                filename_items.sort(key=lambda x: x[1], reverse=True)
+                
+                # Show top files with truncated names
+                file_data = {
+                    "File": [f[:30] + "..." if len(f) > 30 else f for f, c in filename_items[:5]],
+                    "Count": [c for f, c in filename_items[:5]]
+                }
+                file_df = pd.DataFrame(file_data)
+                st.dataframe(file_df, hide_index=True, use_container_width=True)
+            else:
+                st.write("No file data")
+    
+    # Close container
+    st.markdown('</div>', unsafe_allow_html=True)
+

src/ui_components/styles.py

@@ -0,0 +1,117 @@
+"""
+Custom CSS styles for Streamlit application
+"""
+
+
+def get_custom_css() -> str:
+    """Get custom CSS styles as a string"""
+    return """
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        color: #1f77b4;
+        text-align: center;
+        margin-bottom: 1rem;
+        width: 100%;
+        display: block;
+    }
+    
+    .subtitle {
+        font-size: 1.2rem;
+        color: #666;
+        text-align: center;
+        margin-bottom: 2rem;
+        width: 100%;
+        display: block;
+    }
+    
+    .session-info {
+        background-color: #f0f2f6;
+        padding: 10px;
+        border-radius: 5px;
+        margin-bottom: 20px;
+        font-size: 0.9rem;
+    }
+    
+    .user-message {
+        background-color: #007bff;
+        color: white;
+        padding: 12px 16px;
+        border-radius: 18px 18px 4px 18px;
+        margin: 8px 0;
+        margin-left: 20%;
+        word-wrap: break-word;
+    }
+    
+    .bot-message {
+        background-color: #f1f3f4;
+        color: #333;
+        padding: 12px 16px;
+        border-radius: 18px 18px 18px 4px;
+        margin: 8px 0;
+        margin-right: 20%;
+        word-wrap: break-word;
+        border: 1px solid #e0e0e0;
+    }
+    
+    .filter-section {
+        margin-bottom: 20px;
+        padding: 15px;
+        background-color: #f8f9fa;
+        border-radius: 8px;
+        border: 1px solid #e9ecef;
+    }
+    
+    .filter-title {
+        font-weight: bold;
+        margin-bottom: 10px;
+        color: #495057;
+    }
+    
+    .feedback-section {
+        background-color: #f8f9fa;
+        padding: 20px;
+        border-radius: 10px;
+        margin-top: 30px;
+        border: 2px solid #dee2e6;
+    }
+    
+    .retrieval-history {
+        background-color: #ffffff;
+        padding: 15px;
+        border-radius: 5px;
+        margin: 10px 0;
+        border-left: 4px solid #007bff;
+    }
+    
+    .retrieval-distribution-container {
+        background-color: #ffffff;
+        padding: 25px;
+        border-radius: 10px;
+        margin: 20px 0;
+        border: 2px solid #e0e0e0;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1), 0 2px 4px rgba(0, 0, 0, 0.06);
+    }
+    
+    .metric-label {
+        font-size: 0.9rem;
+        color: #555;
+        margin-bottom: 5px;
+        text-align: center;
+    }
+    
+    .metric-value {
+        font-size: 1.8rem;
+        font-weight: bold;
+        color: #000000;
+        text-align: center;
+    }
+    
+    .metric-container {
+        text-align: center;
+        padding: 10px;
+    }
+</style>
+"""
+

src/ui_components/utils.py

@@ -0,0 +1,73 @@
+"""
+UI utility functions for data processing and statistics
+"""
+
+from typing import Dict, Any, List
+from collections import Counter
+
+
+def extract_chunk_statistics(sources: List[Any]) -> Dict[str, Any]:
+    """Extract statistics from retrieved chunks."""
+    if not sources:
+        return {}
+    
+    sources_list = []
+    years = []
+    filenames = []
+    districts = []
+    
+    for doc in sources:
+        metadata = getattr(doc, 'metadata', {})
+        
+        # Extract source
+        source = metadata.get('source', 'Unknown')
+        sources_list.append(source)
+        
+        # Extract year
+        year = metadata.get('year', 'Unknown')
+        if year and year != 'Unknown':
+            try:
+                # Convert to int first, then back to string to ensure it's a proper year
+                year_int = int(float(year))  # Handle both int and float strings
+                if 1900 <= year_int <= 2030:  # Reasonable year range
+                    years.append(str(year_int))
+                else:
+                    years.append('Unknown')
+            except (ValueError, TypeError):
+                years.append('Unknown')
+        else:
+            years.append('Unknown')
+        
+        # Extract filename
+        filename = metadata.get('filename', 'Unknown')
+        filenames.append(filename)
+        
+        # Extract district
+        district = metadata.get('district', 'Unknown')
+        if district and district != 'Unknown':
+            districts.append(district)
+        else:
+            districts.append('Unknown')
+    
+    # Count occurrences
+    source_counts = Counter(sources_list)
+    year_counts = Counter(years)
+    filename_counts = Counter(filenames)
+    district_counts = Counter(districts)
+    
+    return {
+        'total_chunks': len(sources),
+        'unique_sources': len(source_counts),
+        'unique_years': len([y for y in year_counts.keys() if y != 'Unknown']),
+        'unique_filenames': len(filename_counts),
+        'unique_districts': len([d for d in district_counts.keys() if d != 'Unknown']),
+        'source_distribution': dict(source_counts),
+        'year_distribution': dict(year_counts),
+        'filename_distribution': dict(filename_counts),
+        'district_distribution': dict(district_counts),
+        'sources': sources_list,
+        'years': years,
+        'filenames': filenames,
+        'districts': districts
+    }
+

src/vectorstore.py

@@ -28,11 +28,19 @@ class MatryoshkaEmbeddings(Embeddings):
 
         if truncate_dim and "matryoshka" in model_name.lower():
             # Use SentenceTransformer directly for Matryoshka models
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-            self.model = SentenceTransformer(model_name, truncate_dim=truncate_dim, device=device)
+            # Explicitly load on CPU first to avoid meta tensor issues
+            self.model = SentenceTransformer(
+                model_name, 
+                truncate_dim=truncate_dim,
+                device="cpu"  # Load on CPU first, prevents meta tensor error
+            )
             print(f"🔧 Matryoshka model configured for {truncate_dim} dimensions")
         else:
             # Use standard HuggingFaceEmbeddings
+            # Pass device="cpu" to prevent meta tensor issues
+            if "model_kwargs" not in kwargs:
+                kwargs["model_kwargs"] = {}
+            kwargs["model_kwargs"]["device"] = "cpu"
             self.model = HuggingFaceEmbeddings(model_name=model_name, **kwargs)
 
     def embed_documents(self, texts: List[str]) -> List[List[float]]:
@@ -76,12 +84,15 @@ class VectorStoreManager:
 
     def _create_embeddings(self) -> HuggingFaceEmbeddings:
         """Create embeddings model from configuration."""
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        
         model_name = self.config["retriever"]["model"]
         normalize = self.config["retriever"]["normalize"]
         
-        model_kwargs = {"device": device}
+        # Fix for meta tensor issue: explicitly load on CPU first
+        # This prevents HuggingFaceEmbeddings from trying to move meta tensors
+        # The model will be loaded on CPU and can be moved later if needed
+        model_kwargs = {
+            "device": "cpu"  # Load on CPU first to avoid meta tensor issues
+        }
         encode_kwargs = {
             "normalize_embeddings": normalize,
             "batch_size": 100,

upload_to_gemini_filestore.py

@@ -0,0 +1,402 @@
+#!/usr/bin/env python3
+"""
+Upload Documents to Google Gemini File Search Store
+
+This script uploads PDF documents to a Gemini File Search store for RAG.
+It processes documents from the reports directory and uploads them with metadata.
+"""
+
+import os
+import sys
+import json
+import time
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from dotenv import load_dotenv
+
+try:
+    from google import genai
+    from google.genai import types
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+    print("❌ google-genai package not installed. Install with: pip install google-genai")
+
+# Load .env file
+load_dotenv()
+
+
+def extract_metadata_from_path(file_path: Path) -> Dict[str, Any]:
+    """Extract metadata from file path structure."""
+    # Example: /path/to/reports/Annual Consolidated OAG audit reports 2018/Annual Consolidated OAG audit reports 2018.pdf
+    parts = file_path.parts
+    filename = file_path.stem  # Without extension
+    
+    metadata = {
+        "filename": file_path.name,
+        "filepath": str(file_path),
+    }
+    
+    # Extract year
+    year_match = None
+    for part in parts:
+        if any(year in part for year in ['2018', '2019', '2020', '2021', '2022', '2023', '2024', '2025']):
+            for year in ['2018', '2019', '2020', '2021', '2022', '2023', '2024', '2025']:
+                if year in part:
+                    year_match = year
+                    break
+            if year_match:
+                break
+    
+    if year_match:
+        metadata["year"] = year_match
+    
+    # Extract source/district
+    filename_lower = filename.lower()
+    if "consolidated" in filename_lower or "oag" in filename_lower:
+        metadata["source"] = "Consolidated"
+    elif "gulu" in filename_lower:
+        metadata["source"] = "Gulu DLG"
+        metadata["district"] = "Gulu"
+    elif "kalangala" in filename_lower:
+        metadata["source"] = "Kalangala DLG"
+        metadata["district"] = "Kalangala"
+    elif "kcca" in filename_lower:
+        metadata["source"] = "KCCA"
+        metadata["district"] = "Kampala"
+    elif "maaif" in filename_lower:
+        metadata["source"] = "MAAIF"
+    elif "mwts" in filename_lower:
+        metadata["source"] = "MWTS"
+    
+    return metadata
+
+
+def get_or_create_filestore(client: genai.Client, store_name: Optional[str] = None) -> str:
+    """Get existing file search store or create a new one."""
+    if store_name:
+        # Try to get existing store
+        try:
+            stores = client.file_search_stores.list()
+            for store in stores:
+                if store.name == store_name or store.display_name == store_name:
+                    print(f"✅ Using existing store: {store.display_name} ({store.name})")
+                    return store.name
+        except Exception as e:
+            print(f"⚠️  Could not list stores: {e}")
+    
+    # Create new store
+    display_name = store_name or "Audit Reports"
+    print(f"📝 Creating new file search store: '{display_name}'...")
+    
+    try:
+        file_search_store = client.file_search_stores.create(
+            config={'display_name': display_name}
+        )
+        print(f"✅ Created store: {file_search_store.display_name} ({file_search_store.name})")
+        return file_search_store.name
+    except Exception as e:
+        print(f"❌ Failed to create store: {e}")
+        raise
+
+
+def format_metadata_for_gemini(metadata: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Format metadata dictionary for Gemini API customMetadata format.
+    
+    Based on Gemini API, customMetadata should use:
+    - string_value for string fields
+    - numeric_value for numeric fields
+    """
+    custom_metadata = []
+    
+    # Add year if available (as numeric_value)
+    if metadata.get('year'):
+        try:
+            year_int = int(metadata['year'])
+            custom_metadata.append({
+                'key': 'year',
+                'numeric_value': year_int
+            })
+        except (ValueError, TypeError):
+            # Fallback to string if not numeric
+            custom_metadata.append({
+                'key': 'year',
+                'string_value': str(metadata['year'])
+            })
+    
+    # Add source if available (as string_value)
+    if metadata.get('source'):
+        custom_metadata.append({
+            'key': 'source',
+            'string_value': str(metadata['source'])
+        })
+    
+    # Add district if available (as string_value)
+    if metadata.get('district'):
+        custom_metadata.append({
+            'key': 'district',
+            'string_value': str(metadata['district'])
+        })
+    
+    # Add filename for reference (as string_value)
+    if metadata.get('filename'):
+        custom_metadata.append({
+            'key': 'filename',
+            'string_value': str(metadata['filename'])
+        })
+    
+    return custom_metadata
+
+
+def check_file_exists(client: genai.Client, store_name: str, filename: str) -> bool:
+    """Check if a file with the same name already exists in the store."""
+    try:
+        # List files in the store
+        store = client.file_search_stores.get(name=store_name)
+        # Note: The API might not have a direct list method, so we'll catch errors
+        return False  # Assume not exists for now
+    except Exception:
+        return False  # If we can't check, assume it doesn't exist
+
+
+def upload_file_to_store(
+    client: genai.Client,
+    file_path: Path,
+    store_name: str,
+    metadata: Dict[str, Any],
+    skip_existing: bool = True
+) -> Optional[bool]:
+    """Upload a single file to the file search store with metadata."""
+    try:
+        print(f"   📤 Uploading: {file_path.name}...")
+        
+        # Format metadata for Gemini API
+        custom_metadata = format_metadata_for_gemini(metadata)
+        
+        # Display metadata being uploaded
+        if custom_metadata:
+            metadata_parts = []
+            for m in custom_metadata:
+                if 'numeric_value' in m:
+                    metadata_parts.append(f"{m['key']}={m['numeric_value']}")
+                elif 'string_value' in m:
+                    metadata_parts.append(f"{m['key']}={m['string_value']}")
+            if metadata_parts:
+                print(f"      📋 Metadata: {', '.join(metadata_parts)}")
+        
+        # Check if file already exists (if skip_existing is True)
+        if skip_existing:
+            # Note: We'll handle duplicates via error messages
+            pass
+        
+        # Upload and import file with metadata
+        # Note: Gemini API may not support customMetadata in upload_to_file_search_store
+        # We'll try with metadata first, then fallback without it if it fails
+        upload_params = {
+            'file': str(file_path),
+            'file_search_store_name': store_name,
+        }
+        
+        # Build config
+        config = {
+            'display_name': metadata.get('filename', file_path.name),
+        }
+        
+        # Upload file (metadata not supported in upload config per API)
+        # Note: Gemini File Search API doesn't support customMetadata in upload_to_file_search_store
+        # Metadata would need to be added via a separate API call after upload, if supported
+        # For now, we upload without metadata - the filename in display_name contains the info
+        upload_params['config'] = config
+        operation = client.file_search_stores.upload_to_file_search_store(**upload_params)
+        
+        # Wait for import to complete
+        max_wait = 300  # 5 minutes max per file
+        start_time = time.time()
+        
+        while not operation.done:
+            if time.time() - start_time > max_wait:
+                print(f"      ⚠️  Timeout waiting for upload to complete")
+                return False
+            
+            time.sleep(2)
+            try:
+                operation = client.operations.get(operation)
+            except Exception as op_error:
+                # Check if it's a "terminated" error (file might already exist)
+                error_str = str(op_error).lower()
+                if 'terminated' in error_str or 'already' in error_str:
+                    print(f"      ⚠️  File may already exist or upload was interrupted")
+                    print(f"      💡 Skipping this file")
+                    return None  # Return None to indicate "skipped"
+                raise
+        
+        # Check for errors in the operation result
+        if hasattr(operation, 'error') and operation.error:
+            error_msg = str(operation.error)
+            if 'terminated' in error_msg.lower() or 'already' in error_msg.lower():
+                print(f"      ⚠️  File may already exist in the store")
+                print(f"      💡 Skipping this file")
+                return None  # Return None to indicate "skipped" vs False for "failed"
+            print(f"      ❌ Upload failed: {operation.error}")
+            return False
+        
+        print(f"      ✅ Uploaded successfully")
+        return True
+        
+    except Exception as e:
+        error_str = str(e).lower()
+        # Handle specific error cases
+        if 'terminated' in error_str or 'already' in error_str or '400' in error_str:
+            print(f"      ⚠️  Upload error: File may already exist or upload was interrupted")
+            print(f"      💡 Error details: {e}")
+            print(f"      💡 Skipping this file")
+            return None  # Return None to indicate "skipped"
+        print(f"      ❌ Error uploading {file_path.name}: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def find_report_files(reports_dir: Path) -> List[Path]:
+    """Find all PDF report files in the reports directory."""
+    pdf_files = []
+    
+    if not reports_dir.exists():
+        print(f"❌ Reports directory not found: {reports_dir}")
+        return pdf_files
+    
+    # Find all PDF files
+    for pdf_file in reports_dir.rglob("*.pdf"):
+        pdf_files.append(pdf_file)
+    
+    return sorted(pdf_files)
+
+
+def main():
+    """Main function to upload documents to Gemini File Search store."""
+    print("=" * 60)
+    print("Gemini File Search Store Upload Tool")
+    print("=" * 60)
+    
+    if not GEMINI_AVAILABLE:
+        print("\n❌ Please install google-genai package:")
+        print("   pip install google-genai")
+        return 1
+    
+    # Get API key
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        print("\n❌ GEMINI_API_KEY not found in environment variables")
+        print("   Please add GEMINI_API_KEY to your .env file")
+        return 1
+    
+    # Get store name (optional)
+    store_name = os.getenv("GEMINI_FILESTORE_NAME")
+    
+    # Get reports directory - try multiple possible locations
+    reports_dir_str = os.getenv("REPORTS_DIR")
+    if not reports_dir_str:
+        # Try common locations
+        possible_paths = [
+            "/Users/ayeroyan/workspace/chatbot-rag/reports",
+            Path(__file__).parent / "reports",
+            Path.cwd() / "reports",
+        ]
+        for path in possible_paths:
+            if Path(path).exists():
+                reports_dir_str = str(path)
+                break
+        
+        if not reports_dir_str:
+            reports_dir_str = "/Users/ayeroyan/workspace/chatbot-rag/reports"  # Default fallback
+    
+    reports_dir = Path(reports_dir_str)
+    
+    # Initialize Gemini client
+    print(f"\n🔌 Connecting to Gemini API...")
+    try:
+        client = genai.Client(api_key=api_key)
+        print(f"   ✅ Connected")
+    except Exception as e:
+        print(f"   ❌ Failed to connect: {e}")
+        return 1
+    
+    # Get or create file search store
+    print(f"\n📦 Setting up file search store...")
+    try:
+        store_name = get_or_create_filestore(client, store_name)
+    except Exception as e:
+        print(f"   ❌ Failed to setup store: {e}")
+        return 1
+    
+    # Find all PDF files
+    print(f"\n🔍 Scanning for PDF files in: {reports_dir}")
+    pdf_files = find_report_files(reports_dir)
+    
+    if not pdf_files:
+        print(f"   ❌ No PDF files found in {reports_dir}")
+        return 1
+    
+    print(f"   ✅ Found {len(pdf_files)} PDF files")
+    
+    # Upload files
+    print(f"\n📤 Uploading files to store...")
+    print(f"   Store: {store_name}")
+    print(f"   Files: {len(pdf_files)}")
+    
+    uploaded = 0
+    failed = 0
+    skipped = 0
+    
+    for i, pdf_file in enumerate(pdf_files, 1):
+        print(f"\n[{i}/{len(pdf_files)}] Processing: {pdf_file.name}")
+        
+        # Extract metadata
+        metadata = extract_metadata_from_path(pdf_file)
+        
+        # Display extracted metadata
+        metadata_info = []
+        if metadata.get('year'):
+            metadata_info.append(f"Year: {metadata['year']}")
+        if metadata.get('source'):
+            metadata_info.append(f"Source: {metadata['source']}")
+        if metadata.get('district'):
+            metadata_info.append(f"District: {metadata['district']}")
+        
+        if metadata_info:
+            print(f"   📊 Extracted metadata: {', '.join(metadata_info)}")
+        
+        # Upload file with metadata
+        result = upload_file_to_store(client, pdf_file, store_name, metadata, skip_existing=True)
+        
+        if result is True:
+            uploaded += 1
+        elif result is None:  # Skipped (already exists)
+            skipped += 1
+        else:  # Failed
+            failed += 1
+        
+        # Small delay between uploads to avoid rate limits
+        if i < len(pdf_files):
+            time.sleep(1)
+    
+    # Summary
+    print(f"\n" + "=" * 60)
+    print(f"Upload Summary")
+    print(f"=" * 60)
+    print(f"   ✅ Uploaded: {uploaded}")
+    if skipped > 0:
+        print(f"   ⏭️  Skipped (already exists): {skipped}")
+    print(f"   ❌ Failed: {failed}")
+    print(f"   📦 Store: {store_name}")
+    
+    if uploaded > 0:
+        print(f"\n✅ Successfully uploaded {uploaded} files to Gemini File Search store!")
+        print(f"   You can now use this store in the beta version of the chatbot.")
+    
+    return 0 if failed == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+

verify_qdrant_migration.py

@@ -0,0 +1,438 @@
+#!/usr/bin/env python3
+"""
+Qdrant Migration Verification Script
+
+This script compares the source and destination Qdrant collections to verify
+that the migration was successful. It:
+1. Compares collection configurations
+2. Fetches sample points from source
+3. Retrieves same points from destination using IDs
+4. Compares vectors, metadata, and all attributes
+"""
+
+import os
+import sys
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+from qdrant_client import QdrantClient
+import json
+
+# Try to import config loader and dotenv for automatic source detection
+try:
+    from src.config.loader import load_config
+    CONFIG_AVAILABLE = True
+except ImportError:
+    CONFIG_AVAILABLE = False
+
+try:
+    from dotenv import load_dotenv
+    DOTENV_AVAILABLE = True
+except ImportError:
+    DOTENV_AVAILABLE = False
+
+# Load .env file automatically if available
+if DOTENV_AVAILABLE:
+    project_root = Path(__file__).parent
+    env_file = project_root / ".env"
+    if env_file.exists():
+        load_dotenv(env_file, override=True)
+    else:
+        load_dotenv(override=True)
+
+
+def get_collection_info(client: QdrantClient, collection_name: str) -> Dict[str, Any]:
+    """Get collection information including vector size and point count."""
+    try:
+        collection_info = client.get_collection(collection_name)
+        
+        # Handle different Qdrant client versions and response formats
+        if hasattr(collection_info, 'config'):
+            config = collection_info.config
+            if hasattr(config, 'params') and hasattr(config.params, 'vectors'):
+                vectors_config = config.params.vectors
+                if isinstance(vectors_config, dict):
+                    vector_size = vectors_config.get('size')
+                    distance = vectors_config.get('distance')
+                else:
+                    vector_size = getattr(vectors_config, 'size', None)
+                    distance = getattr(vectors_config, 'distance', None)
+            else:
+                vector_size = getattr(config, 'vector_size', None)
+                distance = getattr(config, 'distance', None)
+        else:
+            vector_size = getattr(collection_info, 'vector_size', None)
+            distance = getattr(collection_info, 'distance', None)
+        
+        points_count = getattr(collection_info, 'points_count', 0)
+        indexed_vectors_count = getattr(collection_info, 'indexed_vectors_count', 0)
+        
+        if vector_size is None:
+            try:
+                result, _ = client.scroll(collection_name=collection_name, limit=1, with_vectors=True)
+                if result and hasattr(result[0], 'vector') and result[0].vector:
+                    vector_size = len(result[0].vector)
+            except Exception:
+                pass
+        
+        return {
+            "vector_size": vector_size,
+            "distance": distance or "Cosine",
+            "points_count": points_count,
+            "indexed_vectors_count": indexed_vectors_count,
+        }
+    except Exception as e:
+        print(f"❌ Error getting collection info: {e}")
+        return None
+
+
+def fetch_points_by_ids(client: QdrantClient, collection_name: str, point_ids: List) -> Dict:
+    """Fetch points by their IDs from a collection."""
+    try:
+        points = client.retrieve(
+            collection_name=collection_name,
+            ids=point_ids,
+            with_payload=True,
+            with_vectors=True
+        )
+        return {point.id: point for point in points}
+    except Exception as e:
+        print(f"❌ Error fetching points by IDs: {e}")
+        return {}
+
+
+def compare_points(source_point, dest_point, point_id) -> Dict[str, Any]:
+    """Compare two points and return differences."""
+    differences = []
+    matches = []
+    
+    # Compare IDs
+    if source_point.id == dest_point.id:
+        matches.append("ID")
+    else:
+        differences.append(f"ID: source={source_point.id}, dest={dest_point.id}")
+    
+    # Compare vectors
+    source_vec = getattr(source_point, 'vector', None)
+    dest_vec = getattr(dest_point, 'vector', None)
+    
+    if source_vec is None and dest_vec is None:
+        matches.append("Vector (both None)")
+    elif source_vec is None or dest_vec is None:
+        differences.append(f"Vector: source={'None' if source_vec is None else f'len={len(source_vec)}'}, dest={'None' if dest_vec is None else f'len={len(dest_vec)}'}")
+    elif len(source_vec) != len(dest_vec):
+        differences.append(f"Vector length: source={len(source_vec)}, dest={len(dest_vec)}")
+    else:
+        # Compare vector values (with tolerance for floating point)
+        import numpy as np
+        try:
+            vec_diff = np.abs(np.array(source_vec) - np.array(dest_vec))
+            max_diff = float(np.max(vec_diff))
+            if max_diff < 1e-6:
+                matches.append(f"Vector (max diff: {max_diff:.2e})")
+            else:
+                differences.append(f"Vector values differ (max diff: {max_diff:.2e})")
+        except Exception as e:
+            differences.append(f"Vector comparison error: {e}")
+    
+    # Compare payloads
+    source_payload = getattr(source_point, 'payload', {}) or {}
+    dest_payload = getattr(dest_point, 'payload', {}) or {}
+    
+    # Convert to dicts if needed
+    if hasattr(source_payload, '__dict__'):
+        source_payload = source_payload.__dict__
+    if hasattr(dest_payload, '__dict__'):
+        dest_payload = dest_payload.__dict__
+    
+    source_keys = set(source_payload.keys())
+    dest_keys = set(dest_payload.keys())
+    
+    if source_keys != dest_keys:
+        missing_in_dest = source_keys - dest_keys
+        extra_in_dest = dest_keys - source_keys
+        if missing_in_dest:
+            differences.append(f"Payload keys missing in dest: {missing_in_dest}")
+        if extra_in_dest:
+            differences.append(f"Payload keys extra in dest: {extra_in_dest}")
+    
+    # Compare payload values
+    common_keys = source_keys & dest_keys
+    for key in common_keys:
+        source_val = source_payload[key]
+        dest_val = dest_payload[key]
+        
+        if source_val == dest_val:
+            matches.append(f"Payload.{key}")
+        else:
+            # Handle nested structures
+            if isinstance(source_val, dict) and isinstance(dest_val, dict):
+                if source_val != dest_val:
+                    differences.append(f"Payload.{key}: dicts differ")
+            elif isinstance(source_val, list) and isinstance(dest_val, list):
+                if source_val != dest_val:
+                    differences.append(f"Payload.{key}: lists differ (len: {len(source_val)} vs {len(dest_val)})")
+            else:
+                differences.append(f"Payload.{key}: '{source_val}' != '{dest_val}'")
+    
+    return {
+        "point_id": point_id,
+        "matches": matches,
+        "differences": differences,
+        "match_count": len(matches),
+        "diff_count": len(differences)
+    }
+
+
+def main():
+    print("="*70)
+    print("Qdrant Migration Verification Script")
+    print("="*70)
+    
+    # Auto-detect source from config and .env file
+    source_url = os.getenv('QDRANT_URL')
+    source_key = os.getenv('QDRANT_API_KEY')
+    source_collection = os.getenv('QDRANT_COLLECTION', 'docling')
+    
+    if CONFIG_AVAILABLE:
+        try:
+            config = load_config()
+            qdrant_config = config.get('qdrant', {})
+            if not source_url:
+                source_url = qdrant_config.get('url')
+            if not source_key:
+                source_key = qdrant_config.get('api_key')
+            if not source_collection:
+                source_collection = qdrant_config.get('collection_name', 'docling')
+        except Exception as e:
+            print(f"⚠️  Could not load config: {e}")
+    
+    # Get destination from env
+    dest_url = os.getenv('DEST_QDRANT_URL')
+    dest_key = os.getenv('DEST_QDRANT_API_KEY')
+    dest_collection = os.getenv('DEST_COLLECTION')  # Optional, will auto-detect
+    
+    # Validate
+    if not source_url or not source_key:
+        print("❌ Source Qdrant credentials missing!")
+        print("   Set QDRANT_URL and QDRANT_API_KEY in .env or environment")
+        return 1
+    
+    if not dest_url or not dest_key:
+        print("❌ Destination Qdrant credentials missing!")
+        print("   Set DEST_QDRANT_URL and DEST_QDRANT_API_KEY in .env or environment")
+        return 1
+    
+    print(f"\n📋 Configuration:")
+    print(f"   Source: {source_url}")
+    print(f"   Source Collection: {source_collection}")
+    print(f"   Destination: {dest_url}")
+    if dest_collection:
+        print(f"   Destination Collection: {dest_collection} (specified)")
+    else:
+        print(f"   Destination Collection: (auto-detect)")
+    
+    # Connect to Qdrant instances
+    print(f"\n🔌 Connecting to Qdrant instances...")
+    try:
+        source_client = QdrantClient(url=source_url, api_key=source_key, timeout=120)
+        print(f"   ✅ Connected to source")
+    except Exception as e:
+        print(f"   ❌ Failed to connect to source: {e}")
+        return 1
+    
+    try:
+        dest_client = QdrantClient(url=dest_url, api_key=dest_key, timeout=120)
+        print(f"   ✅ Connected to destination")
+    except Exception as e:
+        print(f"   ❌ Failed to connect to destination: {e}")
+        return 1
+    
+    # Auto-detect destination collection if not specified
+    if not dest_collection:
+        try:
+            collections = dest_client.get_collections().collections
+            collection_names = [c.name for c in collections]
+            if len(collection_names) == 1:
+                dest_collection = collection_names[0]
+                print(f"\n📋 Auto-detected destination collection: '{dest_collection}'")
+            elif len(collection_names) > 1:
+                print(f"\n⚠️  Found {len(collection_names)} collections in destination:")
+                for name in collection_names:
+                    print(f"   - {name}")
+                print(f"\n   Using first collection: '{collection_names[0]}'")
+                dest_collection = collection_names[0]
+            else:
+                print("❌ No collections found in destination!")
+                return 1
+        except Exception as e:
+            print(f"❌ Could not list destination collections: {e}")
+            return 1
+    
+    # Get collection info
+    print(f"\n📊 Collection Information Comparison")
+    print("="*70)
+    
+    source_info = get_collection_info(source_client, source_collection)
+    dest_info = get_collection_info(dest_client, dest_collection)
+    
+    if not source_info:
+        print("❌ Could not get source collection info")
+        return 1
+    
+    if not dest_info:
+        print("❌ Could not get destination collection info")
+        return 1
+    
+    print(f"\nSource Collection ('{source_collection}'):")
+    print(f"   Vector size: {source_info['vector_size']}")
+    print(f"   Distance: {source_info['distance']}")
+    print(f"   Points: {source_info['points_count']:,}")
+    print(f"   Indexed: {source_info['indexed_vectors_count']:,}")
+    
+    print(f"\nDestination Collection ('{dest_collection}'):")
+    print(f"   Vector size: {dest_info['vector_size']}")
+    print(f"   Distance: {dest_info['distance']}")
+    print(f"   Points: {dest_info['points_count']:,}")
+    print(f"   Indexed: {dest_info['indexed_vectors_count']:,}")
+    
+    # Compare configs
+    print(f"\n🔍 Configuration Comparison:")
+    config_matches = []
+    config_diffs = []
+    
+    if source_info['vector_size'] == dest_info['vector_size']:
+        config_matches.append(f"Vector size: {source_info['vector_size']}")
+    else:
+        config_diffs.append(f"Vector size: source={source_info['vector_size']}, dest={dest_info['vector_size']}")
+    
+    if str(source_info['distance']) == str(dest_info['distance']):
+        config_matches.append(f"Distance: {source_info['distance']}")
+    else:
+        config_diffs.append(f"Distance: source={source_info['distance']}, dest={dest_info['distance']}")
+    
+    if source_info['points_count'] == dest_info['points_count']:
+        config_matches.append(f"Points count: {source_info['points_count']:,}")
+    else:
+        config_diffs.append(f"Points count: source={source_info['points_count']:,}, dest={dest_info['points_count']:,}")
+    
+    if config_matches:
+        print(f"   ✅ Matches: {len(config_matches)}")
+        for match in config_matches:
+            print(f"      - {match}")
+    
+    if config_diffs:
+        print(f"   ❌ Differences: {len(config_diffs)}")
+        for diff in config_diffs:
+            print(f"      - {diff}")
+    
+    # Fetch sample points from source
+    print(f"\n📥 Fetching sample points from source...")
+    sample_size = 2000  # Fetch 20 sample points
+    
+    try:
+        source_points_result, _ = source_client.scroll(
+            collection_name=source_collection,
+            limit=sample_size,
+            with_payload=True,
+            with_vectors=True
+        )
+        
+        if not source_points_result:
+            print("❌ No points found in source collection!")
+            return 1
+        
+        print(f"   ✅ Fetched {len(source_points_result)} points from source")
+        
+        # Extract point IDs
+        source_point_ids = [point.id for point in source_points_result]
+        print(f"   Point IDs: {source_point_ids[:5]}{'...' if len(source_point_ids) > 5 else ''}")
+        
+    except Exception as e:
+        print(f"❌ Error fetching source points: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    # Fetch same points from destination
+    print(f"\n📥 Fetching same points from destination by ID...")
+    try:
+        dest_points_dict = fetch_points_by_ids(dest_client, dest_collection, source_point_ids)
+        print(f"   ✅ Fetched {len(dest_points_dict)} points from destination")
+        
+        missing_ids = set(source_point_ids) - set(dest_points_dict.keys())
+        if missing_ids:
+            print(f"   ⚠️  Missing {len(missing_ids)} points in destination: {list(missing_ids)[:5]}{'...' if len(missing_ids) > 5 else ''}")
+        
+    except Exception as e:
+        print(f"❌ Error fetching destination points: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    # Compare points
+    print(f"\n🔍 Point-by-Point Comparison")
+    print("="*70)
+    
+    comparison_results = []
+    for source_point in source_points_result:
+        point_id = source_point.id
+        dest_point = dest_points_dict.get(point_id)
+        
+        if dest_point is None:
+            comparison_results.append({
+                "point_id": point_id,
+                "status": "MISSING",
+                "matches": [],
+                "differences": [f"Point not found in destination"]
+            })
+        else:
+            comparison = compare_points(source_point, dest_point, point_id)
+            comparison["status"] = "MATCH" if comparison["diff_count"] == 0 else "DIFF"
+            comparison_results.append(comparison)
+    
+    # Summary
+    matches = [r for r in comparison_results if r["status"] == "MATCH"]
+    diffs = [r for r in comparison_results if r["status"] == "DIFF"]
+    missing = [r for r in comparison_results if r["status"] == "MISSING"]
+    
+    print(f"\n📊 Comparison Summary:")
+    print(f"   Total points compared: {len(comparison_results)}")
+    print(f"   ✅ Perfect matches: {len(matches)}")
+    print(f"   ⚠️  Differences found: {len(diffs)}")
+    print(f"   ❌ Missing in destination: {len(missing)}")
+    
+    # Show details for points with differences
+    if diffs:
+        print(f"\n⚠️  Points with differences:")
+        for diff_result in diffs[:10]:  # Show first 10
+            print(f"\n   Point ID: {diff_result['point_id']}")
+            if diff_result['matches']:
+                print(f"      ✅ Matches ({len(diff_result['matches'])}): {', '.join(diff_result['matches'][:5])}")
+            if diff_result['differences']:
+                print(f"      ❌ Differences ({len(diff_result['differences'])}):")
+                for d in diff_result['differences'][:5]:
+                    print(f"         - {d}")
+    
+    if missing:
+        print(f"\n❌ Missing points in destination:")
+        for missing_result in missing[:10]:
+            print(f"   - Point ID: {missing_result['point_id']}")
+    
+    # Final verdict
+    print(f"\n" + "="*70)
+    if len(missing) == 0 and len(diffs) == 0:
+        print("✅ VERIFICATION PASSED: All points match perfectly!")
+        return 0
+    elif len(missing) == 0:
+        print(f"⚠️  VERIFICATION PARTIAL: All points present but {len(diffs)} have differences")
+        return 1
+    else:
+        print(f"❌ VERIFICATION FAILED: {len(missing)} points missing, {len(diffs)} have differences")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+