adding other components

app.py

@@ -72,72 +72,57 @@ with gr.Blocks(theme=gr.themes.Monochrome(), fill_width = True) as dashboard_app
         with gr.Tab("Retriever and Reranker"):
             with gr.Row(elem_classes = "centered-content-row"):
                 with gr.Column(scale=1):
-                    gr.Markdown("## What is Retriever ?")
+                    gr.Markdown("### What is Retriever ?")
                     gr.Markdown("""It is the crucial process of efficiently finding and extracting relevant \
                         information from a vast knowledge base to ground and inform the chatbot's final answer.""")
                     gr.Markdown(retriverText)
                     embed_space("https://giz-chatfed-retriever0-3.hf.space", height=700)
         
-        # 4. File Ingestor (Embedding via iframe pending due to compliance and Readme documentation missing)
+        # 4. File Ingestor (Embedding via iframe)
         with gr.Tab("File Ingestor"):
             with gr.Row(elem_classes = "centered-content-row"):
                 with gr.Column(scale=1):
-                    gr.Markdown("## What is File Ingestor")
+                    gr.Markdown("### What is File Ingestor")
                     gr.Markdown("""In certain chatbot use-cases it might be that user input can be a file upload,\
                         on top of existing Vector Database. In this case it's important that we ingest this \
                         file and use it for next for  relevant use """)
                     gr.Markdown(fileingestorText)
-        ###  Enables this once space is public: after Proper EU aI act compliance  release embed_space("https://giz-chatfed-whisp.hf.space", height=700)
+                    embed_space("https://giz-eudr-chabo-ingestor.hf.space", height=700)
         
         # 5. Generator
         with gr.Tab("Generator"):
             with gr.Row(elem_classes = "centered-content-row"):
                 with gr.Column(scale=1):
-                    gr.Markdown("## What is Generator?")
-                    gr.Markdown("""It is the microserviceis the crucial process of efficiently finding and extracting relevant \
-                        information from a vast knowledge base to ground and inform the chatbot's final answer.""")
-                    gr.Markdown(generatorText)  
+                    gr.Markdown("### What is Generator?")
+                    gr.Markdown("""Drawing upon the relevant context provided by the retrieval \
+                        the Generator is the module responsible for producing the final, coherent, and natural-sounding \
+                        text response that directly addresses the user's query.""")
+                    gr.Markdown(generatorText)
         
-        # 6. Orchest
+        # 6. Orchestrator (Embedding via iframe)
         with gr.Tab("Orchestrator"):
             with gr.Row(elem_classes = "centered-content-row"):
                 with gr.Column(scale=1):
-                    gr.Markdown("## What is Orchestrator ?")
+                    gr.Markdown("### What is Orchestrator ?")
                     gr.Markdown(""" The Orchestrator is the central command module, defining the exact \
                         steps and flow of data: it sequences the initial user prompt, directs the query \
                         to the correct vector retrieval module, manages the document reranking (if applicable),\
-                        and finally routes the retrieved context and original prompt to the Large Language Model \
-                        (LLM) for final answer generation..""")
+                        and finally routes the retrieved context and original prompt to the Generator module \
+                        for final answer generation. """)
+                    embed_space("https://giz-eudr-chabo-orchestrator.hf.space/gradio/")
                     gr.Markdown(orchestratorText)  
 
+        # 7. HuggingFace Chat UI (Embedding via iframe)
         with gr.Tab("HuggingFace Chat UI"):
             with gr.Row(elem_classes = "centered-content-row"):
                 with gr.Column(scale=1):
-                    gr.Markdown("## What is Retriever ?")
-                    gr.Markdown("""It is the crucial process of efficiently finding and extracting relevant \
-                        information from a vast knowledge base to ground and inform the chatbot's final answer.""")
-                    gr.Markdown(""" This mciroservice integrates with the vector database to retrieve semantically relevant documents,\
-                        with optional reranking for precision, ready for seamless use in ChaBo RAG workflows.  \
-                        
-                        For more info on Retriever and code base visit the following links:
-                        - ChaBo_Retriever : [**ReadMe**](https://huggingface.co/spaces/GIZ/chatfed_retriever0.3/blob/main/README.md)
-                        - ChaBo_Retriever: [**Codebase**](https://huggingface.co/spaces/GIZ/chatfed_retriever0.3/tree/main)""")
-                    embed_space("https://giz-chatfed-retriever0-3.hf.space", height=700) 
-
-        with gr.Tab("Integrated UI"):
-            with gr.Row(elem_classes = "centered-content-row"):
-                with gr.Column(scale=1):
-                    gr.Markdown("## What is Retriever ?")
-                    gr.Markdown("""It is the crucial process of efficiently finding and extracting relevant \
-                        information from a vast knowledge base to ground and inform the chatbot's final answer.""")
-                    gr.Markdown(""" This mciroservice integrates with the vector database to retrieve semantically relevant documents,\
-                        with optional reranking for precision, ready for seamless use in ChaBo RAG workflows.  \
-                        
-                        For more info on Retriever and code base visit the following links:
-                        - ChaBo_Retriever : [**ReadMe**](https://huggingface.co/spaces/GIZ/chatfed_retriever0.3/blob/main/README.md)
-                        - ChaBo_Retriever: [**Codebase**](https://huggingface.co/spaces/GIZ/chatfed_retriever0.3/tree/main)""")
-                    embed_space("https://giz-chatfed-retriever0-3.hf.space", height=700)            
-        
+                    gr.Markdown("## What is HuggingFace Chat UI ?")
+                    gr.Markdown("""The Hugging Face Chat UI is a streamlined, open-source web interface \
+                        specifically designed for building and deploying conversational AI applications. \
+                        It offers a powerful, ready-to-use frontend for RAG pipelines and LLMs, \
+                        enabling rapid prototyping and deployment on platforms like Hugging Face Spaces""")
+                    embed_space("https://giz-eudr-chatbo-chatui.hf.space", height=700) 
+       
 
 dashboard_app.css = """
         .centered-content-row {

fileingestor.py

@@ -1,4 +1,4 @@
-fileingestorText = """ This mciroservice integrates with the Orchestrator and HuggingFace Chat UI and \
+fileingestorText = """ This microservice integrates with the Orchestrator and HuggingFace Chat UI and \
                          uses the deterministic tool for further processing/actions.  \
                         
                         [ChaBo_FileIngestor](https://huggingface.co/spaces/GIZ/eudr_chabo_ingestor) hosts a microservice which takes the \

orchestrator.py

@@ -1,5 +1,7 @@
-orchestratorText = """ # Chabo Orchestrator Documentation 
-                ## Table of Contents
+orchestratorText = """ 
+                # Chabo Orchestrator Documentation 
+
+                ### Table of Contents
                 1. Overview
                 2. System Architecture
                 3. Components
@@ -11,158 +13,160 @@ orchestratorText = """ # Chabo Orchestrator Documentation
 
                 ## Overview
 
