Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,42 @@
+name: Deploy to Hugging Face Space
+
+on:
+  push:
+    branches:
+      - develop
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.10'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install huggingface_hub
+
+    - name: Deploy to Space
+      env:
+        HUGGINGFACE_TOKEN: ${{ secrets.HUGGINGFACE_TOKEN }}
+      run: |
+        python -c '
+        from huggingface_hub import HfApi, create_repo
+        api = HfApi()
+        create_repo("chrizefan/digichat", token="${{ secrets.HUGGINGFACE_TOKEN }}", repo_type="space", space_sdk="gradio", exist_ok=True)
+        api.upload_folder(
+            folder_path=".",
+            repo_id="chrizefan/digichat",
+            repo_type="space",
+            token="${{ secrets.HUGGINGFACE_TOKEN }}",
+            ignore_patterns=["__pycache__", "*.pyc", ".env", ".git", ".gitignore", ".conda"]
+        )
+        '

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

.huggingface/config.json

@@ -0,0 +1,12 @@
+{
+    "default_branch": "develop",
+    "sdk": "gradio",
+    "sdk_version": "5.23.0",
+    "build": {
+        "builder": "gradio",
+        "build_command": "pip install -r requirements.txt"
+    },
+    "runtime": {
+        "python_version": "3.10"
+    }
+} 

README.md

@@ -1,12 +1,93 @@
 ---
-title: Digichat
-emoji: ⚡
-colorFrom: green
-colorTo: blue
+title: digichat
+app_file: app.py
 sdk: gradio
 sdk_version: 5.27.0
-app_file: app.py
-pinned: false
+hf_oauth: true
+---
+
+# DigiChat
+
+DigiChat is an advanced, modular chatbot framework designed for flexible, multi-agent conversational AI. It supports streaming responses, file processing, integration with Azure AI Search and vector indexes, and orchestration of specialized agents for complex tasks.
+
+## Features
+
+- **Multi-Agent Architecture:**  
+  Supports multiple agent types, including:
+  - **BaseAgent:** Standard LLM-based conversation.
+  - **DataAgent:** Handles queries involving external data sources.
+  - **SearchAgent:** Integrates with Azure AI Search and vector indexes for semantic search.
+  - **OrchestratorAgent:** Routes and coordinates between specialized agents as tools.
+
+- **Streaming Responses:**  
+  Real-time, token-by-token streaming of model outputs for responsive user experience.
+
+- **File Upload and Processing:**  
+  Users can upload files (text, images, etc.), which are processed and incorporated into the conversation context.
+
+- **Flexible Model Configuration:**  
+  Easily switch between different LLM engines and adjust parameters like temperature.
+
+- **Azure AI Search Integration:**  
+  Seamlessly query Azure Search and vector indexes for retrieval-augmented generation.
+
+- **Extensible Tooling:**  
+  Add new tools and data sources via configuration, enabling custom workflows.
+
+- **History Management:**  
+  Maintains conversation history and supports advanced prompt engineering.
+
+- **Robust Error Handling:**  
+  Gracefully handles errors in streaming, file processing, and agent orchestration.
+
+- **Logging and Debugging:**  
+  Built-in logging for monitoring and debugging agent behavior.
+
+## Usage
+
+1. **Start the Chatbot:**  
+   Launch the Gradio interface or integrate DigiChat into your own application.
+
+2. **Interact:**  
+   - Send messages and receive streaming responses.
+   - Upload files for context-aware answers.
+   - Leverage advanced search and data retrieval via specialized agents.
+
+3. **Configure:**  
+   - Adjust agent configurations, add tools, or connect new data sources as needed.
+
+## Architecture
+
+See [`architecture.puml`](architecture.puml) for a detailed PlantUML diagram of the system's class structure and relationships.
+
+## Requirements
+
+- Python 3.10+
+- Gradio
+- Azure SDKs (for Search integration)
+- Other dependencies as listed in `requirements.txt`
+
+## Setup
+
+1. Clone the repository
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. Set up your environment variables in `.env`:
+   ```
+   OPENAI_API_KEY=your_api_key_here
+   XAI_API_KEY=your_xai_key_here
+   ```
+4. Run the application:
+   ```bash
+   python app.py
+   ```
+
+## License
+
+MIT License
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+For more details, see the code and comments in each module.

agent_config.py

