flowchart TD
    %% User Input and Initial Processing
    A[User Question] --> B[Prompt]
    B --> C{Check Local Knowledge}
    
    %% Knowledge Source Decision Tree
    C -->|Found| D[Generate RAG Response]
    C -->|Not Found| E{Needs Real-time Data?}
    
    %% External API Paths
    E -->|No| F[Query Gemini API]
    E -->|Yes| G[Query Grok API]
    
    %% Response Processing
    D --> H[Format in Prompt]
    F --> H
    G --> H
    
    %% Output and Feedback Loop
    H --> I[Response to User]
    J[User Feedback] --> K[Store for Training]
    
    %% Configuration Management
    L[Local Config] --> B
    L --> C
    L --> E

    %% Debug Information Flow
    style M fill:#f9f,stroke:#333,stroke-width:2px
    M[Debug Info Panel] -.-> B
    M -.-> C
    M -.-> D
    M -.-> F
    M -.-> G
    M -.-> H

    %% Collaboration Status
    N[Hamburger Menu] -.-> O[Status Report]
    
    %% Style Definitions
    classDef api fill:#f96,stroke:#333,stroke-width:2px
    classDef config fill:#9cf,stroke:#333,stroke-width:2px
    classDef process fill:#9f9,stroke:#333,stroke-width:2px
    
    %% Apply Styles
    class F,G api
    class L config
    class B,D,H process

classDiagram
    class AICollaborationManager {
        -ConversationMemory memory
        -VertexAI gemini
        -ChatXAI grok
        -PromptTemplate template
        +process_query()
        -_get_gemini_response()
        -_get_grok_perspective()
        -_synthesize_response()
    }
    
    class ConversationMemory {
        -deque history
        -PGVector vectorstore
        +add_interaction()
        +get_history()
        +get_context_for_collaboration()
        -_sanitize_context()
    }
    
    class FastAPIServer {
        +query_documents()
        +upload_pdf()
        +list_files()
        +reindex_documents()
    }
    
    class IndexerService {
        +process_pdf()
        +index_pdfs()
        +add_embeddings()
    }
    
    class MetricsTracker {
        +start_phase()
        +end_phase()
        +update_search_metrics()
        +finalize()
    }

    AICollaborationManager --> ConversationMemory
    FastAPIServer --> AICollaborationManager
    FastAPIServer --> IndexerService
    IndexerService --> ConversationMemory
    AICollaborationManager --> MetricsTracker

flowchart TD
    A[Query] --> B{Contains Keywords?}
    B -->|Weather, Sports, News| C[Realtime/Grok]
    B -->|No Keywords| D{Vector Search}
    D -->|Results Found| E[RAG Response]
    D -->|No Results| F[Gemini Response]
    
    style C fill:#f96,stroke:#333
    style E fill:#9f9,stroke:#333

sequenceDiagram
    participant U as User
    participant P as QueryProcessor
    participant V as VectorStore
    participant G as Gemini
    participant K as Grok
    
    U->>P: Query
    
    %% RAG Attempt First
    P->>V: Search for Context
    V-->>P: Return Documents
    
    alt Documents Found
        P->>G: Query + RAG Context
        G-->>P: Enhanced Response
        P->>U: Return RAG Response
    else No Documents Found
        P->>G: Query (No Context)
        G-->>P: Response with requires_grok flag
        
        alt requires_grok = true
            P->>K: Get Realtime Data
            K-->>P: Realtime Data
            P->>G: Synthesize Final Response
            G-->>P: Final Response
            P->>U: Return Synthesized Response
        else requires_grok = false
            P->>U: Return Direct Gemini Response
        end
    end

    note over P: Always try RAG first,<br/>only use realtime if no<br/>RAG results and Gemini<br/>flags realtime needed

flowchart TD
    A[User Query] --> B[Log Query Type Detection]
    B --> C{Document Search}
    C -->|Success| D[Log Retrieved Chunks]
    C -->|Failure| E[Log Search Error]
    D --> F[Log RAG Integration]
    E --> G[Log Fallback Path]
    F --> H{API Selection}
    G --> H
    H -->|Gemini| I[Log Gemini Response]
    H -->|Grok| J[Log Grok Response]
    I & J --> K[Log Final Response]
    K --> L[Log UI Updates]
    
    style D fill:#f96
    style E fill:#f96
    style I fill:#f96
    style J fill:#f96

sequenceDiagram
    participant C as Client
    participant F as FastAPI
    participant V as VectorStore
    participant AI as AICollaboration
    participant G as Gemini

    C->>F: Query Request
    F->>V: similarity_search()
    Note over F,V: First Potential Break Point
    
    alt Vector Search Success
        V-->>F: Retrieved Documents
        F->>AI: Process with RAG Context
        AI->>G: Generate with Context
        G-->>AI: Enhanced Response
        AI-->>F: Final Response
    else Vector Search Failure
        V-->>F: No Results/Error
        Note over F,V: Second Break Point
        F->>AI: Process without Context
        AI->>G: Direct Generation
        G-->>AI: Base Response
        AI-->>F: Fallback Response
    end
    
    F-->>C: Response to Client

flowchart TD
    A[Client Request] --> B[Load Balancer/Health Check]
    B --> C[FastAPI Server]
    
    subgraph Critical Monitoring Points
    C --> D{Vector Search}
    D --> |Success| E[Document Processing]
    D --> |Failure| F[Fallback Path]
    
    E --> G{API Calls}
    F --> G
    
    G --> |Basic| H[Gemini]
    G --> |Real-time| I[Grok -> Gemini]
    end
    
    H --> J[Response]
    I --> J
    
    style B fill:#ff9999,stroke:#333,stroke-width:2px
    style D fill:#ff9999,stroke:#333,stroke-width:2px
    style G fill:#ff9999,stroke:#333,stroke-width:2px
    
    %% Monitoring metrics
    M1[Response Time] -.-> B
    M2[Memory Usage] -.-> D
    M3[API Latency] -.-> G
    
    classDef metric fill:#ccffcc,stroke:#333,stroke-width:1px
    class M1,M2,M3 metric