-                The Chabo Orchestrator is the central coordination module of the Chabo RAG system. It orchestrates the flow between multiple microservices to provide intelligent document processing and question-answering capabilities. The system is designed for deployment on Huggingface Spaces.
-
-                ### Key Features
-                    - **Workflow Orchestration**: Uses LangGraph to manage complex processing pipelines
-                    - **Multi-Modal Support**: Handles files dependent on ChatUI and Ingestor config (e.g. PDF, DOCX, GeoJSON, and JSON )
-                    - **Streaming Responses**: Real-time response generation with Server-Sent Events (SSE)
-                    - **Dual Processing Modes**:
-                    - **Direct Output Mode**: Returns ingestor results immediately (e.g. EUDR use case)
-                    - **Standard RAG Mode**: Full retrieval-augmented generation pipeline
-                    - **Intelligent Caching**: Prevents redundant file processing (e.g. EUDR use case)
-                    - **Multiple Interfaces**: FastAPI endpoints for modules; LangServe endpoints for ChatUI; Gradio UI for testing
-
-
-                    ## System Architecture
-
-                    ### High-Level Architecture
-
-                    ```
-                    ┌─────────────────┐
-                    │   ChatUI        │
-                    │   Frontend      │
-                    └────────┬────────┘
-                            │ HTTP/SSE
-                            ▼
-                    ┌─────────────────────────────────┐
-                    │   Chabo Orchestrator            │
-                    │   ┌─────────────────────────┐   │
-                    │   │   LangGraph Workflow    │   │
-                    │   │   ┌─────────────────┐   │   │
-                    │   │   │ Detect File     │   │   │
-                    │   │   │ Type            │   │   │
-                    │   │   └────────┬────────┘   │   │
-                    │   │            │            │   │
-                    │   │   ┌────────▼────────┐   │   │
-                    │   │   │ Ingest File     │   │   │
-                    │   │   └────────┬────────┘   │   │
-                    │   │            │            │   │
-                    │   │      ┌─────┴──────┐     │   │
-                    │   │      │            │     │   │
-                    │   │   ┌──▼───┐   ┌────▼───┐ │   │
-                    │   │   │Direct│   │Retrieve│ │   │
-                    │   │   │Output│   │Context │ │   │
-                    │   │   └──┬───┘   └────┬───┘ │   │
-                    │   │      │            │     │   │
-                    │   │      │       ┌────▼───┐ │   │
-                    │   │      │       │Generate│ │   │
-                    │   │      │       │Response│ │   │
-                    │   │      │       └────────┘ │   │
-                    │   └──────┴──────────────────┘   │
-                    └──────┬───────────┬──────────┬───┘
-                        │           │          │
+                The Chabo Orchestrator is the central coordination module of the Chabo RAG system. \
+                It orchestrates the flow between multiple microservices to provide intelligent \
+                document processing and question-answering capabilities. The system is designed for deployment on Huggingface Spaces.
+
+                ### Key Features:
+                - **Workflow Orchestration**: Uses LangGraph to manage complex processing pipelines
+                - **Multi-Modal Support**: Handles files dependent on ChatUI and Ingestor config (e.g. PDF, DOCX, GeoJSON, and JSON )
+                - **Streaming Responses**: Real-time response generation with Server-Sent Events (SSE)
+                - **Dual Processing Modes**:
+                - **Direct Output Mode**: Returns ingestor results immediately (e.g. EUDR use case)
+                - **Standard RAG Mode**: Full retrieval-augmented generation pipeline
+                - **Intelligent Caching**: Prevents redundant file processing (e.g. EUDR use case)
+                - **Multiple Interfaces**: FastAPI endpoints for modules; LangServe endpoints for ChatUI; Gradio UI for testing
+
+                ## System Architecture
+
+                ### High-Level Architecture
+
+                ```
+
+                        ┌─────────────────┐
+                        │   ChatUI        │
+                        │   Frontend      │
+                        └────────┬────────┘
+                                 │ HTTP/SSE
+                                 ▼
+                ┌─────────────────────────────────┐
+                │      Chabo Orchestrator         │
+                │   ┌─────────────────────────┐   │
+                │   │   LangGraph Workflow    │   │
+                │   │   ┌─────────────────┐   │   │
+                │   │   │ Detect File     │   │   │
+                │   │   │ Type            │   │   │
+                │   │   └────────┬────────┘   │   │
+                │   │            │            │   │
+                │   │   ┌────────▼────────┐   │   │
+                │   │   │ Ingest File     │   │   │
+                │   │   └────────┬────────┘   │   │
+                │   │            │            │   │
+                │   │      ┌─────┴──────┐     │   │
+                │   │      │            │     │   │
+                │   │   ┌──▼───┐   ┌────▼───┐ │   │
+                │   │   │Direct│   │Retrieve│ │   │
+                │   │   │Output│   │Context │ │   │
+                │   │   └──┬───┘   └────┬───┘ │   │
+                │   │      │            │     │   │
+                │   │      │       ┌────▼───┐ │   │
+                │   │      │       │Generate│ │   │
+                │   │      │       │Response│ │   │
+                │   │      │       └────────┘ │   │
+                │   └──────┴──────────────────┘   │
+                └──────┬───────────┬──────────┬───┘
+                       │           │          │
                     ┌───▼──┐   ┌───▼───┐   ┌──▼────┐
                     │Ingest│   │Retrie-│   │Genera-│
                     │or    │   │ver    │   │tor    │
                     └──────┘   └───────┘   └───────┘