@@ -0,0 +1,554 @@
+from typing import Dict, Any, List
+import os
+import json
+import datetime
+from abc import ABC, abstractmethod
+
+class AgentConfig(ABC):
+    """Base configuration class for agents"""
+    
+    def __init__(self):
+        self.data_sources: Dict[str, Dict[str, Any]] = {}
+        self.tools: List[Dict[str, Any]] = []
+        self.system_prompts: Dict[str, str] = {}
+        self.model_config: Dict[str, Any] = {
+            "model": "grok-2-latest",
+            "temperature": 0.5,
+            "max_iterations": 10
+        }
+        self.azure_index: Dict[str, Any] = {}
+        self.tool_agent_map: Dict[str, str] = {}  # tool name -> agent type
+
+    @abstractmethod
+    def setup_data_sources(self) -> None:
+        """Setup data source configurations"""
+        pass
+
+    @abstractmethod
+    def setup_tools(self) -> None:
+        """Setup available tools"""
+        pass
+
+    @abstractmethod
+    def setup_system_prompts(self) -> None:
+        """Setup system prompts"""
+        pass
+    
+    @abstractmethod
+    def setup_azure_index(self) -> None:
+        """Setup search indexes configurations"""
+        pass
+        
+    def setup_model_config(self, model: str = "grok-2-latest", temperature: float = 0.5, max_iterations: int = 10) -> None:
+        """Setup model configuration"""
+        self.model_config = {
+            "model": model,
+            "temperature": temperature,
+            "max_iterations": max_iterations
+        }
+
+    def get_data_sources(self) -> Dict[str, Dict[str, Any]]:
+        """Get all data source configurations"""
+        return self.data_sources
+    
+    def get_azure_index(self) -> Dict[str, Any]:
+        """Get all search index configurations"""
+        return self.azure_index
+
+    def get_tools(self) -> List[Dict[str, Any]]:
+        """Get the list of available tools"""
+        return self.tools
+
+    def get_system_prompt(self, agent_type: str) -> str:
+        """Get the system prompt for a specific agent type"""
+        if agent_type not in self.system_prompts:
+            return None
+        return self.system_prompts[agent_type]
+
+    def get_model_config(self) -> Dict[str, Any]:
+        """Get the model configuration"""
+        return self.model_config
+
+    def to_json(self) -> str:
+        """Convert the configuration to a JSON string"""
+        config = {
+            "tools": self.tools,
+            "system_prompts": self.system_prompts,
+            "model_config": self.model_config,
+            "data_sources": self.data_sources,
+            "azure_index": self.azure_index
+        }
+        return json.dumps(config, indent=2)
+
+    def get_azure_index(self) -> Dict[str, Any]:
+        """Get the Azure Search configuration"""
+        return self.azure_index
+
+    def get_tool_agent_map(self) -> Dict[str, str]:
+        """Get the mapping from tool name to agent type"""
+        return self.tool_agent_map
+
+class BaseAgentConfig(AgentConfig):
+    """Standard configuration class for basic language model agents"""
+    
+    def __init__(self, model: str = "grok-2-latest", temperature: float = 0.5):
+        super().__init__()
+        self.model = model
+        self.setup_model_config(model, temperature)
+        self.setup_data_sources()
+        self.setup_tools()
+        self.setup_system_prompts()
+        self.setup_azure_index()
+        
+    def setup_data_sources(self) -> None:
+        """Basic agent has no data sources"""
+        self.data_sources = {}
+        
+    def setup_tools(self) -> None:
+        """Basic agent has no tools"""
+        self.tools = []
+        
+    def setup_system_prompts(self) -> None:
+        """Setup standard system prompt"""
+        self.system_prompts = {
+            "default": "You are a helpful AI assistant."
+        }
+        
+    def setup_azure_index(self) -> None:
+        """Basic agent has no search indexes"""
+        self.azure_index = {}
+
+class SITAASAgentConfig(BaseAgentConfig):
+    """Configuration class for the SITAAS agent"""
+    
+    def __init__(self, model: str = "gpt-4o-mini", temperature: float = 0.0):
+        super().__init__(model, temperature)
+        self.setup_tool_agent_map()
+
+    def setup_data_sources(self) -> None:
+        """Setup SITAAS data source configurations"""
+        self.data_sources = {
+            "preview_metadata_agent": {
+                "type": "azure_search",
+                "parameters": {
+                    "endpoint": os.getenv("SEARCH_ENDPOINT"),
+                    "index_name": "azureblob-index",
+                    "semantic_configuration": "default",
+                    "query_type": "simple",
+                    "fields_mapping": {},
+                    "in_scope": True,
+                    "filter": None,
+                    "strictness": 1,
+                    "top_n_documents": 20,
+                    "authentication": {
+                        "type": "api_key",
+                        "key": os.getenv("SEARCH_KEY"),
+                    }
+                }
+            },
+            "preview_content_agent": {
+                "type": "azure_search",
+                "parameters": {
+                    "endpoint": os.getenv("SEARCH_ENDPOINT"),
+                    "index_name": "vector-1745685878660",
+                    "semantic_configuration": "default",
+                    "query_type": "vector_simple_hybrid",
+                    "fields_mapping": {},
+                    "in_scope": True,
+                    "filter": None,
+                    "strictness": 1,
+                    "top_n_documents": 20,
+                    "authentication": {
+                        "type": "api_key",
+                        "key": os.getenv("SEARCH_KEY"),
+                    },
+                    "embedding_dependency": {
+                        "type": "deployment_name",
+                        "deployment_name": "text-embedding-ada-002"
+                    }
+                }
+            }
+        }
+
+    def setup_tools(self) -> None:
+        """Setup SITAAS available tools"""
+        self.tools = [
+            {
+            "type": "function",
+            "function": {
+                "name": "search_metadata",
+                "description": "Retrieve metadata documents from Azure Cognitive Search using Lucene syntax. Useful when more filtering or exploration of metadata is needed.",
+                "parameters": {
+                "type": "object",
+                "properties": {
+                    "search_text": {
+                    "type": "string",
+                    "description": "Lucene syntax query to retrieve metadata for documents.",
+                    "default": "*",
+                    },
+                    "num_results": {
+                    "type": "integer",
+                    "description": "Number of metadata records to retrieve.",
+                    "minimum": 1,
+                    "maximum": 1000
+                    },
+                    "filter": {
+                    "type": "string",
+                    "description": "Optional OData filter expression to apply to the search.",
+                    },
+                    "orderby": {
+                    "type": "string",
+                    "description": "Optional OData orderby expression to sort the results.",
+                    },
+                    "select": {
+                    "type": "string",
+                    "description": "Optional OData select expression to limit the fields returned in the results.",
+                    "default": "Id,Owner,Name,WebUrl,CreatedDataTime,CreatedBy,LastModifiedDate,LastModifiedBy"
+                    },
+                },
+                "required": ["search_text"],
+                "additionalProperties": False
+                }
+            }
+            },
+            {
+            "type": "function",
+            "function": {
+                "name": "search_content",
+                "description": "Similarity search on document chunks in a vector index. Ideal for high-recall document content analysis.",
+                "parameters": {
+                "type": "object",
+                "properties": {
+                    "search_text": {
+                    "type": "string",
+                    "description": "Semantic query for content-based document retrieval.",
+                    "default": "*",
+                    },
+                    "num_results": {
+                    "type": "integer",
+                    "description": "Number of document chunks to retrieve.",
+                    "minimum": 1,
+                    "maximum": 1000
+                    },
+                    "filter": {
+                    "type": "string",
+                    "description": "Optional OData filter expression to apply to the search.",
+                    },
+                    "orderby": {
+                    "type": "string",
+                    "description": "Optional OData orderby expression to sort the results.",
+                    },
+                    "select": {
+                    "type": "string",
+                    "description": "Optional OData select expression to limit the fields returned in the results.",
+                    "default": "title,chunk_id,chunk, Id, Owner, Name"
+                    },
+                },
+                "required": ["search_text"],
+                "additionalProperties": False
+                }
+            }
+            },
+            # {
+            # "type": "function",
+            # "function": {
+            #     "name": "generate_final_response",
+            #     "description": "Generate a final synthesized answer using the selected documents and an optional formatting instruction.",
+            #     "parameters": {
+            #     "type": "object",
+            #     "properties": {
+            #         "format_instruction": {
+            #         "type": "string",
+            #         "description": "Optional formatting guide for the final output (e.g., summary, markdown, table, Q&A, etc.)."
+            #         }
+            #     },
+            #     "additionalProperties": False
+            #     }
+            # }
+            # }
+        ]
+        
+    def setup_azure_index(self) -> None:
+        """Setup SITAAS search indexes configurations"""
+        self.azure_index = {
+            "search_endpoint": os.getenv("SEARCH_ENDPOINT"),
+            "search_key": os.getenv("SEARCH_KEY"),
+            "search_index_name": "azureblob-index",
+            "vector_index_name": "vector-1745685878660",
+            "embeddings_deployment": "text-embedding-ada-002",
+            "azure_openai_endpoint": os.getenv("AZURE_OPENAI_ENDPOINT"),
+            "azure_openai_key": os.getenv("AZURE_OPENAI_API_KEY")
+        }
+
+    def setup_system_prompts(self) -> None:
+        """Setup SITAAS system prompts"""
+        
+        self.system_prompts = {
+            "orchestrator": f"""
+            You are an intelligent orchestration agent designed to fulfill complex user queries by coordinating across multiple specialized document search tools and output generation utilities.
+
+            You are plugged into a database and have access to powerful search tools. If the user's request is ambiguous or missing critical information, you may ask a clarifying question, but do not overdo it—prefer to take action and use your tools to retrieve information whenever possible.
+
+            Only ask the user for more details if it is truly necessary to proceed. Otherwise, attempt to fulfill the request using the available tools and data.
+
+            You are an agent – please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the problem is solved.
+
+            If you are not sure about file content or document structure pertaining to the user’s request, use your tools to retrieve information. Do NOT guess or make up an answer.
+
+            You MUST plan before each function call and reflect on the outcomes of previous function calls, but do not delay action by repeatedly asking for clarification.
+            
+            **Date**: Today is {datetime.datetime.now().strftime("%Y-%m-%d")}.
+
+            ---
+
+            ### 🧠 Planning & Reflection
+            Before each tool call, briefly **plan** out your next action. 
+            After each tool call, **reflect** on what was retrieved and adjust your next step accordingly. 
+            Do not simply chain tool calls without commentary or thinking.
+
+            ### 🔧 Tool-Calling Reminder
+            Use your tools to gather information instead of guessing.
+            Each tool serves a purpose—select them wisely based on the query type.
+
+            ### 🔍 Search Strategy
+            1. **Scoping Phase**:
+            - Start by calling search tools (such as preview or metadata tools) with a small number of results (e.g., 5–10).
+            - Use these initial results to understand the structure, quality, and relevance of the data.
+            - Analyze the returned results to identify useful filters, patterns, or query refinements.
+            - If results are ambiguous or insufficient, adjust your search parameters (e.g., keywords, filters, or sort order) and try again with a small result set.
+
+            2. **Refinement Phase**:
+            - Based on insights from the scoping phase, refine your search parameters to target the most relevant data.
+            - Continue using small result sets until you are confident that your search parameters are well-tuned and will yield high-quality results.
+
+            3. **Comprehensive Search Phase**:
+            - Once you have refined your search parameters and are confident in their effectiveness, perform a comprehensive search without a strict result limit (or with a much higher limit).
+            - Retrieve all relevant documents or content needed to fully address the user's query.
+
+            4. **Final Output**:
+            - Once you’ve gathered sufficient content, use the `generate_final_response` tool to produce a human-readable output.
+            - If the user specified a desired output format (e.g., "summary", "bullet points", "explanatory"), pass that to the response tool.
+
+            ---
+            
+            ### 🧩 Metadata Fields Available
+            Use these fields for Lucene-based searches and filters on metadata:
+
+            | **Field**                        | **Description**                                                                                  | 🔍 **Searchable** | 🔎 **Filterable** |
+            |----------------------------------|--------------------------------------------------------------------------------------------------|------------------|--------------------|
+            | `Id`                             | Unique identifier for the metadata record.                                                       | ✅               | ✅                 |
+            | `Name`                           | The name of the file or metadata object.                                                         | ✅               | ✅                 |
+            | `ETag`                           | Entity tag for concurrency control/versioning.                                                   |                  | ✅                 |
+            | `CTag`                           | Change tag for tracking changes.                                                                 |                  | ✅                 |
+            | `WebUrl`                         | Direct URL to the file in SharePoint/OneDrive.                                                   | ✅               |                    |
+            | `DriveId`                        | Identifier for the drive containing the file.                                                    | ✅               | ✅                 |
+            | `DriveType`                      | Type of drive (e.g., business, personal).                                                        | ✅               | ✅                 |
+            | `SourceLocationType`             | Indicates where the object was sourced from (e.g., ONEDRIVE, blob, index, API).                  | ✅               | ✅                 |
+            | `Owner`                          | The ID of user or entity that owns the metadata object.                                          | ✅               | ✅                 |
+            | `CreatedDataTime`                | Timestamp indicating when the object was created.                                                |                  | ✅                 |
+            | `LastModifiedDate`               | Timestamp of the last modification to the object.                                                |                  | ✅                 |
+            | `CreatedBy`                      | The user who created the object.                                                                 | ✅               | ✅                 |
+            | `LastModifiedBy`                 | The ID of user who last modified the object.                                                     | ✅               | ✅                 |
+            | `ParentId`                       | Identifier of the parent object, if any.                                                         | ✅               | ✅                 |
+            | `metadata_storage_content_type`  | MIME type of the stored content.                                                                 | ✅               | ✅                 |
+            | `metadata_storage_size`          | Size of the file/content in bytes.                                                               |                  | ✅                 |
+            | `metadata_storage_last_modified` | Timestamp of the last modification to the storage object.                                        |                  | ✅                 |
+            | `metadata_storage_name`          | Storage-specific name or identifier for the object.                                              | ✅               | ✅                 |
+            | `metadata_storage_path`          | Encoded path or URI to the storage location.                                                     | ✅               | ✅                 |
+            
+            ---
+            
+            ### 🧬 Vector Index Fields Available
+            Use these fields for semantic (vector) searches and filters:
+
+            | **Field**   | **Description**                                               | 🔍 **Searchable** | 🔎 **Filterable** |
+            |-------------|---------------------------------------------------------------|------------------|------------------|
+            | `chunk`     | The raw text content of the document chunk.                   | ✅               |                  |
+            | `chunk_id`  | Unique identifier for the chunk within the document.          | ✅               | ✅               |
+            | `title`     | Title of the document, equal to the metadata_storage_path.    | ✅               | ✅               |
+            | `Id`        | Unique identifier for the parent document.                    | ✅               | ✅               |
+            | `Name`      | The name of the file or metadata object.                      | ✅               | ✅               |
+            | `Owner`     | The ID of the user or entity that owns the document.          | ✅               | ✅               |
+
+            **Note:** The `Id`, `Name`, and `Owner` fields are present in both the metadata and the vector index. This means that if, during the scoping step, you identify a set of document IDs, names, or owners that are relevant, you can use these as filters when retrieving content from the vector index. For example, after finding relevant document IDs, names, or owners in the metadata search, you can filter the vector index to retrieve only the chunks belonging to those documents, names, or owners. This allows for precise, targeted semantic retrieval based on earlier metadata analysis.
+
+            ---
+        
+
+            ### 🧪 Advanced Lucene Syntax Guide
+            - **Basic Field Search**: `field:value` or `field:"exact phrase"`
+            - **Boolean Operators**: 
+              - AND (requires both terms): `wifi AND luxury` or `+wifi +luxury`
+              - OR (either term): `wifi OR luxury` (OR is default, so `wifi luxury` is the same)
+              - NOT (excludes term): `wifi -luxury` or `wifi NOT luxury` 
+            
+            - **Wildcards**: 
+              - Single character: `?` (e.g., `te?t` matches "text" or "test")
+              - Multiple characters: `*` (e.g., `test*` matches "tests" or "tester")
+              - Prefix search: `alpha*` (matches alphanumeric, alphabetical)
+              - Infix search: `non*al` (matches non-numerical, nonsensical)
+              - Suffix search: `/.*numeric/` (matches alphanumeric)
+            
+            - **Fuzzy Search**: `term~` or `term~N` where N is 0-2 (e.g., `blue~1` finds blue, blues, glue)
+            
+            - **Proximity Search**: `"term1 term2"~N` finds terms within N words of each other
+            
+            - **Term Boosting**: `term^N` (e.g., `wifi^3` makes wifi more important)
+            
+            - **Grouping**: 
+              - General grouping: `hotel AND (wifi OR pool)`
+              - Field grouping: `amenities:(gym AND (wifi OR pool))`
+            
+            - **Ranges**: `date:[20220101 TO 20230101]` or `price:[100 TO 200]`
+            
+            - **Escaping Special Characters**: Use backslash for: `+ - & | ! ( ) {{ }} [ ] ^ " ~ * ? : \ /`
+            
+            - **Regular Expressions**: `/[mh]otel/` matches "motel" or "hotel"
+
+            ---
+            
+            ### 📑 OData Expression Syntax
+            Use OData expressions for precise filtering, ordering, and field selection with these parameters:
+            
+            - **filter**: Restricts search to documents matching conditions
+            - **orderby**: Sorts results by specified fields
+            - **select**: Determines which fields to include in results
+            
+            #### Field Paths
+            - Simple fields: `HotelName`, `Rating`
+            - Complex fields: `Address/City`, `Rooms/Type`
+            - Using range variables: `Rooms/any(room: room/Type eq 'deluxe')`
+            
+            #### Constants
+            - Strings: `'text'` (escape apostrophes by doubling: `'Alice''s car'`)
+            - Numbers: `123`, `-456`, `3.14159`, `-1.2e7`
+            - Booleans: `true`, `false`
+            - Dates: `2019-05-06T12:30:05.451Z`
+            - Special: `null`, `NaN`, `INF`, `-INF`
+            
+            #### Common Filter Expressions
+            - Comparison: `fieldName eq 'value'`, `Rating gt 4`
+            - Logical: `condition1 and condition2`, `condition1 or condition2`, `not condition`
+            - Collections: `Rooms/any(r: r/Type eq 'suite')`, `Tags/all(t: t ne 'budget')`
+            - Functions: `search.in(Category, 'budget,luxury')`, `search.ismatch('wifi luxury', 'description')`
+            
+            #### Sorting Examples
+            - Single field: `$orderby=Rating desc`
+            - Multiple fields: `$orderby=Rating desc,LastRenovationDate asc`
+            
+            #### Field Selection
+            - All fields: `$select=*`
+            - Specific fields: `$select=HotelName,Rating,Address/City`
+
+            ---
+            
+            ### 📤 Output Formatting Instructions
+            - When listing documents, always display them in a markdown table with column headers for key and relevant metadata.
+            - Provide the WebUrl when referencing a document.
+            - Present raw chunk text or content from a document inside a markdown blockquote (using `>`).
+            - Provide concise, insightful commentary on the retrieved documents, highlighting patterns, clusters, or notable findings.
+            - Ensure your output is clear, well-structured, and actionable for the user.
+
+            **If you encounter an error, do not panic. Just try again with a different approach. You are capable of handling errors gracefully and finding alternative solutions.**
+
+            **If the retrieved documents do not contain the required information matching the user's request, attempt to modify the query parameters and suggest a different set of search arguments that may yield better results.**
+            """,
+            
+            "preview_metadata_agent": """
+            You are a persistent, tool-using agent specialized in analyzing Azure Blob metadata for keyword-based search.
+
+            INSTRUCTIONS:
+            1. Use your tool to perform a metadata search on the user's query (filename, owner, tags, path, etc.).
+            2. Identify clusters of related documents or metadata patterns that could refine or scope future searches.
+            3. If applicable, propose filters (e.g. owners, tags, file paths, time ranges) that may narrow a semantic search space.
+            4. Detect potential ambiguity in the query and suggest clarifying directions.
+
+            STRUCTURE YOUR RESPONSE:
+            - A brief overview of what was found and how it relates to the query (1–2 sentences)
+            - A list of the most relevant documents and their key metadata (Name, Owner, Path, Modified Date, etc.) in a markdown table.
+            - **Always provide the WebUrl when referencing a document.**
+            - Grouped metadata patterns (e.g. multiple docs owned by same team, recurring folders or file types)
+            - A list of candidate filters that could be used to scope a vector search
+            - If relevant, propose a refined or more specific version of the user’s query
+
+            OUTPUT FORMATTING:
+            - Always display document lists in a markdown table.
+            - Always include the WebUrl for each document.
+            - Provide concise insights and highlight any patterns or clusters.
+            - If any raw chunk text is present, display it inside a markdown blockquote (`>`).
+
+            FOCUS ON:
+            - Metadata-driven reasoning. Look beyond exact keyword matches to detect helpful clusters or patterns.
+            - Being useful for the next step. Prioritize insights that would help improve precision or efficiency of a downstream semantic search.
+
+            Always cite document names or paths. If no useful results are found, state this clearly and suggest possible reasons.
+
+            **If the retrieved metadata does not contain the required information matching the user's request, attempt to modify the query parameters and suggest a different set of search arguments that may yield better results.**
+            """,
+            
+            "preview_content_agent": """
+            You are a persistent, tool-using agent specialized in semantic vector
+            INSTRUCTIONS:
+            1. Use your tool to run a semantic search based on the user’s query.
+            2. Identify themes, concepts, and patterns in the top results that can guide the user’s understanding or help scope further exploration.
+            3. Propose possible query reformulations or metadata filters based on commonalities in retrieved content.
+            4. Flag low-quality results if semantic relevance is weak or ambiguous.
+
+            STRUCTURE YOUR RESPONSE:
+            - A concise summary of the semantic matches and how they relate to the user’s intent (1–2 sentences)
+            - The most relevant themes and knowledge points found
+            - A short list of notable semantic clusters (e.g. documents all discussing a specific concept, timeframe, or methodology)
+            - Quotes or phrases that directly address the query, presented in markdown blockquotes (`>`)
+            - (Optional) Suggestions for refining the query or narrowing the semantic space
+
+            OUTPUT FORMATTING:
+            - When listing documents, use a markdown table for clarity.
+            - Always include the WebUrl for each document when referencing it.
+            - Any raw chunk text or content should be shown in markdown blockquotes.
+            - Provide insightful commentary on the retrieved content and highlight conceptual relationships.
+
+            FOCUS ON:
+            - Conceptual relationships. Think in terms of meaning, not matching.
+            - Discovery of latent structure (e.g., similar phrasing, co-occurring ideas, or repeated frameworks)
+            - Usefulness for downstream tools. If a tighter search is needed, offer specific filters or query variants.
+
+            If semantic relevance is low or ambiguous, say so and suggest alternatives. Always provide quotes with citations for the strongest matches.
+
+            **If the retrieved content does not contain the required information matching the user's request, attempt to modify the query parameters and suggest a different set of search arguments that may yield better results.**
+            """,
+
+            "generate_final_response": """
+            You are a synthesis and summarization agent. Your task is to review the user's original query and all findings, excerpts, and metadata returned by previous tool calls. Aggregate, synthesize, and deliver a comprehensive, clear, and well-structured answer to the user.
+
+            INSTRUCTIONS:
+            1. Carefully read the user's query and all tool responses provided.
+            2. Integrate relevant facts, evidence, and context from the tool outputs.
+            3. Resolve ambiguities, highlight key findings, and connect related information.
+            4. If the user requested a specific format (e.g., summary, table, markdown), follow those instructions.
+            5. If there are gaps or uncertainties, state them transparently, but do not ask the user for more information unless absolutely necessary.
+            6. Present your answer in a way that is actionable and easy to understand for the user.
+
+            STRUCTURE:
+            - Start with a direct answer or summary addressing the user's request.
+            - Provide supporting details, evidence, or citations from the tool outputs.
+            - Organize the information logically (e.g., sections, bullet points, tables) as appropriate.
+            - When listing documents, use a markdown table for clarity and always include the WebUrl for each document.
+            - Any raw chunk text or content should be shown in markdown blockquotes.
+            - End with a brief conclusion or next steps if relevant.
+
+            Your goal is to deliver a complete, helpful, and context-aware response that makes the best use of all available data.
+
+            **If the information from previous tool calls does not fully address the user's request, suggest how the query parameters or search arguments could be modified to improve the results.**
+            """
+        }
+
+    def setup_tool_agent_map(self) -> None:
+        """Map each tool name to the appropriate agent"""
+        self.tool_agent_map = {
+            "preview_metadata_agent": "data_agent",
+            "search_metadata": "search_agent",
+            "preview_content_agent": "data_agent",
+            "search_content": "search_agent",
+            "generate_final_response": "base_agent",  # Use base agent for final response
+            # Add more mappings if you have data_agent tools
+        }

