app.py

"""
RAG Chatbot Application
=======================
DAY 4: Main Streamlit application entry point.

This is the main file that brings everything together!

Run with: streamlit run app.py
"""

import streamlit as st

# Import configuration and validate settings
from config.settings import settings

# Validate API keys before anything else
try:
    settings.validate()
except ValueError as e:
    st.error(f"⚠️ Configuration Error:\n\n{str(e)}")
    st.stop()

# Import UI components
from ui.components import (
    init_session_state,
    display_chat_history,
    add_message,
    display_sidebar_info,
    display_file_uploader,
    display_processing_status,
    
)
from ui.chat_interface import ChatInterface


def _display_evidence_tabs(sources: dict):
    """Display a compact evidence panel (no tabs)."""
    st.markdown("**Sources & Evidence**")
    st.divider()

    # Document sources
    if sources.get("document_sources"):
        st.markdown("**Document Sources:**")
        for doc in sources["document_sources"]:
            with st.expander(f"📄 {doc['name']}"):
                st.markdown(f"**Source:** {doc['name']}")
                st.markdown(f"**Preview:** {doc['content_preview']}")
    else:
        st.markdown("**Document Sources:** None")

    st.divider()

    # Web sources
    if sources.get("web_sources"):
        st.markdown("**Web Sources:**")
        for web in sources["web_sources"]:
            with st.expander(f"🌐 {web.get('title','No title')[:60]}..."):
                st.markdown(f"**Title:** {web.get('title','No title')}")
                st.markdown(f"**URL:** {web.get('url','')}")
                st.markdown(f"**Preview:** {web.get('content_preview','')}")
                if web.get('url'):
                    st.markdown(f"[🔗 Open Link]({web.get('url')})")
    else:
        st.markdown("**Web Sources:** None")

    st.divider()

    # Routing & relevance
    routing = sources.get("routing", {})
    if routing:
        if routing.get("category") == "document":
            st.markdown("📄 **Document-only search**")
        elif routing.get("category") == "web":
            st.markdown("🌐 **Web-only search**")
        else:
            st.markdown("🔀 **Hybrid search** (documents + web)")

        st.markdown(f"**Reason:** {routing.get('reason','')}")

        # Show relevance evaluation if available
        relevance = routing.get("relevance_check")
        if relevance:
            confidence_color = {
                "HIGH": "🟢",
                "MEDIUM": "🟡",
                "LOW": "🔴"
            }.get(relevance.get("confidence"), "⚪")

            st.markdown(f"**Local Content Relevance:** {confidence_color} {relevance.get('confidence')}")
            st.markdown(f"**Evaluation:** {relevance.get('reason')}")
            st.markdown(f"**Confidence Score:** {relevance.get('score',0):.1f}/1.0")


# Page configuration
st.set_page_config(
    page_title="RAG Chatbot",
    page_icon="🤖",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Custom CSS for better appearance
st.markdown("""
    <style>
    .stApp {
        max-width: 1200px;
        margin: 0 auto;
    }
    </style>
""", unsafe_allow_html=True)


def main():
    """Main application function."""
    
    # Initialize session state
    init_session_state()
    
    # Initialize chat interface (cached in session state)
    if "chat_interface" not in st.session_state:
        st.session_state.chat_interface = ChatInterface()
    
    chat = st.session_state.chat_interface
    
    # Display sidebar
    display_sidebar_info()
    
    # Main content area
    st.title("RAG Chatbot")
    st.markdown("Chat with your documents using AI")
    
    # File upload section
    with st.expander("Upload Documents", expanded=not st.session_state.vector_store_initialized):
        uploaded_files = display_file_uploader()
        
        if uploaded_files:
            # Process button
            if st.button("Process Documents", type="primary"):
                with st.spinner("Processing documents..."):
                    try:
                        num_chunks = chat.process_uploaded_files(uploaded_files)
                        display_processing_status(
                            f"Processed {len(uploaded_files)} file(s) into {num_chunks} chunks!",
                            "success"
                        )
                    except Exception as e:
                        display_processing_status(f"Error: {str(e)}", "error")
    
    # Web search toggle (fixed in sidebar); read value from session state
    use_web_search = st.session_state.get("use_web_search", False)
    
    st.divider()
    
    # Display chat history
    display_chat_history()
    
    # Chat input
    if prompt := st.chat_input("Ask a question about your documents..."):
        # Add user message
        add_message("user", prompt)
        
        # Display user message
        with st.chat_message("user"):
            st.markdown(prompt)
        
        # Generate and display assistant response
        with st.chat_message("assistant"):
            try:
                # Stream the response
                response_placeholder = st.empty()
                full_response = ""
                
                for chunk in chat.get_response(prompt, use_web_search=use_web_search):
                    full_response += chunk
                    response_placeholder.markdown(full_response)
                
                # Get detailed sources
                sources = chat.get_sources(prompt, use_web_search=use_web_search)
                
                # Display evidence tabs
                if sources["document_sources"] or sources["web_sources"]:
                    _display_evidence_tabs(sources)
                
                # Add assistant message to history
                add_message("assistant", full_response, sources)
                
            except Exception as e:
                error_msg = f"Error generating response: {str(e)}"
                st.error(error_msg)
                add_message("assistant", error_msg)


if __name__ == "__main__":
    main()