-                    ```
-
-                    ### Component Communication
-
-                    All communication between modules happens over HTTP:
-                    - **Orchestrator ↔ Ingestor**: Gradio Client (file upload, processing)
-                    - **Orchestrator ↔ Retriever**: Gradio Client (semantic search)
-                    - **Orchestrator ↔ Generator**: HTTP streaming (SSE for real-time responses)
-                    - **ChatUI ↔ Orchestrator**: LangServe streaming endpoints
+                
+                ```
+                ### Component Communication
 
-                    ### Workflow Logic
+                All communication between modules happens over HTTP:
+                - **Orchestrator ↔ Ingestor**: Gradio Client (file upload, processing)
+                - **Orchestrator ↔ Retriever**: Gradio Client (semantic search)
+                - **Orchestrator ↔ Generator**: HTTP streaming (SSE for real-time responses)
+                - **ChatUI ↔ Orchestrator**: LangServe streaming endpoints
 
-                    The orchestrator implements two distinct workflows:
+                ### Workflow Logic
 
-                    **Direct Output Workflow** (when `DIRECT_OUTPUT=True` and file is new):
-                    ```
+                The orchestrator implements two distinct workflows:
+                **Direct Output Workflow** (when `DIRECT_OUTPUT=True` and file is new):
+                ```
                     File Upload → Detect Type → Ingest → Direct Output → Return Results
-                    ```
-
-                    **Standard RAG Workflow** (default or cached files):
-                    ```
+                ```
+                **Standard RAG Workflow** (default or cached files):
+                ```
                     Query → Retrieve Context → Generate Response → Stream to User
-                    ```
+                ```
+
 
-                    ## Components
+                ## Components
 
-                    ### 1. Main Application (`main.py`)
+                ### 1. Main Application (`main.py`)
+                - LangServe endpoints for ChatUI integration
+                - Gradio web interface for testing
+                - FastAPI endpoints for diagnostics and future use (e.g. /health)
+                - Cache management endpoint (for direct output use cases)
 
-                    - LangServe endpoints for ChatUI integration
-                    - Gradio web interface for testing
-                    - FastAPI endpoints for diagnostics and future use (e.g. /health)
-                    - Cache management endpoint (for direct output use cases)
 
-                    **Key Functions:**
-                    - `chatui_adapter()`: Handles text-only queries
-                    - `chatui_file_adapter()`: Handles file uploads with queries
-                    - `create_gradio_interface()`: Test UI
+                **Key Functions:**
+                - `chatui_adapter()`: Handles text-only queries
+                - `chatui_file_adapter()`: Handles file uploads with queries
+                - `create_gradio_interface()`: Test UI
 
-                    ### 2. Workflow Nodes (`nodes.py`)
+                ### 2. Workflow Nodes (`nodes.py`)
 
-                    LangGraph nodes that implement the processing pipeline:
+                LangGraph nodes that implement the processing pipeline:
 
-                    **Node Functions:**
+                **Node Functions:**
 
-                    - `detect_file_type_node()`: Identifies file type and determines routing
-                    - `ingest_node()`: Processes files through appropriate ingestor
-                    - `direct_output_node()`: Returns raw ingestor results
-                    - `retrieve_node()`: Fetches relevant context from vector store
-                    - `generate_node_streaming()`: Streams LLM responses
-                    - `route_workflow()`: Conditional routing logic
+                - `detect_file_type_node()`: Identifies file type and determines routing
+                - `ingest_node()`: Processes files through appropriate ingestor
+                - `direct_output_node()`: Returns raw ingestor results
+                - `retrieve_node()`: Fetches relevant context from vector store
+                - `generate_node_streaming()`: Streams LLM responses
+                - `route_workflow()`: Conditional routing logic
 