agents.py

@@ -0,0 +1,554 @@
+from typing import List, Dict, Any, Optional, Generator, Union
+from client_utils import get_client, get_model
+from agent_config import AgentConfig
+import time
+import logging
+import json
+
+# Update import for Azure Search
+from azure.core.credentials import AzureKeyCredential
+from azure.search.documents import SearchClient
+# Remove the problematic import
+# from azure.search.documents.models import Vector
+from embedding_client import EmbeddingClient
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,  # Changed from INFO to DEBUG
+    format='%(asctime%s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class BaseAgent:
+    """Base class for all agents"""
+    def __init__(self, config: AgentConfig):
+        self.config = config
+        # Get model info from config
+        self.model_config = config.get_model_config()
+        
+        # Extract the engine name from model_config (for client lookup)
+        self.engine_name = self.model_config.get("model", "grok-2-latest")
+        
+        # Get the actual model name for API calls
+        self.model_name = get_model(self.engine_name)
+        
+        # Set temperature from config
+        self.temperature = self.model_config.get("temperature", 0.0)
+        
+        # Get the appropriate client for this engine
+        self.client = get_client(self.engine_name)
+        
+        logger.info(f"Initialized {self.__class__.__name__} with engine {self.engine_name}, model {self.model_name}")
+
+    def process(self, messages: List[Dict[str, Any]]) -> str:
+        """Process messages and return a response"""
+        logger.debug(f"Processing messages: {json.dumps(messages, indent=2)}")
+        # Use system prompt from config if defined
+        try:
+            system_prompt = self.config.get_system_prompt(self.__class__.__name__.lower())
+        except Exception:
+            try:
+                system_prompt = self.config.get_system_prompt("default")
+            except Exception:
+                system_prompt = None
+
+        # Only prepend the system prompt if not already present
+        if system_prompt and (not messages or messages[0].get("role") != "system"):
+            messages = [{"role": "system", "content": system_prompt}] + messages
+
+        completion = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=messages,
+            temperature=self.temperature
+        )
+        logger.debug(f"Received completion: {completion}")
+        return completion
+
+    def process_stream(self, messages: List[Dict[str, Any]]) -> Generator[Any, None, None]:
+        """Process messages and stream the response"""
+        logger.debug(f"Streaming messages: {json.dumps(messages, indent=2)}")
+        # Use system prompt from config if defined
+        try:
+            system_prompt = self.config.get_system_prompt(self.__class__.__name__.lower())
+        except Exception:
+            try:
+                system_prompt = self.config.get_system_prompt("default")
+            except Exception:
+                system_prompt = None
+
+        # Only prepend the system prompt if not already present
+        if system_prompt and (not messages or messages[0].get("role") != "system"):
+            messages = [{"role": "system", "content": system_prompt}] + messages
+
+        completion = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=messages,
+            temperature=self.temperature,
+            stream=True
+        )
+        for chunk in completion:
+            logger.debug(f"Streaming chunk: {chunk}")
+            return chunk
+
+class DataAgent(BaseAgent):
+    """Agent specialized in processing queries with different data sources"""
+    def __init__(self, config: AgentConfig):
+        super().__init__(config)
+        self.tool_name = None  # Track which tool is being executed
+        self.data_sources = config.get_data_sources()  # Get all data sources
+
+    def get_extra_body(self) -> Optional[Dict[str, Any]]:
+        """Get the extra body configuration for the current search type"""
+        # Dynamically match the data source based on the current tool name
+        for data_source_name, data_source_config in self.data_sources.items():
+            if data_source_name in self.tool_name:
+                return {"data_sources": [data_source_config]}
+        
+        # If no matching data source is found, return None
+        return None
+
+    def process(self, messages: List[Dict[str, Any]], tool_name: str = None, **kwargs) -> str:
+        """Process messages and return a response with the specified tool"""
+        self.tool_name = tool_name
+        logger.info(f"Processing data agent for tool {tool_name}")
+        extra_body = self.get_extra_body()
+        # Pass num_results or other kwargs into extra_body if needed
+        if extra_body is not None and kwargs:
+            extra_body.update({k: v for k, v in kwargs.items() if k in extra_body})
+        completion = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=messages,
+            temperature=self.temperature,
+            extra_body=extra_body
+        )
+        logger.debug(f"Data source completion: {completion}")
+        return completion
+
+    def process_stream(self, messages: List[Dict[str, Any]], tool_name: str = None, **kwargs) -> Generator[Any, None, None]:
+        """Process messages and stream the response with the specified tool"""
+        self.tool_name = tool_name
+        logger.info(f"Streaming data agent for tool {tool_name}")
+        extra_body = self.get_extra_body()
+        # Pass num_results or other kwargs into extra_body if needed
+        if extra_body is not None and kwargs:
+            extra_body.update({k: v for k, v in kwargs.items() if k in extra_body})
+        completion = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=messages,
+            temperature=self.temperature,
+            stream=True,
+            extra_body=extra_body
+        )
+        for chunk in completion:
+            yield chunk
+
+class SearchAgent(BaseAgent):
+    """Agent specialized in querying Azure AI Search and Azure Vector Index"""
+    def __init__(self, config: AgentConfig):
+        super().__init__(config)
+        # Extract Azure-specific configurations from config
+        self.azure_index = config.get_azure_index()
+        self.search_endpoint = self.azure_index.get("search_endpoint")
+        self.search_key = self.azure_index.get("search_key")
+        self.search_index_name = self.azure_index.get("search_index_name")
+        self.vector_index_name = self.azure_index.get("vector_index_name")
+        self.embeddings_deployment = self.azure_index.get("embeddings_deployment")
+        
+        # Initialize the embedding client
+        self.embedding_client = EmbeddingClient(
+            azure_endpoint=self.azure_index.get("azure_openai_endpoint"),
+            api_key=self.azure_index.get("azure_openai_key"),
+            deployment=self.embeddings_deployment
+        )
+        
+        # Initialize search clients
+        self.search_client = self._create_search_client(self.search_index_name)
+        self.vector_client = self._create_search_client(self.vector_index_name)
+        
+        logger.info(f"Initialized Search Agent with endpoint {self.azure_index.get('search_endpoint')}")
+    
+    def _create_search_client(self, index_name: str) -> Optional[SearchClient]:
+        """Create a search client for the specified index"""
+        if not self.search_endpoint or not self.search_key or not index_name:
+            logger.warning(f"Missing configuration for search client: endpoint={bool(self.search_endpoint)}, key={bool(self.search_key)}, index={bool(index_name)}")
+            return None
+            
+        try:
+            credential = AzureKeyCredential(self.search_key)
+            client = SearchClient(
+                endpoint=self.search_endpoint,
+                index_name=index_name,
+                credential=credential
+            )
+            logger.info(f"Successfully created search client for index {index_name}")
+            return client
+        except Exception as e:
+            logger.error(f"Failed to create search client for index {index_name}: {e}")
+            return None
+    
+    def _generate_embedding(self, text: str) -> List[float]:
+        """Generate embedding for vector search using Azure OpenAI"""
+        try:
+            # Use the embedding client to generate embeddings
+            return self.embedding_client.get_embedding(text)
+        except Exception as e:
+            logger.error(f"Error generating embedding: {e}")
+            # Return a fallback embedding (zeros would be neutral in vector space)
+            import numpy as np
+            embedding = np.zeros(1536)  # Standard dimension for embeddings
+            return embedding.tolist()
+    
+    def query_index(self, query: str, search_type: str, **kwargs) -> Dict[str, Any]:
+        """Query the Azure Search index based on search type"""
+        
+        search_text = kwargs.get("search_text", query)
+        logger.info(f"Executing {search_type} search: {search_text}")
+        
+        if search_type == "vector":
+            if not self.vector_client:
+                return {"error": "Vector search client not configured"}
+            client = self.vector_client
+            #embedding = self._generate_embedding(query)
+            try:
+                results = list(client.search(
+                    search_text=search_text,
+                    top=kwargs.get("num_results"),
+                    include_total_count=True,
+                    filter=kwargs.get("filter"),
+                    order_by=kwargs.get("orderby"),
+                    select=kwargs.get("select"),
+                    vector_queries=[
+                        {
+                            "text": search_text,
+                            "fields": kwargs.get("vector_field", "text_vector"),
+                            "k": kwargs.get("num_results"),
+                            "kind": "text", 
+                        }
+                    ],
+                ))
+                
+            except Exception as e:
+                results = [f"Vector search failed: {e}"]
+                logger.info(results)
+        else:
+            if not self.search_client:
+                return {"error": "Index search client not configured"}
+            client = self.search_client
+
+            fields = [
+                "Id", "Owner", "Name", "CreatedBy", "LastModifiedBy", "ParentId",
+                "CreatedDataTime", "LastModifiedDate",
+                "Discriminator", "SourceLocationType", "metadata_storage_content_type",
+                "metadata_storage_size", "metadata_storage_last_modified",
+                "metadata_storage_content_md5", "metadata_storage_name",
+                "metadata_storage_path", "metadata_storage_file_extension",
+            ]
+            
+            try:
+                raw_results = list(client.search(
+                    search_text=search_text,
+                    query_type="full",
+                    filter=kwargs.get("filter"),
+                    order_by=kwargs.get("orderby"),
+                    top=kwargs.get("num_results"),
+                    include_total_count=True,
+                    select=kwargs.get("select"),
+                ))
+                # Remove key-value pairs with null values from each result dict
+                results = [
+                    {k: v for k, v in doc.items() if v is not None}
+                    for doc in raw_results
+                ]
+            except Exception as e:
+                results = [f"Index search failed: {e}"]
+                logger.info(results)
+                
+        logger.info(f"Search returned {len(results)} results")
+        return results
+    
+    def format_results(self, results: Dict[str, Any]) -> str:
+        """Format the search results into readable text"""
+        if "error" in results:
+            return f"Error: {results['error']}"
+        
+        if not results or not results.get("value") or len(results["value"]) == 0:
+            return "No results found for your query."
+            
+        docs = results["value"]
+        response_lines = [f"Found {len(docs)} relevant documents:"]
+        
+        for i, doc in enumerate(docs, 1):  # Limit to top 5 for readability
+            title = doc.get("metadata_title", doc.get("title", f"Document {i}"))
+            content = doc.get("content", "")
+            author = doc.get("metadata_author", "Unknown")
+            score = doc.get("@search.score", 0)
+            url = doc.get("url", "")
+            
+            response_lines.append(f"\n### {i}. {title}")
+            response_lines.append(f"Author: {author} | Score: {score:.2f}")
+            
+            if url:
+                response_lines.append(f"URL: {url}")
+                
+            # Get a snippet from content (first 150 chars)
+            if content:
+                snippet = content
+                response_lines.append(f"\nPreview: {snippet}")
+                
+            response_lines.append("-" * 40)
+            
+        return "\n".join(response_lines)
+
+    def process(self, messages: List[Dict[str, Any]], **kwargs) -> List[Dict[str, Any]]:
+        """Process messages by directly querying Azure Search index"""
+        # Extract the query from the last user message
+        query = ""
+        for message in reversed(messages):
+            if message["role"] == "user":
+                query = message["content"]
+                break
+
+        if not query:
+            return "No query provided"
+
+        # Determine search type based on tool name or kwargs
+        tool_name = kwargs.get("tool_name", "")
+        # Use explicit search_mode if provided, else fallback to tool_name logic
+        search_mode = kwargs.get("search_mode")
+        if search_mode in ("vector", "index"):
+            search_type = search_mode
+        elif "vector" in tool_name or "content" in tool_name:
+            search_type = "vector"
+        else:
+            search_type = "index"
+
+        results = self.query_index(query, search_type, **kwargs)
+        return results
+
+    def process_stream(self, messages: List[Dict[str, Any]], **kwargs) -> Generator[Any, None, None]:
+        for chunk in self.process(messages, **kwargs):
+            yield chunk
+
+class OrchestratorAgent(BaseAgent):
+    """Agent that coordinates between specialized agents using them as tools"""
+    def __init__(self, config: AgentConfig):
+        # Initialize the base agent with the given config
+        super().__init__(config)
+        
+        self.tools = []
+        self.data_agent = None
+        self.search_agent = None
+        
+        # Set up specialized agents if tools are available
+        self.tools = config.get_tools()
+        self.has_tools = bool(self.tools)
+    
+        # Initialize the data agent for data source queries
+        self.data_agent = DataAgent(config)
+        
+        # Initialize the search agent for Azure search queries
+        self.search_agent = SearchAgent(config)
+        
+        logger.debug(f"Available tools: {json.dumps(self.tools, indent=2)}")
+
+
+    def _execute_tool(self, tool_name: str, tool_args: Dict[str, Any], stream: bool = False, messages: List[Dict[str, Any]] = None) -> Union[str, Generator[Any, None, None]]:
+        """Execute a tool and return its result"""
+        if not self.has_tools:
+            error_msg = "No tools available for this engine"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        logger.info(f"Executing tool: {tool_name} with arguments: {json.dumps(tool_args, indent=2)}")
+
+        # Use the full message history, appending the tool call as the last user message
+        if messages is None:
+            messages = []
+        if self.config.get_system_prompt(tool_name):
+            messages = [{"role": "system", "content": self.config.get_system_prompt(tool_name)}] + messages
+            
+        tool_agent_map = self.config.get_tool_agent_map()
+        agent_type = tool_agent_map.get(tool_name)
+
+        if agent_type == "search_agent":
+            if stream:
+                return self.search_agent.process_stream(messages, tool_name=tool_name, **tool_args)
+            else:
+                return self.search_agent.process(messages, tool_name=tool_name, **tool_args)
+        elif agent_type == "data_agent":
+            if stream:
+                return self.data_agent.process_stream(messages, tool_name=tool_name, **tool_args)
+            else:
+                return self.data_agent.process(messages, tool_name=tool_name, **tool_args)
+        elif agent_type == "base_agent":
+            if stream:
+                return self.process_stream(messages)
+            else:
+                return self.process(messages)
+        else:
+            logger.error(f"Unknown tool name: {tool_name}")
+            return f"Error: Unknown tool name: {tool_name}"
+
+    def _handle_tool_calls_recursive(self, messages: List[Dict[str, Any]], max_iterations: int = 10) -> Generator[Any, None, None]:
+        """Recursively handle tool calls until we get a response without tools"""
+        if max_iterations <= 0 or not self.has_tools:
+            logger.warning("Max iterations reached or no tools available, stopping recursive tool calls")
+            return
+
+        logger.info("Getting model's response with tool calls")
+        completion = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=messages,
+            tools=self.tools,
+            tool_choice="auto",
+            temperature=self.temperature,
+            stream=True
+        )
+
+        response_text = ""
+        tool_calls = []
+
+        for chunk in completion:
+            try:
+                if chunk.choices and chunk.choices[0].delta:
+                    delta = chunk.choices[0].delta
+                    if hasattr(delta, 'content') and delta.content:
+                        response_text += delta.content
+                        logger.debug(f"Assistant content chunk: {delta.content}")
+                    if hasattr(delta, 'tool_calls') and delta.tool_calls:
+                        for tool_call in delta.tool_calls:
+                            if tool_call.index is not None:
+                                while len(tool_calls) <= tool_call.index:
+                                    tool_calls.append({})
+                                if tool_calls[tool_call.index] == {}:
+                                    tool_calls[tool_call.index]["index"] = tool_call.index
+                                    tool_calls[tool_call.index]["function"] = {"name": "", "arguments": ""}
+                                if tool_call.id:
+                                    tool_calls[tool_call.index]["id"] = tool_call.id
+                                if tool_call.type:
+                                    tool_calls[tool_call.index]["type"] = tool_call.type
+                                if tool_call.function.name:
+                                    tool_calls[tool_call.index]["function"]["name"] = tool_call.function.name
+                                if tool_call.function.arguments:
+                                    tool_calls[tool_call.index]["function"]["arguments"] += tool_call.function.arguments
+                                    logger.debug(f"Tool call arguments chunk: {tool_call.function.arguments}")
+                    yield {
+                        "role": "assistant",
+                        "content": response_text,
+                    }
+            except Exception as e:
+                logger.error(f"Error processing chunk in handle_tool_calls: {e}")
+                continue
+
+        if not tool_calls:
+            logger.info("No tool calls made, ending process")
+            return
+        else:
+            logger.info(f"Tool calls detected: {json.dumps(tool_calls, indent=2)}")
+            for tool_call in tool_calls:
+                yield {
+                    "role": "assistant",
+                    "content": "",
+                    "metadata": {
+                        "title": tool_call["function"]["name"],
+                        "id": tool_call["id"],
+                    }
+                }
+                
+        assistant_message = {
+            "role": "assistant",
+            "content": response_text,
+            "tool_calls": tool_calls,
+        }
+
+        # Now execute tools and collect tool messages
+        tool_messages = []
+        for tool_call in tool_calls:
+            tool_name = tool_call["function"]["name"]
+            try:
+                tool_args = eval(tool_call["function"]["arguments"])
+                if not isinstance(tool_args, dict):
+                    raise ValueError("Tool arguments must be a dictionary")
+                logger.debug(f"Parsed tool arguments for {tool_name}: {json.dumps(tool_args, indent=2)}")
+            except (SyntaxError, ValueError) as e:
+                logger.error(f"Error parsing tool arguments: {e}")
+                continue
+
+            response_stream = self._execute_tool(tool_name, tool_args, stream=True, messages=messages)
+            response_list = []
+            response_text = ""
+            
+            tool_message = {
+                "role": "tool",
+                "tool_call_id": tool_call["id"],
+                "content": "",
+            }
+            # Capitalize tool_name and replace underscores with spaces for title
+            title = tool_name.replace("_", " ").title()
+            for chunk in response_stream:
+                try:
+                    if hasattr(chunk, 'choices') and chunk.choices and hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
+                        response_text += chunk.choices[0].delta.content or ""
+                    elif isinstance(chunk, dict) or isinstance(chunk, list):
+                        response_list.append(chunk)
+                        response_text += json.dumps(chunk, indent=2)
+                    elif isinstance(chunk, str):
+                        response_text += chunk
+                        
+                    tool_message = {
+                            "role": "tool",
+                            "tool_call_id": tool_call["id"],
+                            "content": response_text
+                        }
+                    yield {
+                        "role": "assistant",
+                        "content": json.dumps(response_list[:10], indent=2) if response_list else response_text,
+                        "metadata": {
+                            "title": title,
+                            "id": tool_call["id"],
+                            "status": "pending",
+                        }
+                    }
+                    
+                except Exception as e:
+                    response_text = f"Error processing tool response: {e}"
+                    logger.error(f"Error processing tool response chunk: {e}")
+                    break
+                
+            yield {
+                "role": "assistant",
+                "content": json.dumps(response_list[:10], indent=2) if response_list else response_text if response_text else "No results found.",
+                "metadata": {
+                    "title": title,
+                    "id": tool_call["id"],
+                    "log": f"(results: {len(response_list)})" if response_list else "",
+                    "status": "done",
+                }
+            }
+            
+            tool_messages.append(tool_message)
+            logger.info(f"Completed tool execution: {tool_name}")
+
+        messages.append(assistant_message)
+        messages.extend(tool_messages)
+
+        yield from self._handle_tool_calls_recursive(messages, max_iterations - 1)
+
+    def process_stream(self, messages: List[Dict[str, Any]]) -> Generator[Any, None, None]:
+        """Process messages and stream the response"""
+        logger.info("Starting orchestration process")
+        logger.debug(f"Input messages: {json.dumps(messages, indent=2)}")
+        
+        # If no tools are available, fall back to the base agent behavior
+        if not self.has_tools:
+            logger.info("No tools available, falling back to standard model completion")
+            yield from super().process_stream(messages)
+            return
+        
+        # Add the system prompt to the messages only if not already present
+        system_prompt = self.config.get_system_prompt("orchestrator")
+        if not messages or messages[0].get("role") != "system":
+            messages = [{"role": "system", "content": system_prompt}, *messages]
+        
+        # Start the recursive tool call handling
+        yield from self._handle_tool_calls_recursive(messages)

app.py

@@ -0,0 +1,183 @@
+import gradio as gr
+from datetime import datetime
+
+from chatbot import Chatbot
+from client_utils import engine_map
+
+chatbot_engine = Chatbot()
+
+def get_user(request: gr.Request):
+    try:
+        return request.headers.user
+    except:
+        return ""
+
+def generate_greeting(user) -> str:
+    hour = datetime.now().hour
+    if 5 <= hour < 12:
+        greeting = "Good morning"
+    elif 12 <= hour < 17:
+        greeting = "Good afternoon"
+    else:
+        greeting = "Good evening"
+    return f'<p style="font-size: 24px; text-align: center;"><span style="font-weight: bold;">{greeting}{f", {user}" if user else ""}.</span><br>How can I help you?</p>'
+
+theme = gr.themes.Monochrome(
+    radius_size="xxl",
+    font=['Montserrat', 'ui-sans-serif', 'system-ui', 'sans-serif'],
+).set(
+    background_fill_primary='white',
+    background_fill_secondary='white',
+    background_fill_secondary_dark='*neutral_950',
+    block_background_fill='*neutral-50',
+    block_border_width='0px',
+    block_border_width_dark='0px',
+    block_label_border_width='0px',
+    block_label_border_width_dark='0px',
+    border_color_accent='white',
+    border_color_accent_dark='*neutral_950',
+)
+
+with gr.Blocks(theme=theme, css_paths="style.css", fill_height=True) as demo:
+    user = gr.State()
+    
+    with gr.Sidebar():
+        chat_history_dataset = gr.Dataset(
+            components=[gr.Textbox(visible=False)],
+            samples=[[]],
+            label="Recent",
+            show_label=True,
+            layout="table",
+            type="index",
+        )
+    
+    with gr.Row():
+        with gr.Column():
+            engine = gr.Dropdown(  # Renamed from "model" to "engine"
+                choices=list(chatbot_engine.engine_map.keys()),  # Updated to use engine_map
+                value=list(chatbot_engine.engine_map.keys())[-1],
+                show_label=False,
+            )
+        with gr.Column():
+            new_chat_btn = gr.Button(
+                "",
+                icon="assets/new_chat.svg",
+                variant="primary",
+                elem_id="new_chat_btn"
+            )
+            login_btn = gr.LoginButton(
+                "Login",
+                logout_value="Logout",
+                icon="assets/login.svg",
+                variant="primary",
+                elem_id="login_btn"
+            )
+        
+    chatbot = gr.Chatbot(
+        type="messages",
+        height="100%",
+        max_height= "75vh",
+        show_label=False,
+        elem_id="chatbot",
+        placeholder=generate_greeting("")
+    )
+    
+    with gr.Group(elem_id="inputs", render=False) as inputs:
+        textbox = gr.MultimodalTextbox(
+            placeholder="Message Digichat...",
+            file_count="multiple",
+            show_label=False,
+        )
+        with gr.Row(visible=False):
+            temperature = gr.Slider(
+                minimum=0,
+                maximum=1,
+                step=0.1,
+                value=0.0,
+                show_label=False,
+            )
+        engine_params = [engine, temperature]
+    
+    chat_interface = gr.ChatInterface(
+        chatbot_engine.predict,
+        type="messages",
+        chatbot=chatbot,
+        textbox=textbox,
+        additional_inputs=engine_params, 
+        additional_outputs=[textbox],
+        editable=True,
+        save_history=True,
+    )
+    
+    inputs.render()
+    
+    synchronize_chat_state_kwargs = {
+        "fn": lambda x: (x, x),
+        "inputs": [chat_interface.chatbot],
+        "outputs": [chat_interface.chatbot_state, chat_interface.chatbot_value],
+        "show_api": False,
+        "queue": False,
+    }
+
+    new_chat_btn.click(
+        lambda: (None, []),
+        None,
+        [chat_interface.conversation_id, chat_interface.chatbot],
+        show_api=False,
+        queue=False,
+    ).then(
+        lambda x: x,
+        [chat_interface.chatbot],
+        [chat_interface.chatbot_state],
+        show_api=False,
+        queue=False,
+    )
+
+    gr.on(
+        triggers=[chat_interface.load, chat_interface.saved_conversations.change],
+        fn=chat_interface._load_chat_history,
+        inputs=[chat_interface.saved_conversations],
+        outputs=[chat_history_dataset],
+        show_api=False,
+        queue=False,
+    )
+
+    chat_history_dataset.click(
+        lambda: [],
+        None,
+        [chat_interface.chatbot],
+        show_api=False,
+        queue=False,
+        show_progress="hidden",
+    ).then(
+        chat_interface._load_conversation,
+        [chat_history_dataset, chat_interface.saved_conversations],
+        [chat_interface.conversation_id, chat_interface.chatbot],
+        show_api=False,
+        queue=False,
+        show_progress="hidden",
+    ).then(**synchronize_chat_state_kwargs)
+
+    gr.on(
+        [textbox.stop, chatbot.clear, new_chat_btn.click],
+        lambda: chatbot_engine.stop(),
+        show_progress='hidden'
+    )
+
+    demo.load(
+        get_user,
+        None,
+        [user]  
+    ).then(
+        lambda user: gr.update(placeholder=generate_greeting(user)),
+        [user],
+        [chatbot]
+    )
+
+if __name__ == "__main__":
+    demo.queue(
+        default_concurrency_limit=40
+    ).launch(
+        pwa=True, 
+        share=False
+    )