-                    **Helper Functions:**
+                **Helper Functions:**
 
-                    - `process_query_streaming()`: Unified streaming interface
-                    - `compute_file_hash()`: SHA256 hashing for deduplication
-                    - `clear_direct_output_cache()`: Cache management
+                - `process_query_streaming()`: Unified streaming interface
+                - `compute_file_hash()`: SHA256 hashing for deduplication
+                - `clear_direct_output_cache()`: Cache management
 
-                    ### 3. Data Models (`models.py`)
+                ### 3. Data Models (`models.py`)
 
-                    Pydantic models for type validation
+                Pydantic models for type validation
 
-                    ### 4. Retriever Adapter (`retriever_adapter.py`)
+                ### 4. Retriever Adapter (`retriever_adapter.py`)
 
-                    Abstraction layer for managing different retriever configurations:
-                    - Handles authentication
-                    - Formats queries and filters
+                Abstraction layer for managing different retriever configurations:
+                - Handles authentication
+                - Formats queries and filters
 
-                    ### 5. Utilities (`utils.py`)
+                 ### 5. Utilities (`utils.py`)
 
-                    Helper functions
+                Helper functions
 
-                    #### Conversation Context Management
+                #### Conversation Context Management
 
-                    The `build_conversation_context()` function manages conversation history to provide relevant context to the generator while respecting token limits and conversation flow.
+                The `build_conversation_context()` function manages conversation history to provide relevant context to the generator while respecting token limits and conversation flow.
 
-                    **Key Features:**
+                **Key Features:**
 
-                    - **Context Selection**: Always includes the first user and assistant messages to maintain conversation context
-                    - **Recent Turn Limiting**: Includes only the last N complete turns (user + assistant pairs) to focus on recent conversation (default: 3)
-                    - **Character Limit Management**: Truncates to maximum character limits to prevent context overflow
+                - **Context Selection**: Always includes the first user and assistant messages to maintain conversation context
+                - **Recent Turn Limiting**: Includes only the last N complete turns (user + assistant pairs) to focus on recent conversation (default: 3)
+                - **Character Limit Management**: Truncates to maximum character limits to prevent context overflow
 
 
-                    **Function Parameters:**
+                **Function Parameters:**
 
-                    ```python
+                ```python
                     def build_conversation_context(
                         messages,           # List of Message objects from conversation
                         max_turns: int = 3, # Maximum number of recent turns to include
                         max_chars: int = 8000  # Maximum total characters in context
                     ) -> str
-                    ```
+                ```
 
-                    ## Configuration
+                
+                ## Configuration
 
-                    ### Configuration File (`params.cfg`)
+                ### Configuration File (`params.cfg`)
 
-                    ```ini
+                ```ini
                     [file_processing]
                     # Enable direct output mode: when True, ingestor results are returned directly
                     # without going through the generator. When False, all files go through full RAG pipeline.