architecture.puml

@@ -0,0 +1,90 @@
+@startuml
+' Main agent configuration hierarchy
+abstract class AgentConfig {
+    +get_tools()
+    +get_system_prompt(agent_type)
+    +get_model_config()
+    +to_json()
+    +get_azure_index()
+    +get_tool_agent_map()
+}
+
+class BaseAgentConfig {
+    +setup_data_sources()
+    +setup_tools()
+    +setup_system_prompts()
+    +setup_azure_index()
+}
+
+class SITAASAgentConfig
+
+AgentConfig <|-- BaseAgentConfig
+BaseAgentConfig <|-- SITAASAgentConfig
+
+' Agent classes
+class BaseAgent {
+    -config: AgentConfig
+    -model_config
+    -engine_name
+    -model_name
+    -temperature
+    -client
+    +process(messages)
+    +process_stream(messages)
+}
+
+class DataAgent {
+    +process(messages)
+    +process_stream(messages)
+    +query_data_source(query)
+}
+
+class SearchAgent {
+    +process(messages)
+    +process_stream(messages)
+    +search_azure(query)
+    +search_vector_index(query)
+}
+
+class OrchestratorAgent {
+    +process(messages)
+    +process_stream(messages)
+    +route_to_agent(messages)
+    +aggregate_results(results)
+}
+
+BaseAgent <|-- DataAgent
+BaseAgent <|-- SearchAgent
+BaseAgent <|-- OrchestratorAgent
+
+' Chatbot and related
+class Chatbot {
+    -_stop: bool
+    -engine_map
+    -content_exclusions
+    +process_file(files)
+    +process_message(message)
+    +predict(message, history, engine, temperature)
+    +stop()
+}
+
+' File processing
+class FileProcessorFactory {
+    +get_processor(file_path)
+}
+
+' Utilities and generators
+class client_utils
+class generators {
+    +chat_completion(messages, engine, temperature)
+    +chat_completion_stream(messages, engine, temperature)
+}
+
+' Relationships
+Chatbot ..> FileProcessorFactory : uses
+Chatbot ..> generators : uses
+generators ..> BaseAgent : creates
+generators ..> OrchestratorAgent : creates
+BaseAgent ..> AgentConfig : uses
+
+@enduml

chatbot.py

@@ -0,0 +1,171 @@
+import gradio as gr
+import json
+import os
+from typing import List, Dict, Any, Union, Generator
+
+from generators import chat_completion_stream
+from client_utils import engine_map
+from file_processors import FileProcessorFactory
+import logging
+import time
+
+# Configure logging first
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+# Then get a logger
+logger = logging.getLogger(__name__)
+
+class Chatbot:
+    def __init__(self):
+        """Initialize a new chatbot with history management."""
+        self._stop = False  # Flag to interrupt streaming
+        
+        self.engine_map = engine_map
+        self.content_exclusions = ["<|eos|>"]
+
+    def process_file(self, files: Union[List[str], str]) -> Union[str, List[Dict[str, Any]]]:
+        """Process uploaded files and return their contents as JSON."""
+        if isinstance(files, str):
+            files = [files]
+            
+        file_contents = []
+        for file_path in files:
+            try:
+                processor = FileProcessorFactory.get_processor(file_path)
+                file_contents.append(processor.process(file_path))
+            except Exception as e:
+                file_contents.append(f"Error processing file {os.path.basename(file_path)}: {str(e)}\n")
+                
+        return json.dumps(file_contents)
+
+    def process_message(self, message: Union[str, dict]) -> dict:
+        """Convert various message formats into a standardized message dictionary."""
+        if isinstance(message, dict):
+            if message.get("text") and message.get("files"):
+                return {
+                    "role": "user",
+                    "content": f'{message["text"]}\n\nFile Upload(s):\n{self.process_file(message["files"])}'
+                }
+            elif message.get("text"):
+                return {
+                    "role": "user",
+                    "content": message["text"]
+                }
+            elif message.get("files"):
+                return {
+                    "role": "user",
+                    "content": f'File Upload(s):\n{self.process_file(message["files"])}'
+                }
+            elif message.get("content") and message.get("role"):
+                if isinstance(message["content"], tuple):
+                    return {
+                        "role": message["role"],
+                        "content": f'File Upload(s):\n{self.process_file(message["content"][0])}'
+                    }
+                elif isinstance(message["content"], str):
+                    return {
+                        "role": message["role"],
+                        "content": message["content"]
+                    }
+        elif isinstance(message, str):
+            if message:
+                return {
+                    "role": "user",
+                    "content": message,
+                }
+        return 
+          
+    def predict(self, message: Union[str, dict], history: List[Dict[str, Any]], engine: str, temperature: float) -> Generator:
+        """Generate a streaming response for the given message and conversation history."""
+        self._stop = False  # Reset stop flag
+
+        yield "", gr.update(interactive=False, submit_btn=False, stop_btn=True)
+
+        history.append(message)
+
+        # Process all messages and update the list
+        history = [msg for msg in (self.process_message(msg) for msg in history) if msg is not None]
+
+        response = []
+        streamed_content = ""  # Accumulate the assistant's response here
+
+        def fade_html(text: str, fade_count: int = 200) -> str:
+            """
+            Fade all characters if text is shorter than fade_count.
+            Otherwise, fade only the last fade_count characters.
+            """
+            if not text:
+                return text
+            text_len = len(text)
+            if text_len <= fade_count:
+                # Fade all characters
+                fade_spans = ''
+                for i, c in enumerate(text):
+                    opacity = 1.0 - (i / max(text_len - 1, 1))
+                    fade_spans += f'<span style="opacity:{opacity:.2f};transition:opacity 0.2s">{c}</span>'
+                return fade_spans
+            else:
+                base = text[:-fade_count]
+                fades = text[-fade_count:]
+                fade_spans = ''
+                for i, c in enumerate(fades):
+                    opacity = 1.0 - (i / (fade_count - 1))
+                    fade_spans += f'<span style="opacity:{opacity:.2f};transition:opacity 0.2s">{c}</span>'
+                return base + fade_spans
+
+        for chunk in chat_completion_stream(history, engine=engine, temperature=temperature):
+            logger.debug("Chunk received: %s", chunk)
+            if self._stop:
+                break
+
+            try:
+                content = chunk.get("content", "")
+                if chunk.get("metadata"):
+                    # Do not stream metadata contents, just update/append as before
+                    new_metadata = True
+                    for i, resp in enumerate(response):
+                        if resp.get("metadata", {}).get("id") == chunk["metadata"]["id"]:
+                            response[i]["content"] = content
+                            response[i]["metadata"] = chunk["metadata"]
+                            new_metadata = False
+                            break
+                    if new_metadata:
+                        response.append({
+                            "role": "assistant",
+                            "content": content,
+                            "metadata": chunk["metadata"]
+                        })
+                    # Do not stream char-by-char for metadata
+                    # yield response, gr.skip()
+                else:
+                    # Stream each character in the latest assistant message (no metadata)
+                    if not response or response[-1].get("metadata"):
+                        response.append({
+                            "role": "assistant",
+                            "content": content,
+                        })
+                        streamed_content = ""  # Reset for new message
+                    else:
+                        response[-1]["content"] = content
+                    latest = response[-1]
+                    prev_len = len(streamed_content)
+                    new_content = latest.get("content", "")
+                    for c in new_content[prev_len:]:
+                        if self._stop:
+                            break
+                        streamed_content += c
+                        # Only fade the last fade_count characters of the current message
+                        latest["content"] = fade_html(streamed_content)
+                        yield response, gr.skip()
+                        time.sleep(0.003)
+            except Exception as e:
+                logger.info(f"Error processing chunk from chat completion: {e}")
+                continue
+
+        yield response, gr.update(interactive=True, submit_btn=True, stop_btn=False)
+
+    def stop(self):
+        """Interrupt the currently streaming response."""
+        self._stop = True