@@ -189,32 +193,31 @@ orchestratorText = """ # Chabo Orchestrator Documentation
                     [general]
                     # need to include this for HF inference endpoint limits
                     MAX_CONTEXT_CHARS = 15000 
-                    ```
+                ```
 
-                    ### Environment Variables
+                ### Environment Variables
 
-                    Create a `.env` file with:
+                Create a `.env` file with:
 
-                    ```bash
+                ```bash
                     # Required for private HuggingFace Spaces
                     HF_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxx
+                ```
 
-                    ```
-
-                    ### ChatUI Configuration
+                ### ChatUI Configuration
 
-                    ChatUI `DOTENV_LOCAL` example deployment configuration:
+                ChatUI `DOTENV_LOCAL` example deployment configuration:
 
-                    ```javascript
+                ```javascript
                     MODELS=`[
                     {
                         "name": "asistente_eudr",
                         "displayName": "Asistente EUDR",
                         "description": "Retrieval-augmented generation on EUDR Whisp API powered by ChatFed modules.",
-                    "instructions": {
-                        "title": "EUDR Asistente: Instructiones",
-                        "content": "Hola, soy Asistente EUDR, un asistente conversacional basado en inteligencia artificial diseñado para ayudarle a comprender el cumplimiento y el análisis del Reglamento de la UE sobre la deforestación. Responderé a sus preguntas utilizando los informes EUDR y los archivos GeoJSON cargados.\n\n💡 **Cómo utilizarlo (panel a la derecha)**\n\n**Modo de uso:** elija entre subir un archivo GeoJSON para su análisis o consultar los informes EUDR filtrados por país.\n\n**Ejemplos:** seleccione entre preguntas de ejemplo seleccionadas de diferentes categorías.\n\n**Referencias:** consulte las fuentes de contenido utilizadas para la verificación de datos.\n\n⚠️ Para conocer las limitaciones y la información sobre la recopilación de datos, consulte la pestaña «Exención de responsibilidad».\n\n⚠️ Al utilizar esta aplicación, usted acepta que recopilemos estadísticas de uso (como preguntas formuladas, comentarios realizados, duración de la sesión, tipo de dispositivo e información geográfica anónima) para comprender el rendimiento y mejorar continuamente la herramienta, basándonos en nuestro interés legítimo por mejorar nuestros servicios."
-                    },
+                        "instructions": {
+                            "title": "EUDR Asistente: Instructiones",
+                            "content": "Hola, soy Asistente EUDR, un asistente conversacional basado en inteligencia artificial diseñado para ayudarle a comprender el cumplimiento y el análisis del Reglamento de la UE sobre la deforestación. Responderé a sus preguntas utilizando los informes EUDR y los archivos GeoJSON cargados.\\n\\n💡 **Cómo utilizarlo (panel a la derecha)**\\n\\n**Modo de uso:** elija entre subir un archivo GeoJSON para su análisis o consultar los informes EUDR filtrados por país.\\n\\n**Ejemplos:** seleccione entre preguntas de ejemplo seleccionadas de diferentes categorías.\\n\\n**Referencias:** consulte las fuentes de contenido utilizadas para la verificación de datos.\\n\\n⚠️ Para conocer las limitaciones y la información sobre la recopilación de datos, consulte la pestaña «Exención de responsabilidad»\\n\\n⚠️ Al utilizar esta aplicación, usted acepta que recopilemos estadísticas de uso (como preguntas formuladas, comentarios realizados, duración de la sesión, tipo de dispositivo e información geográfica anónima) para comprender el rendimiento y mejorar continuamente la herramienta, basándonos en nuestro interés legítimo por mejorar nuestros servicios."
+                        },
                         "multimodal": true,
                         "multimodalAcceptedMimetypes": [
                         "application/geojson"
@@ -226,307 +229,301 @@ orchestratorText = """ # Chabo Orchestrator Documentation
                         },
                         "endpoints": [{
                         "type": "langserve-streaming",
-                        "url": "https://giz-eudr-chabo-orchestrator.hf.space/chatfed-ui-stream",
-                        "streamingFileUploadUrl": "https://giz-eudr-chabo-orchestrator.hf.space/chatfed-with-file-stream",
+                        "url": "[https://giz-eudr-chabo-orchestrator.hf.space/chatfed-ui-stream](https://giz-eudr-chabo-orchestrator.hf.space/chatfed-ui-stream)",
+                        "streamingFileUploadUrl": "[https://giz-eudr-chabo-orchestrator.hf.space/chatfed-with-file-stream](https://giz-eudr-chabo-orchestrator.hf.space/chatfed-with-file-stream)",
                         "inputKey": "text",
                         "fileInputKey": "files"
                         }]
                     }