client_utils.py

@@ -0,0 +1,91 @@
+import os
+from typing import Dict, Any
+from dotenv import load_dotenv
+from openai import OpenAI, AzureOpenAI
+
+load_dotenv()
+
+# Initialize clients only if their required environment variables are present
+engine_map = {}
+
+# Import here to avoid circular imports - will be populated in code below
+from agent_config import BaseAgentConfig, SITAASAgentConfig
+
+# Azure OpenAI client setup
+if all(os.getenv(var) for var in ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_API_VERSION"]):
+    azure_client = AzureOpenAI(
+        api_key=os.getenv("AZURE_OPENAI_API_KEY"),
+        azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
+        api_version=os.getenv("AZURE_OPENAI_API_VERSION")
+    )
+    engine_map.update({
+        "azure-gpt-4o-mini": {
+            "client": azure_client, 
+            "model": "gpt-4o-mini",   
+            "config": BaseAgentConfig("azure-gpt-4o-mini")
+        },
+        "azure-gpt-4o": {
+            "client": azure_client, 
+            "model": "gpt-4o",   
+            "config": BaseAgentConfig("azure-gpt-4o")
+        },
+    })
+
+# OpenAI client setup
+if os.getenv("OPENAI_API_KEY"):
+    openai_client = OpenAI(
+        api_key=os.getenv("OPENAI_API_KEY"),
+    )
+    engine_map.update({
+        "openai-gpt-4o-mini": {
+            "client": openai_client, 
+            "model": "gpt-4o-mini",   
+            "config": BaseAgentConfig("openai-gpt-4o-mini")
+        },
+        "openai-gpt-4o": {
+            "client": openai_client, 
+            "model": "gpt-4o",   
+            "config": BaseAgentConfig("openai-gpt-4o")
+        },
+    })
+
+# x.ai client setup
+if os.getenv("XAI_API_KEY"):
+    xai_client = OpenAI(
+        api_key=os.getenv("XAI_API_KEY"),
+        base_url="https://api.x.ai/v1",
+    )
+    engine_map["grok-2-latest"] = {
+        "client": xai_client, 
+        "model": "grok-2-latest",   
+        "config": BaseAgentConfig("grok-2-latest")
+    }
+
+# Add the SITAAS agent to the engine_map if required env vars are available
+if all(os.getenv(var) for var in ["SEARCH_ENDPOINT", "SEARCH_KEY"]):
+    engine_map["sitaas-agent"] = {
+        "client": azure_client,
+        "model": "gpt-4.1-mini",
+        "config": SITAASAgentConfig("gpt-4.1-mini")  # Use the SITAAS agent configuration
+    }
+
+def get_client(engine: str) -> OpenAI:
+    """Get the appropriate client for the given engine"""
+    try:
+        return engine_map[engine]["client"]
+    except KeyError:
+        raise ValueError(f"Unsupported engine in get_client: {engine}")
+    
+def get_model(engine: str) -> str:
+    """Get the model name for the given engine"""
+    try:
+        return engine_map[engine]["model"]
+    except KeyError:
+        raise ValueError(f"Unsupported engine in get_model: {engine}")
+
+def get_config(engine: str) -> Any:
+    """Get the agent configuration for the given engine"""
+    try:
+        return engine_map[engine]["config"]
+    except KeyError:
+        raise ValueError(f"Unsupported engine in get_config: {engine}")

embedding_client.py

@@ -0,0 +1,75 @@
+"""Client for handling embeddings for vector search"""
+
+import os
+import logging
+from typing import List, Optional
+import numpy as np
+from openai import AzureOpenAI
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class EmbeddingClient:
+    """Client for generating embeddings using Azure OpenAI"""
+    
+    def __init__(self, azure_endpoint: str, api_key: str, deployment: str, api_version: str = "2023-05-15"):
+        """Initialize the embedding client"""
+        self.azure_endpoint = azure_endpoint
+        self.api_key = api_key
+        self.deployment = deployment
+        self.api_version = api_version
+        
+        # Initialize client
+        self.client = None
+        if self.azure_endpoint and self.api_key and self.deployment:
+            try:
+                self.client = AzureOpenAI(
+                    api_key=self.api_key,
+                    api_version=self.api_version,
+                    azure_endpoint=self.azure_endpoint
+                )
+                logger.info(f"Initialized embedding client with deployment {self.deployment}")
+            except Exception as e:
+                logger.error(f"Failed to initialize Azure OpenAI client: {e}")
+                self.client = None
+        else:
+            logger.warning("Missing configuration for embedding client")
+    
+    def get_embedding(self, text: str) -> List[float]:
+        """Generate embedding for the given text"""
+        if not self.client:
+            logger.warning("No embedding client available, falling back to mock embedding")
+            return self._get_mock_embedding()
+        
+        try:
+            # Truncate text if needed
+            max_chars = 32000  # Approximate limit
+            if len(text) > max_chars:
+                text = text[:max_chars]
+                logger.warning(f"Text truncated to {max_chars} characters")
+            
+            # Call the embeddings API
+            response = self.client.embeddings.create(
+                input=text,
+                model=self.deployment
+            )
+            
+            # Extract the embedding
+            embedding = response.data[0].embedding
+            logger.info(f"Successfully generated embedding of dimension {len(embedding)}")
+            return embedding
+        except Exception as e:
+            logger.error(f"Error generating embedding: {e}")
+            return self._get_mock_embedding()
+    
+    def _get_mock_embedding(self) -> List[float]:
+        """Generate a mock embedding for fallback"""
+        logger.warning("Using mock embedding - this is not suitable for production use")
+        # Generate a normalized random vector
+        embedding = np.random.normal(size=1536)  # Standard dimension for text-embedding-ada-002
+        embedding = embedding / np.linalg.norm(embedding)
+        return embedding.tolist()

environment.yml

@@ -0,0 +1,19 @@
+name: digichat
+channels:
+  - conda-forge
+  - pytorch
+  - defaults
+dependencies:
+  - python=3.10
+  - pip
+  - pytorch
+  - torchvision
+  - pip:
+    - gradio==5.27.0
+    - pandas
+    - openai
+    - tiktoken
+    - python-docx
+    - PyPDF2
+    - pillow
+    - transformers 

file_processors.py

@@ -0,0 +1,383 @@
+import base64
+import json
+from typing import Dict, Any
+import PyPDF2
+from docx import Document
+import pandas as pd
+import nbformat
+
+class BaseProcessor:
+    """Base class for all file processors"""
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        raise NotImplementedError("Subclasses must implement process method")
+
+class PDFProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            pages = []
+            for n, page in enumerate(pdf_reader.pages):
+                pages.append({"page": n, "content": page.extract_text()})
+            return {
+                "content": pages,
+                "metadata": {
+                    "total_pages": len(pages),
+                    "file_type": "PDF"
+                }
+            }
+
+class DocxProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        doc = Document(file_path)
+        paragraphs = []
+        
+        for n, paragraph in enumerate(doc.paragraphs, 1):
+            if paragraph.text.strip():
+                paragraphs.append({
+                    "paragraph": n,
+                    "content": paragraph.text
+                })
+        
+        return {
+            "content": paragraphs,
+            "metadata": {
+                "total_paragraphs": len(paragraphs),
+                "file_type": "DOCX"
+            }
+        }
+
+class ImageProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        try:
+            with open(file_path, 'rb') as file:
+                content = base64.b64encode(file.read()).decode('ascii')
+                return {
+                    "content": content,
+                    "metadata": {
+                        "file_type": "IMAGE",
+                        "encoding": "base64"
+                    }
+                }
+        except Exception as e:
+            raise Exception(f"Error processing image: {str(e)}")
+
+class JSONProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            try:
+                data = json.load(file)
+                return {
+                    "content": data,
+                    "metadata": {
+                        "file_type": "JSON",
+                        "is_valid": True
+                    }
+                }
+            except json.JSONDecodeError as e:
+                return {
+                    "content": None,
+                    "metadata": {
+                        "file_type": "JSON",
+                        "is_valid": False,
+                        "error": str(e)
+                    }
+                }
+
+class TextProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": "TEXT",
+                    "encoding": "utf-8"
+                }
+            }
+
+class CSVProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        try:
+            df = pd.read_csv(file_path)
+            return {
+                "content": df.to_dict(orient='records'),
+                "metadata": {
+                    "file_type": "CSV",
+                    "rows": len(df),
+                    "columns": len(df.columns),
+                    "column_names": list(df.columns),
+                    "summary": {
+                        "first_few_rows": df.head().to_dict(orient='records'),
+                        "statistics": df.describe().to_dict()
+                    }
+                }
+            }
+        except Exception as e:
+            return {
+                "content": None,
+                "metadata": {
+                    "file_type": "CSV",
+                    "error": str(e)
+                }
+            }
+
+class ExcelProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        try:
+            # Get sheet names first
+            xl = pd.ExcelFile(file_path)
+            sheets = xl.sheet_names
+            
+            # Read the first sheet by default
+            df = pd.read_excel(file_path, sheet_name=sheets[0])
+            
+            # Read all sheets
+            all_sheets = {}
+            for sheet in sheets:
+                all_sheets[sheet] = pd.read_excel(file_path, sheet_name=sheet).to_dict(orient='records')
+            
+            return {
+                "content": all_sheets,
+                "metadata": {
+                    "file_type": "EXCEL",
+                    "sheets": sheets,
+                    "current_sheet": {
+                        "name": sheets[0],
+                        "rows": len(df),
+                        "columns": len(df.columns),
+                        "column_names": list(df.columns),
+                        "summary": {
+                            "first_few_rows": df.head().to_dict(orient='records'),
+                            "statistics": df.describe().to_dict()
+                        }
+                    }
+                }
+            }
+        except Exception as e:
+            return {
+                "content": None,
+                "metadata": {
+                    "file_type": "EXCEL",
+                    "error": str(e)
+                }
+            }
+
+class PythonProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": "PYTHON",
+                    "encoding": "utf-8"
+                }
+            }
+
+class JupyterNotebookProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        try:
+            with open(file_path, 'r') as file:
+                nb = nbformat.read(file, as_version=4)
+                content = []
+                for cell in nb.cells:
+                    cell_info = {
+                        "type": cell.cell_type,
+                        "content": cell.source
+                    }
+                    if cell.cell_type == "code" and cell.outputs:
+                        cell_info["outputs"] = [str(output) for output in cell.outputs]
+                    content.append(cell_info)
+                
+                return {
+                    "content": content,
+                    "metadata": {
+                        "file_type": "JUPYTER_NOTEBOOK",
+                        "total_cells": len(content),
+                        "cell_types": list(set(cell["type"] for cell in content))
+                    }
+                }
+        except Exception as e:
+            return {
+                "content": None,
+                "metadata": {
+                    "file_type": "JUPYTER_NOTEBOOK",
+                    "error": str(e)
+                }
+            }
+
+class SVGProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        try:
+            with open(file_path, 'r') as file:
+                return {
+                    "content": file.read(),
+                    "metadata": {
+                        "file_type": "SVG",
+                        "encoding": "utf-8"
+                    }
+                }
+        except Exception as e:
+            return {
+                "content": None,
+                "metadata": {
+                    "file_type": "SVG",
+                    "error": str(e)
+                }
+            }
+
+class JavaScriptProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": "JAVASCRIPT",
+                    "encoding": "utf-8"
+                }
+            }
+
+class HTMLProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": "HTML",
+                    "encoding": "utf-8"
+                }
+            }
+
+class CSSProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": "CSS",
+                    "encoding": "utf-8"
+                }
+            }
+
+class JavaProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": "JAVA",
+                    "encoding": "utf-8"
+                }
+            }
+
+class CppProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": "CPP",
+                    "encoding": "utf-8"
+                }
+            }
+
+class HeaderProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": "HEADER",
+                    "encoding": "utf-8"
+                }
+            }
+
+class ShellScriptProcessor(BaseProcessor):
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": "SHELL_SCRIPT",
+                    "encoding": "utf-8"
+                }
+            }
+
+class CodeFileProcessor(BaseProcessor):
+    """Universal processor for code files that just need to be read as text"""
+    @classmethod
+    def process(cls, file_path: str) -> Dict[str, Any]:
+        with open(file_path, 'r') as file:
+            content = file.read()
+            ext = file_path[file_path.rfind('.'):].upper()[1:]  # Remove the dot and capitalize
+            return {
+                "content": content,
+                "metadata": {
+                    "file_type": ext,
+                    "encoding": "utf-8"
+                }
+            }
+
+class FileProcessorFactory:
+    """Factory class to get the appropriate processor for a file type"""
+    _processors = {
+        '.pdf': PDFProcessor,
+        '.docx': DocxProcessor,
+        '.png': ImageProcessor,
+        '.jpg': ImageProcessor,
+        '.jpeg': ImageProcessor,
+        '.json': JSONProcessor,
+        '.txt': TextProcessor,
+        '.csv': CSVProcessor,
+        '.xlsx': ExcelProcessor,
+        '.xls': ExcelProcessor,
+        '.py': PythonProcessor,
+        '.ipynb': JupyterNotebookProcessor,
+        '.svg': SVGProcessor,
+        # Universal code file processor for various file types
+        '.js': CodeFileProcessor,
+        '.html': CodeFileProcessor,
+        '.htm': CodeFileProcessor,
+        '.css': CodeFileProcessor,
+        '.java': CodeFileProcessor,
+        '.cpp': CodeFileProcessor,
+        '.cc': CodeFileProcessor,
+        '.cxx': CodeFileProcessor,
+        '.h': CodeFileProcessor,
+        '.hpp': CodeFileProcessor,
+        '.sh': CodeFileProcessor,
+        '.bash': CodeFileProcessor
+    }
+    
+    @classmethod
+    def get_processor(cls, file_path: str) -> BaseProcessor:
+        ext = file_path[file_path.rfind('.'):].lower()
+        processor = cls._processors.get(ext)
+        if not processor:
+            raise ValueError(f"Unsupported file type: {ext}")
+        return processor 

generators.py

@@ -0,0 +1,101 @@
+import os
+from typing import List, Dict, Any, Generator
+import importlib
+import threading
+import queue
+
+from dotenv import load_dotenv
+from client_utils import get_client, get_model, get_config, engine_map
+
+load_dotenv()
+
+def get_agent(agent_type: str, *args, **kwargs):
+    """Retrieve an agent configuration based on the agent type from engine_map."""
+    try:
+        if agent_type.lower() in engine_map:
+            return engine_map[agent_type.lower()]["config"]
+        raise ValueError(f"Unsupported agent type: {agent_type}")
+    except KeyError:
+        raise ValueError(f"Unsupported agent type: {agent_type}")
+
+def chat_completion(messages: List[Dict[str, Any]], engine: str = "grok-2-latest", temperature: float = 0.5) -> str:
+    # Dynamic import to avoid circular import
+    from agents import BaseAgent, OrchestratorAgent
+    
+    # Get the appropriate config
+    config = get_config(engine)
+    
+    # Override temperature if specified
+    config.setup_model_config(engine, temperature)
+    
+    # Use orchestrator if the config has tools available
+    if len(config.get_tools()) > 0:
+        agent = OrchestratorAgent(config)
+    else:
+        agent = BaseAgent(config)
+        
+    result_queue = queue.Queue()
+
+    def run_process():
+        try:
+            result = agent.process(messages)
+            result_queue.put(result)
+        except Exception as e:
+            result_queue.put(e)
+
+    t = threading.Thread(target=run_process)
+    t.start()
+    t.join()
+    result = result_queue.get()
+    if isinstance(result, Exception):
+        raise result
+    return result
+
+def chat_completion_stream(messages: List[Dict[str, Any]], engine: str = "grok-2-latest", temperature: float = 0.5) -> Generator[Any, None, None]:
+    """Stream chat completions based on the selected engine or agent."""
+    try:
+        # Dynamic import to avoid circular import
+        from agents import BaseAgent, OrchestratorAgent
+        
+        # Get the appropriate config
+        config = get_config(engine)
+        
+        # Override temperature if specified
+        config.setup_model_config(engine, temperature)
+        
+        # Use orchestrator if the config has tools available
+        if len(config.get_tools()) > 0:
+            agent = OrchestratorAgent(config)
+            stream_fn = agent.process_stream
+        else:
+            agent = BaseAgent(config)
+            stream_fn = agent.process_stream
+
+        q = queue.Queue()
+        sentinel = object()
+
+        def run_stream():
+            try:
+                for chunk in stream_fn(messages):
+                    q.put(chunk)
+            except Exception as e:
+                q.put(e)
+            finally:
+                q.put(sentinel)
+
+        t = threading.Thread(target=run_stream)
+        t.start()
+        while True:
+            item = q.get()
+            if item is sentinel:
+                break
+            if isinstance(item, Exception):
+                raise item
+            yield item
+                
+    except Exception as e:
+        # In case of any error, yield a special error chunk that our handler can process
+        print(f"Error in chat_completion_stream: {e}")
+        error_msg = f"Error: {str(e)}"
+        # Create a minimal mock chunk with the error message
+        yield {"choices": [{"delta": {"content": error_msg}}]}

requirements.txt

@@ -0,0 +1,27 @@
+gradio[oauth]==5.24.0
+python-dotenv>=1.0.0
+pandas>=2.0.0
+openai>=1.0.0
+tiktoken>=0.5.0
+
+# For document processing
+python-docx>=0.8.11
+PyPDF2>=3.0.0
+pillow>=10.0.0
+pytesseract>=0.3.10
+torch>=2.0.0
+nbformat>=5.9.0
+python-multipart>=0.0.6
+
+# Azure packages
+requests>=2.28.0
+azure-core>=1.29.4
+azure-identity>=1.15.0
+# Specify newer version that supports vector search
+azure-search-documents>=11.4.0b6
+azure-ai-formrecognizer>=3.2.0
+azure-storage-blob>=12.17.0
+
+# For embeddings and vector operations
+numpy>=1.20.0
+scikit-learn>=1.0.0

style.css

@@ -0,0 +1,96 @@
+div#component-7, div#component-10 {
+    flex: 0;
+    flex-wrap: nowrap;
+    flex-grow: 0;
+    flex-shrink: 0;
+    flex-direction: row;
+}
+
+div#component-7 {
+    justify-content: flex-start;
+}
+
+div#component-10 {
+    justify-content: flex-end;
+}
+
+.wrap.svelte-1hfxrpf {
+    background: none;
+    width: fit-content;
+}
+
+div#component-8, .form.svelte-633qhp {
+    background: none;
+    margin: 0;
+    padding: 0;
+}
+
+button#new_chat_btn, button#login_btn {
+    min-width: min-content;
+    width: fit-content;
+}
+
+.button-icon {
+    width: var(--text-xxl);
+    height: var(--text-xxl);
+}
+
+div#component-0 {
+    height: 90vh;
+}
+
+div#component-27, div#component-33 {
+    display: none;
+}
+
+.icon-wrap.svelte-1hfxrpf {
+    right: 0;
+}
+
+input.border-none.svelte-1hfxrpf {
+    font-size: medium;
+    font-weight: bold;
+}
+
+.label.svelte-p5q82i {
+   margin-bottom: var(--size-5)
+}
+textarea.edit-textarea {
+    border: none;
+}
+
+div#component-32 {
+    gap: 0;
+    max-height: 70vh;
+}
+
+div#chatbot {
+    max-width: min(80%, 900px);
+    align-self: center;
+}
+div#inputs {
+    max-width: min(80%, 700px);
+    min-height: fit-content;
+    align-self: center;
+}
+.styler.svelte-1nguped {
+    background: var(--block-background-fill);
+}
+.form.svelte-633qhp {
+    gap: 0;
+    box-shadow: none;
+}
+
+.bot.svelte-yaaj3.message {
+    border: none;
+}
+.styler.svelte-1nguped {
+    gap: 0px;
+}
+
+.table-wrap.svelte-p5q82i {
+    border: none;
+}
+thead {
+    display: none;
+}