-                    ]`
-
-                    PUBLIC_ANNOUNCEMENT_BANNERS=`[
-                        {
-                        "title": "This is Chat Prototype for DSC users",
-                        "linkTitle": "Keep it Clean"
-                    }
-                    ]`
-
-                    PUBLIC_APP_DISCLAIMER_MESSAGE="Disclaimer: AI is an area of active research with known problems such as biased generation and misinformation. Do not use this application for high-stakes decisions or advice. Do not insert your personal data, especially sensitive, like health data."
-                    PUBLIC_APP_DESCRIPTION="Internal Chat-tool for DSC users for testing"
-
-                    PUBLIC_APP_NAME="EUDR ChatUI" 
-                    ENABLE_ASSISTANTS=false
-                    ENABLE_ASSISTANTS_RAG=false
-                    COMMUNITY_TOOLS=false
-                    MONGODB_URL=mongodb://localhost:27017
-
-                    # Disable LLM-based title generation to prevent template queries
-                    LLM_SUMMARIZATION=false
-                    ```
-
-                    Key things to ensure here:
-                    - multimodalAcceptedMimetypes: file types to accept for upload via ChatUI
-                    - endpoints: orchestrator url + endpoints
-
-                    ## Deployment Guide
-
-                    ### Local Development
-
-                    **Prerequisites:**
-                    - Python 3.10+
-                    - pip
-
-                    **Steps:**
-
-                    1. Clone the repository:
-                    ```bash
-                    git clone <your-repo-url>
-                    cd chabo-orchestrator
-                    ```
-
-                    2. Install dependencies:
-                    ```bash
-                    pip install -r requirements.txt
-                    ```
-
-                    3. Configure the system:
-                    ```bash
-                    # Create .env file
-                    echo "HF_TOKEN=your_token_here" > .env
-
-                    # Edit params.cfg with your service URLs
-                    nano params.cfg
-                    ```
-
-                    4. Run the application:
-                    ```bash
-                    python app/main.py
-                    ```
-
-                    5. Access interfaces:
-                    - Gradio UI: http://localhost:7860/gradio
-                    - API Docs: http://localhost:7860/docs
-                    - Health Check: http://localhost:7860/health
-
-                    ### Docker Deployment
-
-                    **Build the image:**
-
-                    ```bash
-                    docker build -t chabo-orchestrator .
-                    ```
-
-                    **Run the container:**
-
-                    ```bash
-                    docker run -d \
-                    --name chabo-orchestrator \
-                    -p 7860:7860 \
-                    chabo-orchestrator
-                    ```
-
-                    ### HuggingFace Spaces Deployment
-
-                    **Repository Structure:**
-                    ```
-                    your-space/
-                    ├── app/
-                    │   ├── main.py
-                    │   ├── nodes.py
-                    │   ├── models.py
-                    │   ├── retriever_adapter.py
-                    │   └── utils.py
-                    ├── Dockerfile
-                    ├── requirements.txt
-                    ├── params.cfg
-                    └─�� README.md
-                    ```
-
-                    **Steps:**
-
-                    1. Create a new Space on HuggingFace
-                    2. Select "Docker" as the SDK
-                    3. Push your code to the Space repository
-                    4. Add secrets in Space settings:
-                    - `HF_TOKEN`: Your HuggingFace token
-                    5. The Space will automatically build and deploy
-
-                    **Important:** Ensure all service URLs in `params.cfg` are publicly accessible.
-
-                    ### Docker Compose (Multi-Service)
-
-                    Example orchestrated deployment for the entire Chabo stack (*NOTE - docker-compose will not run on Huggingface spaces*)
-
-                    ```yaml
-                    version: '3.8'
-
-                    services:
-                    orchestrator:
-                        build: ./orchestrator
-                        ports:
-                        - "7860:7860"
-                        environment:
-                        - HF_TOKEN=${HF_TOKEN}
-                        - RETRIEVER=http://retriever:7861
-                        - GENERATOR=http://generator:7862
-                        - INGESTOR=http://ingestor:7863
-                        depends_on:
-                        - retriever
-                        - generator
-                        - ingestor
-
-                    retriever:
-                        build: ./retriever
-                        ports:
-                        - "7861:7861"
-                        environment:
-                        - QDRANT_API_KEY=${QDRANT_API_KEY}
-
-                    generator:
-                        build: ./generator
-                        ports:
-                        - "7862:7862"
-                        environment:
-                        - HF_TOKEN=${HF_TOKEN}
-
-                    ingestor:
-                        build: ./ingestor
-                        ports:
-                        - "7863:7863"
-                    ```
-
-                    ## API Reference
-
-                    ### Endpoints
-
-                    #### Health Check
-                    ```
-                    GET /health
-                    ```
-                    Returns service health status.
-
-                    **Response:**
-                    ```json
+                ]`
+                
+                PUBLIC_ANNOUNCEMENT_BANNERS=`[
                     {
-                    "status": "healthy"
+                    "title": "This is Chat Prototype for DSC users",
+                    "linkTitle": "Keep it Clean"
                     }
-                    ```
-
-                    #### Root Information
-                    ```
-                    GET /
-                    ```
-                    Returns API metadata and available endpoints.
-
-                    #### Text Query (Streaming)
-                    ```
-                    POST /chatfed-ui-stream/stream
-                    Content-Type: application/json
-                    ```
-
-                    **Request Body:**
-                    ```json
+                ]`
+
+                PUBLIC_APP_DISCLAIMER_MESSAGE="Disclaimer: AI is an area of active research with known problems such as biased generation and misinformation. Do not use this application for high-stakes decisions or advice. Do not insert your personal data, especially sensitive, like health data."
+                PUBLIC_APP_DESCRIPTION="Internal Chat-tool for DSC users for testing"
+
+                PUBLIC_APP_NAME="EUDR ChatUI" 
+                ENABLE_ASSISTANTS=false
+                ENABLE_ASSISTANTS_RAG=false
+                COMMUNITY_TOOLS=false
+                MONGODB_URL=mongodb://localhost:27017
+
+                # Disable LLM-based title generation to prevent template queries
+                LLM_SUMMARIZATION=false
+                ```
+                Key things to ensure here:
+                - multimodalAcceptedMimetypes: file types to accept for upload via ChatUI
+                - endpoints: orchestrator url + endpoints
+
+                ## Deployment Guide
+
+                ### Local Development
+
+                **Prerequisites:**
+                - Python 3.10+
+                - pip
+
+                **Steps:**
+
+                1. Clone the repository:
+                ```bash
+                git clone <your-repo-url>
+                cd chabo-orchestrator
+                ```
+
+                2. Install dependencies:
+                ```bash
+                pip install -r requirements.txt
+                ```
+
+                3. Configure the system:
+                ```bash
+                # Create .env file
+                echo "HF_TOKEN=your_token_here" > .env
+
+                # Edit params.cfg with your service URLs
+                nano params.cfg
+                ```
+
+                4. Run the application:
+                ```bash
+                python app/main.py
+                ```
+
+                5. Access interfaces:
+                - Gradio UI: http://localhost:7860/gradio
+                - API Docs: http://localhost:7860/docs
+                - Health Check: http://localhost:7860/health
+            
+                ### Docker Deployment
+
+                **Build the image:**
+
+                ```bash
+                docker build -t chabo-orchestrator .
+                ```
+
+                **Run the container:**
+
+                ```bash
+                docker run -d --name chabo-orchestrator -p 7860:7860 chabo-orchestrator
+                ```
+
+                ### HuggingFace Spaces Deployment
+
+
+                **Repository Structure:**
+                ```
+                your-space/
+                ├── app/
+                │   ├── main.py
+                │   ├── nodes.py
+                │   ├── models.py
+                │   ├── retriever_adapter.py
+                │   └── utils.py
+                ├── Dockerfile
+                ├── requirements.txt
+                ├── params.cfg
+                └── README.md
+                ```
+                **Steps:**
+
+                1. Create a new Space on HuggingFace
+                2. Select "Docker" as the SDK
+                3. Push your code to the Space repository
+                4. Add secrets in Space settings:
+                - `HF_TOKEN`: Your HuggingFace token
+                5. The Space will automatically build and deploy
+
+                **Important:** Ensure all service URLs in `params.cfg` are publicly accessible.
+
+                ### Docker Compose (Multi-Service)
+
+                Example orchestrated deployment for the entire Chabo stack (*NOTE - docker-compose will not run on Huggingface spaces*)
+                ```yaml
+                version: '3.8'
+
+                services:
+                orchestrator:
+                    build: ./orchestrator
+                    ports:
+                    - "7860:7860"
+                    environment:
+                    - HF_TOKEN=${HF_TOKEN}
+                    - RETRIEVER=http://retriever:7861
+                    - GENERATOR=http://generator:7862
+                    - INGESTOR=http://ingestor:7863
+                    depends_on:
+                    - retriever
+                    - generator
+                    - ingestor
+
+                retriever:
+                    build: ./retriever
+                    ports:
+                    - "7861:7861"
+                    environment:
+                    - QDRANT_API_KEY=${QDRANT_API_KEY}
+
+                generator:
+                    build: ./generator
+                    ports:
+                    - "7862:7862"
+                    environment:
+                    - HF_TOKEN=${HF_TOKEN}
+
+                ingestor:
+                    build: ./ingestor
+                    ports:
+                    - "7863:7863"
+                ```
+                ## API Reference
+
+                ### Endpoints
+
+                #### Health Check
+                ```
+                GET /health
+                ```
+                Returns service health status.
+
+                **Response:**
+                ```json
+                {
+                "status": "healthy"
+                }
+                ```
+
+                #### Root Information
+                ```
+                GET /
+                ```
+                Returns API metadata and available endpoints.
+
+                #### Text Query (Streaming)
+                ```
+                POST /chatfed-ui-stream/stream
+                Content-Type: application/json
+                ```
+
+                **Request Body:**
+                ```json
+                {
+                "input": {
+                    "text": "What are EUDR requirements?"
+                }
+                }
+                ```
+
+                **Response:** Server-Sent Events stream
+                ```
+                event: data
+                data: "The EUDR requires..."
+
+                event: sources
+                data: {"sources": [...]}
+
+                event: end
+                data: ""
+                ```
+                #### File Upload Query (Streaming)
+                ```
+                POST /chatfed-with-file-stream/stream
+                Content-Type: application/json
+                ```
+
+                **Request Body:**
+                ```json
+                {
+                "input": {
+                    "text": "Analyze this GeoJSON",
+                    "files": [
                     {
-                    "input": {
-                        "text": "What are EUDR requirements?"
+                        "name": "boundaries.geojson",
+                        "type": "base64",
+                        "content": "base64_encoded_content"
                     }
-                    }
-                    ```
-
-                    **Response:** Server-Sent Events stream
-                    ```
-                    event: data
-                    data: "The EUDR requires..."
-
-                    event: sources
-                    data: {"sources": [...]}
-
-                    event: end
-                    data: ""
-                    ```
-
-                    #### File Upload Query (Streaming)
-                    ```
-                    POST /chatfed-with-file-stream/stream
-                    Content-Type: application/json
-                    ```
+                    ]
+                }
+                }
+                ```
 
-                    **Request Body:**
-                    ```json
-                    {
-                    "input": {
-                        "text": "Analyze this GeoJSON",
-                        "files": [
-                        {
-                            "name": "boundaries.geojson",
-                            "type": "base64",
-                            "content": "base64_encoded_content"
-                        }
-                        ]
-                    }
-                    }
-                    ```
+                #### Clear Cache
+                ```
+                POST /clear-cache
+                ```
+                Clears the direct output file cache.
 
-                    #### Clear Cache
-                    ```
-                    POST /clear-cache
-                    ```
-                    Clears the direct output file cache.
+                **Response:**
+                ```json
+                {
+                "status": "cache cleared"
+                }
+                ```
 
-                    **Response:**
-                    ```json
-                    {
-                    "status": "cache cleared"
-                    }
-                    ```
+                ### Gradio Interface
 
-                    ### Gradio Interface
+                #### Interactive Query
 
-                    #### Interactive Query
+                Gradio's default API endpoint for UI interactions. If running on huggingface spaces, access via: https://[ORG_NAME]-[SPACE_NAME].hf.space/gradio/
+                ## Troubleshooting
 
-                    Gradio's default API endpoint for UI interactions. If running on huggingface spaces, access via: https://[ORG_NAME]-[SPACE_NAME].hf.space/gradio/
+                ### Common Issues
 
+                #### 1. File Upload Fails
 
-                    ## Troubleshooting
+                **Symptoms:** "Error reading file" or "Failed to decode uploaded file"
 
-                    ### Common Issues
+                **Solutions:**
+                - Verify file is properly base64 encoded
+                - Check file size limits (default: varies by deployment)
+                - Ensure MIME type is in `multimodalAcceptedMimetypes`
 
-                    #### 1. File Upload Fails
+                #### 2. Slow Responses
 
-                    **Symptoms:** "Error reading file" or "Failed to decode uploaded file"
+                **Symptoms:** Long wait times for responses
 
-                    **Solutions:**
-                    - Verify file is properly base64 encoded
-                    - Check file size limits (default: varies by deployment)
-                    - Ensure MIME type is in `multimodalAcceptedMimetypes`
+                **Solutions:**
+                - Check network latency to external services
+                - Verify `MAX_CONTEXT_CHARS` isn't too high
+                - Consider enabling `DIRECT_OUTPUT` for suitable file types
+                - Check logs for retrieval/generation bottlenecks
 
-                    #### 2. Slow Responses
+                #### 3. Cache Not Clearing
 
-                    **Symptoms:** Long wait times for responses
+                **Symptoms:** Same file shows cached results when it shouldn't
 
-                    **Solutions:**
-                    - Check network latency to external services
-                    - Verify `MAX_CONTEXT_CHARS` isn't too high
-                    - Consider enabling `DIRECT_OUTPUT` for suitable file types
-                    - Check logs for retrieval/generation bottlenecks
+                **Solutions:**
+                - Call `/clear-cache` endpoint
+                - Restart the service (clears in-memory cache)
+                - Check if `DIRECT_OUTPUT=True` in config
 
-                    #### 3. Cache Not Clearing
+                #### 4. Service Connection Errors
 
-                    **Symptoms:** Same file shows cached results when it shouldn't
+                **Symptoms:** "Connection refused" or timeout errors
 
-                    **Solutions:**
-                    - Call `/clear-cache` endpoint
-                    - Restart the service (clears in-memory cache)
-                    - Check if `DIRECT_OUTPUT=True` in config
+                **Solutions:**
+                - Verify all service URLs in `params.cfg` are accessible
+                - Check HF_TOKEN is valid and has access to private spaces (*NOTE - THE ORCHESTRATOR CURRENTLY MUST BE PUBLIC*)
+                - Test each service independently with health checks
+                - Review firewall/network policies
 
-                    #### 4. Service Connection Errors
 
-                    **Symptoms:** "Connection refused" or timeout errors
+                ### Version History
 
-                    **Solutions:**
-                    - Verify all service URLs in `params.cfg` are accessible
-                    - Check HF_TOKEN is valid and has access to private spaces (*NOTE - THE ORCHESTRATOR CURRENTLY MUST BE PUBLIC*)
-                    - Test each service independently with health checks
-                    - Review firewall/network policies
+                - **v1.0.0**: Initial release with LangGraph orchestration
+                - Current implementation supports streaming, caching, and dual-mode processing
 
+                ---
 
-                    ### Version History
+                **Documentation Last Updated:** 2025-10-01  
+                **Compatible With:** Python 3.10+, LangGraph 0.2+, FastAPI 0.100+
 
-                    - **v1.0.0**: Initial release with LangGraph orchestration
-                    - Current implementation supports streaming, caching, and dual-mode processing
 
-                    ---
 
-                    **Documentation Last Updated:** 2025-10-01  
-                    **Compatible With:** Python 3.10+, LangGraph 0.2+, FastAPI 0.100+
-                    """
+            """

retriever.py

@@ -1,4 +1,4 @@
-retriverText = """ This mciroservice integrates with the vector database to retrieve semantically relevant documents,\
+retriverText = """ This microservice integrates with the vector database to retrieve semantically relevant documents,\
                         with optional reranking for precision, ready for seamless use in ChaBo RAG workflows. 
 
                         # Retriever and Reranker Microservice on Hugging Face Spaces 
@@ -50,8 +50,9 @@ retriverText = """ This mciroservice integrates with the vector database to retr
 
                         ```python
                         from gradio_client import Client
-
-                        client = Client("https://giz-chatfed-retriever0-3.hf.space/")
+                        # Replace with your actual Space URL (e.g., https://your-username-retriever_space.hf.space)
+                        retriever_url  = "https://giz-chatfed-retriever0-3.hf.space/"
+                        client = Client(retriever_url)
                         result = client.predict(
                                 query="What is Circular Economy",
                                 collection_name="Humboldt",

vectorDB.py

@@ -9,7 +9,7 @@ vectordbText = """
                     [ChaBo_QdrantServer](https://huggingface.co/spaces/GIZ/chatfed_QdrantServer/blob/main/README.md) Space hosts \
                     a Qdrant vector database instance. This is just a Infrastructural component and doesnt\
                     not serve any user application through its User Interface. However the admin task can be performed by\
-                     accessing "<embedded space url>/dashboard" Ex:https://giz-chatfed-qdrantserver.hf.space/dashboard \
+                    accessing "<embedded space url>/dashboard" Ex:https://giz-chatfed-qdrantserver.hf.space/dashboard \
                     which is passsword protected.
 
                     **Persistence:** Data is stored persistently in the `/data/qdrant_data` directory due to enabled persistent storage.
@@ -21,7 +21,7 @@ vectordbText = """
                     ```python
                     from qdrant_client import QdrantClient
 
-                    # Replace with your actual Space URL (e.g., [https://your-username-qdrant-server.hf.space](https://your-username-qdrant-server.hf.space))
+                    # Replace with your actual Space URL (e.g., https://your-username-qdrant-server.hf.space)
                     QDRANT_HOST = "giz-chatfed-qdrantserver.hf.space"
                     client = QdrantClient(
                         host = QDRANT_HOST,
@@ -30,6 +30,6 @@ vectordbText = """
                         api_key = <QDRANT_API_KEY>,)
                     ```
 
-                    API Documentation: https://api.qdrant.tech/api-reference
+                    **API Documentation**: https://api.qdrant.tech/api-reference
 
                     """