Changelog update for 2.3.8-alfa

- Add possibility to add allowed_languages to tenant make

.aiignore

@@ -0,0 +1,19 @@
+# An .aiignore file follows the same syntax as a .gitignore file.
+# .gitignore documentation: https://git-scm.com/docs/gitignore
+
+# you can ignore files
+.DS_Store
+*.log
+*.tmp
+
+# or folders
+dist/
+build/
+out/
+nginx/node_modules/
+nginx/static/
+db_backups/
+docker/eveai_logs/
+docker/logs/
+docker/minio/
+

.gitignore

@@ -53,3 +53,7 @@ scripts/__pycache__/run_eveai_app.cpython-312.pyc
 /docker/grafana/data/
 /temp_requirements/
 /nginx/node_modules/
+/nginx/static/assets/css/chat.css
+/nginx/static/assets/css/chat-components.css
+/nginx/static/assets/js/components/
+/nginx/static/assets/js/chat-app.js

README.md.k8s-logging

@@ -0,0 +1,67 @@
+# Kubernetes Logging Upgrade
+
+## Overzicht
+Deze instructies beschrijven hoe je alle services moet bijwerken om de nieuwe logging configuratie te gebruiken die zowel compatibel is met traditionele bestandsgebaseerde logging (voor ontwikkeling/test) als met Kubernetes (voor productie).
+
+## Stappen voor elke service
+
+Pas de volgende wijzigingen toe in elk van de volgende services:
+
+- eveai_app
+- eveai_workers
+- eveai_api
+- eveai_chat_client
+- eveai_chat_workers
+- eveai_beat
+- eveai_entitlements
+
+### 1. Update de imports
+
+Verander:
+```python
+from config.logging_config import LOGGING
+```
+
+Naar:
+```python
+from config.logging_config import configure_logging
+```
+
+### 2. Update de logging configuratie
+
+Verander:
+```python
+logging.config.dictConfig(LOGGING)
+```
+
+Naar:
+```python
+configure_logging()
+```
+
+## Dockerfile Aanpassingen
+
+Voeg de volgende regels toe aan je Dockerfile voor elke service om de Kubernetes-specifieke logging afhankelijkheden te installeren (alleen voor productie):
+
+```dockerfile
+# Alleen voor productie (Kubernetes) builds
+COPY requirements-k8s.txt /app/
+RUN if [ "$ENVIRONMENT" = "production" ]; then pip install -r requirements-k8s.txt; fi
+```
+
+## Kubernetes Deployment
+
+Zorg ervoor dat je Kubernetes deployment manifests de volgende omgevingsvariabele bevatten:
+
+```yaml
+env:
+  - name: FLASK_ENV
+    value: "production"
+```
+
+## Voordelen
+
+1. De code detecteert automatisch of deze in Kubernetes draait
+2. In ontwikkeling/test omgevingen blijft alles naar bestanden schrijven
+3. In Kubernetes gaan logs naar stdout/stderr in JSON-formaat
+4. Geen wijzigingen nodig in bestaande logger code in de applicatie

app/eveai_chat_client/templates/chat.html

@@ -0,0 +1,6 @@
+<!-- chat.html -->
+{% extends "base.html" %}
+
+{% block title %}{{ tenant_make.name|default('EveAI') }} - AI Chat{% endblock %}
+
+{% block head %}

common/extensions.py

@@ -11,6 +11,7 @@ from flask_restx import Api
 from prometheus_flask_exporter import PrometheusMetrics
 
 from .utils.cache.eveai_cache_manager import EveAICacheManager
+from .utils.content_utils import ContentManager
 from .utils.simple_encryption import SimpleEncryption
 from .utils.minio_utils import MinioClient
 
@@ -30,4 +31,5 @@ simple_encryption = SimpleEncryption()
 minio_client = MinioClient()
 metrics = PrometheusMetrics.for_app_factory()
 cache_manager = EveAICacheManager()
+content_manager = ContentManager()
 

common/langchain/llm_metrics_handler.py

@@ -3,7 +3,6 @@ from langchain.callbacks.base import BaseCallbackHandler
 from typing import Dict, Any, List
 from langchain.schema import LLMResult
 from common.utils.business_event_context import current_event
-from flask import current_app
 
 
 class LLMMetricsHandler(BaseCallbackHandler):

common/langchain/persistent_llm_metrics_handler.py

@@ -0,0 +1,47 @@
+import time
+from langchain.callbacks.base import BaseCallbackHandler
+from typing import Dict, Any, List
+from langchain.schema import LLMResult
+from common.utils.business_event_context import current_event
+
+
+class PersistentLLMMetricsHandler(BaseCallbackHandler):
+    """Metrics handler that allows metrics to be retrieved from within any call. In case metrics are required for other
+    purposes than business event logging."""
+
+    def __init__(self):
+        self.total_tokens: int = 0
+        self.prompt_tokens: int = 0
+        self.completion_tokens: int = 0
+        self.start_time: float = 0
+        self.end_time: float = 0
+        self.total_time: float = 0
+
+    def reset(self):
+        self.total_tokens = 0
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
+        self.start_time = 0
+        self.end_time = 0
+        self.total_time = 0
+
+    def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any) -> None:
+        self.start_time = time.time()
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        self.end_time = time.time()
+        self.total_time = self.end_time - self.start_time
+
+        usage = response.llm_output.get('token_usage', {})
+        self.prompt_tokens += usage.get('prompt_tokens', 0)
+        self.completion_tokens += usage.get('completion_tokens', 0)
+        self.total_tokens = self.prompt_tokens + self.completion_tokens
+
+    def get_metrics(self) -> Dict[str, int | float]:
+        return {
+            'total_tokens': self.total_tokens,
+            'prompt_tokens': self.prompt_tokens,
+            'completion_tokens': self.completion_tokens,
+            'time_elapsed': self.total_time,
+            'interaction_type': 'LLM',
+        }

common/models/document.py

@@ -8,7 +8,7 @@ import sqlalchemy as sa
 
 class Catalog(db.Model):
     id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(50), nullable=False)
+    name = db.Column(db.String(50), nullable=False, unique=True)
     description = db.Column(db.Text, nullable=True)
     type = db.Column(db.String(50), nullable=False, default="STANDARD_CATALOG")
 
@@ -34,6 +34,7 @@ class Processor(db.Model):
     catalog_id = db.Column(db.Integer, db.ForeignKey('catalog.id'), nullable=True)
     type = db.Column(db.String(50), nullable=False)
     sub_file_type = db.Column(db.String(50), nullable=True)
+    active = db.Column(db.Boolean, nullable=True, default=True)
 
     # Tuning enablers
     tuning = db.Column(db.Boolean, nullable=True, default=False)

common/models/interaction.py

@@ -1,7 +1,7 @@
 from sqlalchemy.dialects.postgresql import JSONB
 
 from ..extensions import db
-from .user import User, Tenant
+from .user import User, Tenant, TenantMake
 from .document import Embedding, Retriever
 
 
@@ -29,6 +29,7 @@ class Specialist(db.Model):
     tuning = db.Column(db.Boolean, nullable=True, default=False)
     configuration = db.Column(JSONB, nullable=True)
     arguments = db.Column(JSONB, nullable=True)
+    active = db.Column(db.Boolean, nullable=True, default=True)
 
     # Relationship to retrievers through the association table
     retrievers = db.relationship('SpecialistRetriever', backref='specialist', lazy=True,
@@ -44,6 +45,21 @@ class Specialist(db.Model):
     updated_at = db.Column(db.DateTime, nullable=False, server_default=db.func.now(), onupdate=db.func.now())
     updated_by = db.Column(db.Integer, db.ForeignKey(User.id))
 
+    def __repr__(self):
+        return f"<Specialist {self.id}: {self.name}>"
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'description': self.description,
+            'type': self.type,
+            'type_version': self.type_version,
+            'configuration': self.configuration,
+            'arguments': self.arguments,
+            'active': self.active,
+        }
+
 
 class EveAIAsset(db.Model):
     id = db.Column(db.Integer, primary_key=True)
@@ -215,3 +231,36 @@ class SpecialistDispatcher(db.Model):
     dispatcher_id = db.Column(db.Integer, db.ForeignKey(Dispatcher.id, ondelete='CASCADE'), primary_key=True)
 
     dispatcher = db.relationship("Dispatcher", backref="specialist_dispatchers")
+
+
+class SpecialistMagicLink(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(50), nullable=False)
+    description = db.Column(db.Text, nullable=True)
+    specialist_id = db.Column(db.Integer, db.ForeignKey(Specialist.id, ondelete='CASCADE'), nullable=False)
+    tenant_make_id = db.Column(db.Integer, db.ForeignKey(TenantMake.id, ondelete='CASCADE'), nullable=True)
+    magic_link_code = db.Column(db.String(55), nullable=False, unique=True)
+
+    valid_from = db.Column(db.DateTime, nullable=True)
+    valid_to = db.Column(db.DateTime, nullable=True)
+
+    specialist_args = db.Column(JSONB, nullable=True)
+
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
+    created_by = db.Column(db.Integer, db.ForeignKey(User.id), nullable=True)
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=db.func.now(), onupdate=db.func.now())
+    updated_by = db.Column(db.Integer, db.ForeignKey(User.id))
+
+    def __repr__(self):
+        return f"<SpecialistMagicLink {self.specialist_id} {self.magic_link_code}>"
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'description': self.description,
+            'magic_link_code': self.magic_link_code,
+            'valid_from': self.valid_from,
+            'valid_to': self.valid_to,
+            'specialist_args': self.specialist_args,
+        }

common/models/user.py

@@ -2,7 +2,7 @@ from datetime import date
 
 from common.extensions import db
 from flask_security import UserMixin, RoleMixin
-from sqlalchemy.dialects.postgresql import ARRAY
+from sqlalchemy.dialects.postgresql import ARRAY, JSONB
 import sqlalchemy as sa
 
 from common.models.entitlements import License
@@ -28,17 +28,19 @@ class Tenant(db.Model):
 
     # language information
     default_language = db.Column(db.String(2), nullable=True)
-    allowed_languages = db.Column(ARRAY(sa.String(2)), nullable=True)
 
    # Entitlements
     currency = db.Column(db.String(20), nullable=True)
     storage_dirty = db.Column(db.Boolean, nullable=True, default=False)
+    default_tenant_make_id = db.Column(db.Integer, db.ForeignKey('public.tenant_make.id'), nullable=True)
 
     # Relations
     users = db.relationship('User', backref='tenant')
     domains = db.relationship('TenantDomain', backref='tenant')
     licenses = db.relationship('License', back_populates='tenant')
     license_usages = db.relationship('LicenseUsage', backref='tenant')
+    tenant_makes = db.relationship('TenantMake', backref='tenant', foreign_keys='TenantMake.tenant_id')
+    default_tenant_make = db.relationship('TenantMake', foreign_keys=[default_tenant_make_id], uselist=False)
 
     @property
     def current_license(self):
@@ -60,8 +62,8 @@ class Tenant(db.Model):
             'timezone': self.timezone,
             'type': self.type,
             'default_language': self.default_language,
-            'allowed_languages': self.allowed_languages,
             'currency': self.currency,
+            'default_tenant_make_id': self.default_tenant_make_id,
         }
 
 
@@ -173,6 +175,43 @@ class TenantProject(db.Model):
         return f"<TenantProject {self.id}: {self.name}>"
 
 
+class TenantMake(db.Model):
+    __bind_key__ = 'public'
+    __table_args__ = {'schema': 'public'}
+
+    id = db.Column(db.Integer, primary_key=True)
+    tenant_id = db.Column(db.Integer, db.ForeignKey('public.tenant.id'), nullable=False)
+    name = db.Column(db.String(50), nullable=False, unique=True)
+    description = db.Column(db.Text, nullable=True)
+    active = db.Column(db.Boolean, nullable=False, default=True)
+    website = db.Column(db.String(255), nullable=True)
+    logo_url = db.Column(db.String(255), nullable=True)
+    allowed_languages = db.Column(ARRAY(sa.String(2)), nullable=True)
+
+    # Chat customisation options
+    chat_customisation_options = db.Column(JSONB, nullable=True)
+
+    # Versioning Information
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
+    created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=db.func.now(), onupdate=db.func.now())
+    updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'))
+
+    def __repr__(self):
+        return f"<TenantMake {self.id} for tenant {self.tenant_id}: {self.name}>"
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'description': self.description,
+            'active': self.active,
+            'website': self.website,
+            'logo_url': self.logo_url,
+            'chat_customisation_options': self.chat_customisation_options,
+        }
+
+
 class Partner(db.Model):
     __bind_key__ = 'public'
     __table_args__ = {'schema': 'public'}
@@ -271,3 +310,35 @@ class PartnerTenant(db.Model):
     created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
     updated_at = db.Column(db.DateTime, nullable=False, server_default=db.func.now(), onupdate=db.func.now())
     updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
+
+
+class SpecialistMagicLinkTenant(db.Model):
+    __bind_key__ = 'public'
+    __table_args__ = {'schema': 'public'}
+
+    magic_link_code = db.Column(db.String(55), primary_key=True)
+    tenant_id = db.Column(db.Integer, db.ForeignKey('public.tenant.id'), nullable=False)
+
+
+class TranslationCache(db.Model):
+    __bind_key__ = 'public'
+    __table_args__ = {'schema': 'public'}
+
+    cache_key = db.Column(db.String(16), primary_key=True)
+    source_text = db.Column(db.Text, nullable=False)
+    translated_text = db.Column(db.Text, nullable=False)
+    source_language = db.Column(db.String(2), nullable=False)
+    target_language = db.Column(db.String(2), nullable=False)
+    context = db.Column(db.Text, nullable=True)
+
+    # Translation cost
+    prompt_tokens = db.Column(db.Integer, nullable=False)
+    completion_tokens = db.Column(db.Integer, nullable=False)
+
+    # Tracking
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
+    created_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
+    updated_at = db.Column(db.DateTime, nullable=False, server_default=db.func.now(), onupdate=db.func.now())
+    updated_by = db.Column(db.Integer, db.ForeignKey('public.user.id'), nullable=True)
+
+    last_used_at = db.Column(db.DateTime, nullable=True)

common/services/entitlements/license_tier_services.py

@@ -6,7 +6,7 @@ from sqlalchemy.exc import SQLAlchemyError
 from common.extensions import db
 from common.models.entitlements import PartnerServiceLicenseTier
 from common.models.user import Partner
-from common.utils.eveai_exceptions import EveAINoManagementPartnerService
+from common.utils.eveai_exceptions import EveAINoManagementPartnerService, EveAINoSessionPartner
 from common.utils.model_logging_utils import set_logging_information
 
 
@@ -19,7 +19,7 @@ class LicenseTierServices:
             # Get partner service (MANAGEMENT_SERVICE type)
             partner = Partner.query.get(partner_id)
             if not partner:
-                return
+                raise EveAINoSessionPartner()
 
             # Find a management service for this partner
             management_service = next((service for service in session['partner']['services']

common/services/interaction/specialist_services.py

@@ -1,7 +1,15 @@
 import uuid
-from typing import Dict, Any, Tuple
+from datetime import datetime as dt, timezone as tz
+from typing import Dict, Any, Tuple, Optional
+from flask import current_app
+from sqlalchemy.exc import SQLAlchemyError
 
+from common.extensions import db, cache_manager
+from common.models.interaction import (
+    Specialist, EveAIAgent, EveAITask, EveAITool
+)
 from common.utils.celery_utils import current_celery
+from common.utils.model_logging_utils import set_logging_information, update_logging_information
 
 
 class SpecialistServices:
@@ -27,4 +35,203 @@ class SpecialistServices:
             'status': 'queued',
         }
 
+    @staticmethod
+    def initialize_specialist(specialist_id: int, specialist_type: str, specialist_version: str):
+        """
+        Initialize an agentic specialist by creating all its components based on configuration.
 
+        Args:
+            specialist_id: ID of the specialist to initialize
+            specialist_type: Type of the specialist
+            specialist_version: Version of the specialist type to use
+
+        Raises:
+            ValueError: If specialist not found or invalid configuration
+            SQLAlchemyError: If database operations fail
+        """
+        config = cache_manager.specialists_config_cache.get_config(specialist_type, specialist_version)
+        if not config:
+            raise ValueError(f"No configuration found for {specialist_type} version {specialist_version}")
+        if config['framework'] == 'langchain':
+            pass    # Langchain does not require additional items to be initialized. All configuration is in the specialist.
+
+        specialist = Specialist.query.get(specialist_id)
+        if not specialist:
+            raise ValueError(f"Specialist with ID {specialist_id} not found")
+
+        if config['framework'] == 'crewai':
+            SpecialistServices.initialize_crewai_specialist(specialist, config)
+
+    @staticmethod
+    def initialize_crewai_specialist(specialist: Specialist, config: Dict[str, Any]):
+        timestamp = dt.now(tz=tz.utc)
+
+        try:
+            # Initialize agents
+            if 'agents' in config:
+                for agent_config in config['agents']:
+                    SpecialistServices._create_agent(
+                        specialist_id=specialist.id,
+                        agent_type=agent_config['type'],
+                        agent_version=agent_config['version'],
+                        name=agent_config.get('name'),
+                        description=agent_config.get('description'),
+                        timestamp=timestamp
+                    )
+
+            # Initialize tasks
+            if 'tasks' in config:
+                for task_config in config['tasks']:
+                    SpecialistServices._create_task(
+                        specialist_id=specialist.id,
+                        task_type=task_config['type'],
+                        task_version=task_config['version'],
+                        name=task_config.get('name'),
+                        description=task_config.get('description'),
+                        timestamp=timestamp
+                    )
+
+            # Initialize tools
+            if 'tools' in config:
+                for tool_config in config['tools']:
+                    SpecialistServices._create_tool(
+                        specialist_id=specialist.id,
+                        tool_type=tool_config['type'],
+                        tool_version=tool_config['version'],
+                        name=tool_config.get('name'),
+                        description=tool_config.get('description'),
+                        timestamp=timestamp
+                    )
+
+            db.session.commit()
+            current_app.logger.info(f"Successfully initialized crewai specialist {specialist.id}")
+
+        except SQLAlchemyError as e:
+            db.session.rollback()
+            current_app.logger.error(f"Database error initializing crewai specialist {specialist.id}: {str(e)}")
+            raise
+        except Exception as e:
+            db.session.rollback()
+            current_app.logger.error(f"Error initializing crewai specialist {specialist.id}: {str(e)}")
+            raise
+
+    @staticmethod
+    def _create_agent(
+            specialist_id: int,
+            agent_type: str,
+            agent_version: str,
+            name: Optional[str] = None,
+            description: Optional[str] = None,
+            timestamp: Optional[dt] = None
+    ) -> EveAIAgent:
+        """Create an agent with the given configuration."""
+        if timestamp is None:
+            timestamp = dt.now(tz=tz.utc)
+
+        # Get agent configuration from cache
+        agent_config = cache_manager.agents_config_cache.get_config(agent_type, agent_version)
+
+        agent = EveAIAgent(
+            specialist_id=specialist_id,
+            name=name or agent_config.get('name', agent_type),
+            description=description or agent_config.get('metadata').get('description', ''),
+            type=agent_type,
+            type_version=agent_version,
+            role=None,
+            goal=None,
+            backstory=None,
+            tuning=False,
+            configuration=None,
+            arguments=None
+        )
+
+        set_logging_information(agent, timestamp)
+
+        db.session.add(agent)
+        current_app.logger.info(f"Created agent {agent.id} of type {agent_type}")
+        return agent
+
+    @staticmethod
+    def _create_task(
+            specialist_id: int,
+            task_type: str,
+            task_version: str,
+            name: Optional[str] = None,
+            description: Optional[str] = None,
+            timestamp: Optional[dt] = None
+    ) -> EveAITask:
+        """Create a task with the given configuration."""
+        if timestamp is None:
+            timestamp = dt.now(tz=tz.utc)
+
+        # Get task configuration from cache
+        task_config = cache_manager.tasks_config_cache.get_config(task_type, task_version)
+
+        task = EveAITask(
+            specialist_id=specialist_id,
+            name=name or task_config.get('name', task_type),
+            description=description or task_config.get('metadata').get('description', ''),
+            type=task_type,
+            type_version=task_version,
+            task_description=None,
+            expected_output=None,
+            tuning=False,
+            configuration=None,
+            arguments=None,
+            context=None,
+            asynchronous=False,
+        )
+
+        set_logging_information(task, timestamp)
+
+        db.session.add(task)
+        current_app.logger.info(f"Created task {task.id} of type {task_type}")
+        return task
+
+    @staticmethod
+    def _create_tool(
+            specialist_id: int,
+            tool_type: str,
+            tool_version: str,
+            name: Optional[str] = None,
+            description: Optional[str] = None,
+            timestamp: Optional[dt] = None
+    ) -> EveAITool:
+        """Create a tool with the given configuration."""
+        if timestamp is None:
+            timestamp = dt.now(tz=tz.utc)
+
+        # Get tool configuration from cache
+        tool_config = cache_manager.tools_config_cache.get_config(tool_type, tool_version)
+
+        tool = EveAITool(
+            specialist_id=specialist_id,
+            name=name or tool_config.get('name', tool_type),
+            description=description or tool_config.get('metadata').get('description', ''),
+            type=tool_type,
+            type_version=tool_version,
+            tuning=False,
+            configuration=None,
+            arguments=None,
+        )
+
+        set_logging_information(tool, timestamp)
+
+        db.session.add(tool)
+        current_app.logger.info(f"Created tool {tool.id} of type {tool_type}")
+        return tool
+
+    @staticmethod
+    def get_specialist_system_field(specialist_id, config_name, system_name):
+        """Get the value of a system field in a specialist's configuration. Returns the actual value, or None."""
+        specialist = Specialist.query.get(specialist_id)
+        if not specialist:
+            raise ValueError(f"Specialist with ID {specialist_id} not found")
+        config = cache_manager.specialists_config_cache.get_config(specialist.type, specialist.type_version)
+        if not config:
+            raise ValueError(f"No configuration found for {specialist.type} version {specialist.version}")
+        potential_field = config.get(config_name, None)
+        if potential_field:
+            if potential_field.type == 'system' and potential_field.system_name == system_name:
+                return specialist.configuration.get(config_name, None)
+        return None

common/services/user/tenant_services.py

@@ -28,7 +28,7 @@ class TenantServices:
                                        if service.get('type') == 'MANAGEMENT_SERVICE'), None)
 
             if not management_service:
-                current_app.logger.error(f"No Management Service defined for partner {partner_id}"
+                current_app.logger.error(f"No Management Service defined for partner {partner_id} "
                                          f"while associating tenant {tenant_id} with partner.")
                 raise EveAINoManagementPartnerService()
 

common/services/utils/translation_services.py

@@ -0,0 +1,43 @@
+import xxhash
+import json
+
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+
+from common.langchain.persistent_llm_metrics_handler import PersistentLLMMetricsHandler
+from common.utils.model_utils import get_template, replace_variable_in_template
+
+class TranslationService:
+    def __init__(self, tenant_id):
+        self.tenant_id = tenant_id
+
+    def translate_text(self, text_to_translate: str, target_lang: str, source_lang: str = None, context: str = None) -> tuple[
+        str, dict[str, int | float]]:
+        prompt_params = {
+            "text_to_translate": text_to_translate,
+            "target_lang": target_lang,
+        }
+        if context:
+            template, llm = get_template("translation_with_context")
+            prompt_params["context"] = context
+        else:
+            template, llm = get_template("translation_without_context")
+
+        # Add a metrics handler to capture usage
+
+        metrics_handler = PersistentLLMMetricsHandler()
+        existing_callbacks = llm.callbacks
+        llm.callbacks = existing_callbacks + [metrics_handler]
+
+        translation_prompt = ChatPromptTemplate.from_template(template)
+
+        setup = RunnablePassthrough()
+
+        chain = (setup | translation_prompt | llm | StrOutputParser())
+
+        translation = chain.invoke(prompt_params)
+
+        metrics = metrics_handler.get_metrics()
+
+        return translation, metrics

common/utils/cache/config_cache.py

@@ -7,7 +7,7 @@ from flask import current_app
 
 from common.utils.cache.base import CacheHandler, CacheKey
 from config.type_defs import agent_types, task_types, tool_types, specialist_types, retriever_types, prompt_types, \
-    catalog_types, partner_service_types
+    catalog_types, partner_service_types, processor_types, customisation_types, specialist_form_types
 
 
 def is_major_minor(version: str) -> bool:
@@ -59,7 +59,7 @@ class BaseConfigCacheHandler(CacheHandler[Dict[str, Any]]):
         """Set the version tree cache dependency."""
         self.version_tree_cache = cache
 
-    def _load_specific_config(self, type_name: str, version_str: str) -> Dict[str, Any]:
+    def _load_specific_config(self, type_name: str, version_str: str = 'latest') -> Dict[str, Any]:
         """
         Load a specific configuration version
         Automatically handles global vs partner-specific configs
@@ -456,7 +456,13 @@ CatalogConfigCacheHandler, CatalogConfigVersionTreeCacheHandler, CatalogConfigTy
         types_module=catalog_types.CATALOG_TYPES
     ))
 
-# Add to common/utils/cache/config_cache.py
+ProcessorConfigCacheHandler, ProcessorConfigVersionTreeCacheHandler, ProcessorConfigTypesCacheHandler = (
+    create_config_cache_handlers(
+        config_type='processors',
+        config_dir='config/processors',
+        types_module=processor_types.PROCESSOR_TYPES
+    ))
+
 PartnerServiceConfigCacheHandler, PartnerServiceConfigVersionTreeCacheHandler, PartnerServiceConfigTypesCacheHandler = (
     create_config_cache_handlers(
         config_type='partner_services',
@@ -464,6 +470,22 @@ PartnerServiceConfigCacheHandler, PartnerServiceConfigVersionTreeCacheHandler, P
         types_module=partner_service_types.PARTNER_SERVICE_TYPES
     ))
 
+CustomisationConfigCacheHandler, CustomisationConfigVersionTreeCacheHandler, CustomisationConfigTypesCacheHandler = (
+    create_config_cache_handlers(
+        config_type='customisations',
+        config_dir='config/customisations',
+        types_module=customisation_types.CUSTOMISATION_TYPES
+    )
+)
+
+SpecialistFormConfigCacheHandler, SpecialistFormConfigVersionTreeCacheHandler, SpecialistFormConfigTypesCacheHandler = (
+    create_config_cache_handlers(
+        config_type='specialist_forms',
+        config_dir='config/specialist_forms',
+        types_module=specialist_form_types.SPECIALIST_FORM_TYPES
+    )
+)
+
 
 def register_config_cache_handlers(cache_manager) -> None:
     cache_manager.register_handler(AgentConfigCacheHandler, 'eveai_config')
@@ -487,12 +509,21 @@ def register_config_cache_handlers(cache_manager) -> None:
     cache_manager.register_handler(CatalogConfigCacheHandler, 'eveai_config')
     cache_manager.register_handler(CatalogConfigTypesCacheHandler, 'eveai_config')
     cache_manager.register_handler(CatalogConfigVersionTreeCacheHandler, 'eveai_config')
+    cache_manager.register_handler(ProcessorConfigCacheHandler, 'eveai_config')
+    cache_manager.register_handler(ProcessorConfigTypesCacheHandler, 'eveai_config')
+    cache_manager.register_handler(ProcessorConfigVersionTreeCacheHandler, 'eveai_config')
     cache_manager.register_handler(AgentConfigCacheHandler, 'eveai_config')
     cache_manager.register_handler(AgentConfigTypesCacheHandler, 'eveai_config')
     cache_manager.register_handler(AgentConfigVersionTreeCacheHandler, 'eveai_config')
     cache_manager.register_handler(PartnerServiceConfigCacheHandler, 'eveai_config')
     cache_manager.register_handler(PartnerServiceConfigTypesCacheHandler, 'eveai_config')
     cache_manager.register_handler(PartnerServiceConfigVersionTreeCacheHandler, 'eveai_config')
+    cache_manager.register_handler(CustomisationConfigCacheHandler, 'eveai_config')
+    cache_manager.register_handler(CustomisationConfigTypesCacheHandler, 'eveai_config')
+    cache_manager.register_handler(CustomisationConfigVersionTreeCacheHandler, 'eveai_config')
+    cache_manager.register_handler(SpecialistFormConfigCacheHandler, 'eveai_config')
+    cache_manager.register_handler(SpecialistFormConfigTypesCacheHandler, 'eveai_config')
+    cache_manager.register_handler(SpecialistFormConfigVersionTreeCacheHandler, 'eveai_config')
 
     cache_manager.agents_config_cache.set_version_tree_cache(cache_manager.agents_version_tree_cache)
     cache_manager.tasks_config_cache.set_version_tree_cache(cache_manager.tasks_version_tree_cache)
@@ -500,4 +531,8 @@ def register_config_cache_handlers(cache_manager) -> None:
     cache_manager.specialists_config_cache.set_version_tree_cache(cache_manager.specialists_version_tree_cache)
     cache_manager.retrievers_config_cache.set_version_tree_cache(cache_manager.retrievers_version_tree_cache)
     cache_manager.prompts_config_cache.set_version_tree_cache(cache_manager.prompts_version_tree_cache)
+    cache_manager.catalogs_config_cache.set_version_tree_cache(cache_manager.catalogs_version_tree_cache)
+    cache_manager.processors_config_cache.set_version_tree_cache(cache_manager.processors_version_tree_cache)
     cache_manager.partner_services_config_cache.set_version_tree_cache(cache_manager.partner_services_version_tree_cache)
+    cache_manager.customisations_config_cache.set_version_tree_cache(cache_manager.customisations_version_tree_cache)
+    cache_manager.specialist_forms_config_cache.set_version_tree_cache(cache_manager.specialist_forms_version_tree_cache)

common/utils/cache/translation_cache.py

@@ -0,0 +1,156 @@
+import json
+from typing import Dict, Any, Optional
+from datetime import datetime as dt, timezone as tz
+
+import xxhash
+from flask import current_app
+from sqlalchemy import and_
+from sqlalchemy.inspection import inspect
+
+from common.utils.cache.base import CacheHandler, T
+from common.extensions import db
+
+from common.models.user import TranslationCache
+from common.services.utils.translation_services import TranslationService
+from flask_security import current_user
+
+
+class TranslationCacheHandler(CacheHandler[TranslationCache]):
+    """Handles caching of translations with fallback to database and external translation service"""
+    handler_name = 'translation_cache'
+
+    def __init__(self, region):
+        super().__init__(region, 'translation')
+        self.configure_keys('hash_key')
+
+    def _to_cache_data(self, instance: TranslationCache) -> Dict[str, Any]:
+        """Convert TranslationCache instance to cache data using SQLAlchemy inspection"""
+        if not instance:
+            return {}
+
+        mapper = inspect(TranslationCache)
+        data = {}
+
+        for column in mapper.columns:
+            value = getattr(instance, column.name)
+
+            # Handle date serialization
+            if isinstance(value, dt):
+                data[column.name] = value.isoformat()
+            else:
+                data[column.name] = value
+
+        return data
+
+    def _from_cache_data(self, data: Dict[str, Any], **kwargs) -> TranslationCache:
+        if not data:
+            return None
+
+        # Create a new TranslationCache instance
+        translation = TranslationCache()
+        mapper = inspect(TranslationCache)
+
+        # Set all attributes dynamically
+        for column in mapper.columns:
+            if column.name in data:
+                value = data[column.name]
+
+                # Handle date deserialization
+                if column.name.endswith('_date') and value:
+                    if isinstance(value, str):
+                        value = dt.fromisoformat(value).date()
+
+                setattr(translation, column.name, value)
+
+        return translation
+
+    def _should_cache(self, value: TranslationCache) -> bool:
+        """Validate if the translation should be cached"""
+        return value is not None and value.cache_key is not None
+
+    def get_translation(self, text: str, target_lang: str, source_lang:str=None, context: str=None) -> Optional[TranslationCache]:
+        """
+        Get the translation for a text in a specific language
+
+        Args:
+            text: The text to be translated
+            target_lang: The target language for the translation
+            source_lang: The source language of the text to be translated
+            context: Optional context for the translation
+
+        Returns:
+            TranslationCache instance if found, None otherwise
+        """
+
+        def creator_func(text: str, target_lang: str, source_lang: str=None, context: str=None) -> Optional[TranslationCache]:
+            # Generate cache key based on inputs
+            cache_key = self._generate_cache_key(text, target_lang, source_lang, context)
+
+            # Check if translation already exists in database
+            existing_translation = db.session.query(TranslationCache).filter_by(cache_key=cache_key).first()
+
+            if existing_translation:
+                # Update last used timestamp
+                existing_translation.last_used_at = dt.now(tz=tz.utc)
+                db.session.commit()
+                return existing_translation
+
+            # Translation not found in DB, need to create it
+            # Initialize translation service
+            translation_service = TranslationService(getattr(current_app, 'tenant_id', None))
+
+            # Get the translation and metrics
+            translated_text, metrics = translation_service.translate_text(
+                text_to_translate=text,
+                target_lang=target_lang,
+                source_lang=source_lang,
+                context=context
+            )
+
+            # Create new translation cache record
+            new_translation = TranslationCache(
+                cache_key=cache_key,
+                source_text=text,
+                translated_text=translated_text,
+                source_language=source_lang or 'auto',
+                target_language=target_lang,
+                context=context,
+                prompt_tokens=metrics.get('prompt_tokens', 0),
+                completion_tokens=metrics.get('completion_tokens', 0),
+                created_at=dt.now(tz=tz.utc),
+                created_by=getattr(current_user, 'id', None) if 'current_user' in globals() else None,
+                updated_at=dt.now(tz=tz.utc),
+                updated_by=getattr(current_user, 'id', None) if 'current_user' in globals() else None,
+                last_used_at=dt.now(tz=tz.utc)
+            )
+
+            # Save to database
+            db.session.add(new_translation)
+            db.session.commit()
+
+            return new_translation
+
+        return self.get(creator_func, text=text, target_lang=target_lang, source_lang=source_lang, context=context)
+
+    def invalidate_tenant_translations(self, tenant_id: int):
+        """Invalidate cached translations for specific tenant"""
+        self.invalidate(tenant_id=tenant_id)
+
+    def _generate_cache_key(self, text: str, target_lang: str, source_lang: str = None, context: str = None) -> str:
+        """Generate cache key for a translation"""
+        cache_data = {
+            "text": text.strip(),
+            "target_lang": target_lang.lower(),
+            "source_lang": source_lang.lower() if source_lang else None,
+            "context": context.strip() if context else None,
+        }
+
+        cache_string = json.dumps(cache_data, sort_keys=True, ensure_ascii=False)
+        return xxhash.xxh64(cache_string.encode('utf-8')).hexdigest()
+
+def register_translation_cache_handlers(cache_manager) -> None:
+    """Register translation cache handlers with cache manager"""
+    cache_manager.register_handler(
+        TranslationCacheHandler,
+        'eveai_model'  # Use existing eveai_model region
+    )

common/utils/chat_utils.py

@@ -0,0 +1,60 @@
+import json
+
+"""
+Utility functions for chat customization.
+"""
+from flask import current_app
+
+
+def get_default_chat_customisation(tenant_customisation=None):
+    """
+    Get chat customization options with default values for missing options.
+
+    Args:
+        tenant_customisation (dict or str, optional): The tenant's customization options.
+            Defaults to None. Can be a dict or a JSON string.
+
+    Returns:
+        dict: A dictionary containing all customization options with default values
+            for any missing options.
+    """
+    # Default customization options
+    default_customisation = {
+        'primary_color': '#007bff',
+        'secondary_color': '#6c757d',
+        'background_color': '#ffffff',
+        'text_color': '#212529',
+        'sidebar_color': '#f8f9fa',
+        'sidebar_background': '#2c3e50',
+        'gradient_start_color': '#f5f7fa',
+        'gradient_end_color': '#c3cfe2',
+        'markdown_background_color': 'transparent',
+        'markdown_text_color': '#ffffff',
+        'sidebar_markdown': '',
+        'welcome_message': 'Hello! How can I help you today?',
+    }
+
+    # If no tenant customization is provided, return the defaults
+    if tenant_customisation is None:
+        return default_customisation
+
+    # Start with the default customization
+    customisation = default_customisation.copy()
+
+    # Convert JSON string to dict if needed
+    if isinstance(tenant_customisation, str):
+        try:
+            tenant_customisation = json.loads(tenant_customisation)
+            current_app.logger.debug(f"Converted JSON string to dict: {tenant_customisation}")
+        except json.JSONDecodeError as e:
+            current_app.logger.error(f"Error parsing JSON customisation: {e}")
+            return default_customisation
+
+    # Update with tenant customization
+    current_app.logger.debug(f"Tenant customisation - in default creation: {tenant_customisation}")
+    if tenant_customisation:
+        for key, value in tenant_customisation.items():
+            if key in customisation:
+                customisation[key] = value
+
+    return customisation

common/utils/config_field_types.py

@@ -21,7 +21,7 @@ class TaggingField(BaseModel):
     @field_validator('type', mode='before')
     @classmethod
     def validate_type(cls, v: str) -> str:
-        valid_types = ['string', 'integer', 'float', 'date', 'enum']
+        valid_types = ['string', 'integer', 'float', 'date', 'enum', 'color']
         if v not in valid_types:
             raise ValueError(f'type must be one of {valid_types}')
         return v
@@ -243,7 +243,7 @@ class ArgumentDefinition(BaseModel):
     @field_validator('type')
     @classmethod
     def validate_type(cls, v: str) -> str:
-        valid_types = ['string', 'integer', 'float', 'date', 'enum']
+        valid_types = ['string', 'integer', 'float', 'date', 'enum', 'color']
         if v not in valid_types:
             raise ValueError(f'type must be one of {valid_types}')
         return v
@@ -256,7 +256,8 @@ class ArgumentDefinition(BaseModel):
                 'integer': NumericConstraint,
                 'float': NumericConstraint,
                 'date': DateConstraint,
-                'enum': EnumConstraint
+                'enum': EnumConstraint,
+                'color': StringConstraint
             }
 
             expected_type = expected_constraint_types.get(self.type)

common/utils/content_utils.py

@@ -0,0 +1,215 @@
+import os
+import re
+import logging
+from packaging import version
+from flask import current_app
+
+logger = logging.getLogger(__name__)
+
+class ContentManager:
+    def __init__(self, app=None):
+        self.app = app
+        if app:
+            self.init_app(app)
+
+    def init_app(self, app):
+        self.app = app
+
+        # Controleer of het pad bestaat
+        if not os.path.exists(app.config['CONTENT_DIR']):
+            logger.warning(f"Content directory not found at: {app.config['CONTENT_DIR']}")
+        else:
+            logger.info(f"Content directory configured at: {app.config['CONTENT_DIR']}")
+
+    def get_content_path(self, content_type, major_minor=None, patch=None):
+        """
+        Geef het volledige pad naar een contentbestand
+
+        Args:
+            content_type (str): Type content (bv. 'changelog', 'terms')
+            major_minor (str, optional): Major.Minor versie (bv. '1.0')
+            patch (str, optional): Patchnummer (bv. '5')
+
+        Returns:
+            str: Volledige pad naar de content map of bestand
+        """
+        content_path = os.path.join(self.app.config['CONTENT_DIR'], content_type)
+
+        if major_minor:
+            content_path = os.path.join(content_path, major_minor)
+
+            if patch:
+                content_path = os.path.join(content_path, f"{major_minor}.{patch}.md")
+
+        return content_path
+
+    def _parse_version(self, filename):
+        """Parse een versienummer uit een bestandsnaam"""
+        match = re.match(r'(\d+\.\d+)\.(\d+)\.md', filename)
+        if match:
+            return match.group(1), match.group(2)
+        return None, None
+
+    def get_latest_version(self, content_type, major_minor=None):
+        """
+        Verkrijg de laatste versie van een bepaald contenttype
+
+        Args:
+            content_type (str): Type content (bv. 'changelog', 'terms')
+            major_minor (str, optional): Specifieke major.minor versie, anders de hoogste
+
+        Returns:
+            tuple: (major_minor, patch, full_version) of None als niet gevonden
+        """
+        try:
+            # Basispad voor dit contenttype
+            content_path = os.path.join(self.app.config['CONTENT_DIR'], content_type)
+
+            if not os.path.exists(content_path):
+                logger.error(f"Content path does not exist: {content_path}")
+                return None
+
+            # Als geen major_minor opgegeven, vind de hoogste
+            if not major_minor:
+                available_versions = os.listdir(content_path)
+                if not available_versions:
+                    return None
+
+                # Sorteer op versienummer (major.minor)
+                available_versions.sort(key=lambda v: version.parse(v))
+                major_minor = available_versions[-1]
+
+            # Nu we major_minor hebben, zoek de hoogste patch
+            major_minor_path = os.path.join(content_path, major_minor)
+
+            if not os.path.exists(major_minor_path):
+                logger.error(f"Version path does not exist: {major_minor_path}")
+                return None
+
+            files = os.listdir(major_minor_path)
+            version_files = []
+
+            for file in files:
+                mm, p = self._parse_version(file)
+                if mm == major_minor and p:
+                    version_files.append((mm, p, f"{mm}.{p}"))
+
+            if not version_files:
+                return None
+
+            # Sorteer op patch nummer
+            version_files.sort(key=lambda v: int(v[1]))
+            return version_files[-1]
+
+        except Exception as e:
+            logger.error(f"Error finding latest version for {content_type}: {str(e)}")
+            return None
+
+    def read_content(self, content_type, major_minor=None, patch=None):
+        """
+        Lees content met versieondersteuning
+
+        Als major_minor en patch niet zijn opgegeven, wordt de laatste versie gebruikt.
+        Als alleen major_minor is opgegeven, wordt de laatste patch van die versie gebruikt.
+
+        Args:
+            content_type (str): Type content (bv. 'changelog', 'terms')
+            major_minor (str, optional): Major.Minor versie (bv. '1.0')
+            patch (str, optional): Patchnummer (bv. '5')
+
+        Returns:
+            dict: {
+                'content': str,
+                'version': str,
+                'content_type': str
+            } of None bij fout
+        """
+        try:
+            # Als geen versie opgegeven, vind de laatste
+            if not major_minor:
+                version_info = self.get_latest_version(content_type)
+                if not version_info:
+                    logger.error(f"No versions found for {content_type}")
+                    return None
+
+                major_minor, patch, full_version = version_info
+
+            # Als geen patch opgegeven, vind de laatste patch voor deze major_minor
+            elif not patch:
+                version_info = self.get_latest_version(content_type, major_minor)
+                if not version_info:
+                    logger.error(f"No versions found for {content_type} {major_minor}")
+                    return None
+
+                major_minor, patch, full_version = version_info
+            else:
+                full_version = f"{major_minor}.{patch}"
+
+            # Nu hebben we major_minor en patch, lees het bestand
+            file_path = self.get_content_path(content_type, major_minor, patch)
+
+            if not os.path.exists(file_path):
+                logger.error(f"Content file does not exist: {file_path}")
+                return None
+
+            with open(file_path, 'r', encoding='utf-8') as file:
+                content = file.read()
+
+            return {
+                'content': content,
+                'version': full_version,
+                'content_type': content_type
+            }
+
+        except Exception as e:
+            logger.error(f"Error reading content {content_type} {major_minor}.{patch}: {str(e)}")
+            return None
+
+    def list_content_types(self):
+        """Lijst alle beschikbare contenttypes op"""
+        try:
+            return [d for d in os.listdir(self.app.config['CONTENT_DIR']) 
+                   if os.path.isdir(os.path.join(self.app.config['CONTENT_DIR'], d))]
+        except Exception as e:
+            logger.error(f"Error listing content types: {str(e)}")
+            return []
+
+    def list_versions(self, content_type):
+        """
+        Lijst alle beschikbare versies voor een contenttype
+
+        Returns:
+            list: Lijst van dicts met versie-informatie
+                  [{'version': '1.0.0', 'path': '/path/to/file', 'date_modified': datetime}]
+        """
+        versions = []
+        try:
+            content_path = os.path.join(self.app.config['CONTENT_DIR'], content_type)
+
+            if not os.path.exists(content_path):
+                return []
+
+            for major_minor in os.listdir(content_path):
+                major_minor_path = os.path.join(content_path, major_minor)
+
+                if not os.path.isdir(major_minor_path):
+                    continue
+
+                for file in os.listdir(major_minor_path):
+                    mm, p = self._parse_version(file)
+                    if mm and p:
+                        file_path = os.path.join(major_minor_path, file)
+                        mod_time = os.path.getmtime(file_path)
+                        versions.append({
+                            'version': f"{mm}.{p}",
+                            'path': file_path,
+                            'date_modified': mod_time
+                        })
+
+            # Sorteer op versienummer
+            versions.sort(key=lambda v: version.parse(v['version']))
+            return versions
+
+        except Exception as e:
+            logger.error(f"Error listing versions for {content_type}: {str(e)}")
+            return []

common/utils/document_utils.py

@@ -3,7 +3,7 @@ from datetime import datetime as dt, timezone as tz
 from sqlalchemy import desc
 from sqlalchemy.exc import SQLAlchemyError
 from werkzeug.utils import secure_filename
-from common.models.document import Document, DocumentVersion, Catalog
+from common.models.document import Document, DocumentVersion, Catalog, Processor
 from common.extensions import db, minio_client
 from common.utils.celery_utils import current_celery
 from flask import current_app
@@ -11,6 +11,7 @@ import requests
 from urllib.parse import urlparse, unquote, urlunparse, parse_qs
 import os
 
+from config.type_defs.processor_types import PROCESSOR_TYPES
 from .config_field_types import normalize_json_field
 from .eveai_exceptions import (EveAIInvalidLanguageException, EveAIDoubleURLException, EveAIUnsupportedFileType,
                                EveAIInvalidCatalog, EveAIInvalidDocument, EveAIInvalidDocumentVersion, EveAIException)
@@ -469,3 +470,15 @@ def lookup_document(tenant_id: int, lookup_criteria: dict, metadata_type: str) -
             "Error during document lookup",
             status_code=500
         )
+
+def is_file_type_supported_by_catalog(catalog_id, file_type):
+    processors = Processor.query.filter_by(catalog_id=catalog_id).filter_by(active=True).all()
+
+    supported_file_types = []
+    for processor in processors:
+        processor_file_types = PROCESSOR_TYPES[processor.type]['file_types']
+        file_types = [f.strip() for f in processor_file_types.split(",")]
+        supported_file_types.extend(file_types)
+
+    if file_type not in supported_file_types:
+        raise EveAIUnsupportedFileType()

common/utils/dynamic_field_utils.py

@@ -38,6 +38,8 @@ def create_default_config_from_type_config(type_config):
                 default_config[field_name] = 0
             elif field_type == "boolean":
                 default_config[field_name] = False
+            elif field_type == "color":
+                default_config[field_name] = "#000000"
             else:
                 default_config[field_name] = ""
 

common/utils/errors.py

@@ -1,3 +1,4 @@
+
 import traceback
 
 import jinja2
@@ -12,6 +13,7 @@ def not_found_error(error):
     if not current_user.is_authenticated:
         return redirect(prefixed_url_for('security.login'))
     current_app.logger.error(f"Not Found Error: {error}")
+    current_app.logger.error(traceback.format_exc())
     return render_template('error/404.html'), 404
 
 
@@ -19,6 +21,7 @@ def internal_server_error(error):
     if not current_user.is_authenticated:
         return redirect(prefixed_url_for('security.login'))
     current_app.logger.error(f"Internal Server Error: {error}")
+    current_app.logger.error(traceback.format_exc())
     return render_template('error/500.html'), 500
 
 
@@ -26,6 +29,7 @@ def not_authorised_error(error):
     if not current_user.is_authenticated:
         return redirect(prefixed_url_for('security.login'))
     current_app.logger.error(f"Not Authorised Error: {error}")
+    current_app.logger.error(traceback.format_exc())
     return render_template('error/401.html')
 
 
@@ -33,6 +37,7 @@ def access_forbidden(error):
     if not current_user.is_authenticated:
         return redirect(prefixed_url_for('security.login'))
     current_app.logger.error(f"Access Forbidden: {error}")
+    current_app.logger.error(traceback.format_exc())
     return render_template('error/403.html')
 
 
@@ -42,6 +47,7 @@ def key_error_handler(error):
         return redirect(prefixed_url_for('security.login'))
     # For other KeyErrors, you might want to log the error and return a generic error page
     current_app.logger.error(f"Key Error: {error}")
+    current_app.logger.error(traceback.format_exc())
     return render_template('error/generic.html', error_message="An unexpected error occurred"), 500
 
 
@@ -76,6 +82,7 @@ def no_tenant_selected_error(error):
     a long period of inactivity. The user will be redirected to the login page.
     """
     current_app.logger.error(f"No Session Tenant Error: {error}")
+    current_app.logger.error(traceback.format_exc())
     flash('Your session expired. You will have to re-enter your credentials', 'warning')
 
     # Perform logout if user is authenticated
@@ -95,6 +102,26 @@ def general_exception(e):
                            error_details=str(e)), 500
 
 
+def template_not_found_error(error):
+    """Handle Jinja2 TemplateNotFound exceptions."""
+    current_app.logger.error(f'Template not found: {error.name}')
+    current_app.logger.error(f'Search Paths: {current_app.jinja_loader.list_templates()}')
+    current_app.logger.error(traceback.format_exc())
+    return render_template('error/500.html',
+                          error_type="Template Not Found",
+                          error_details=f"Template '{error.name}' could not be found."), 404
+
+
+def template_syntax_error(error):
+    """Handle Jinja2 TemplateSyntaxError exceptions."""
+    current_app.logger.error(f'Template syntax error: {error.message}')
+    current_app.logger.error(f'In template {error.filename}, line {error.lineno}')
+    current_app.logger.error(traceback.format_exc())
+    return render_template('error/500.html',
+                          error_type="Template Syntax Error",
+                          error_details=f"Error in template '{error.filename}' at line {error.lineno}: {error.message}"), 500
+
+
 def register_error_handlers(app):
     app.register_error_handler(404, not_found_error)
     app.register_error_handler(500, internal_server_error)
@@ -103,17 +130,6 @@ def register_error_handlers(app):
     app.register_error_handler(EveAINoSessionTenant, no_tenant_selected_error)
     app.register_error_handler(KeyError, key_error_handler)
     app.register_error_handler(AttributeError, attribute_error_handler)
-    app.register_error_handler(Exception, general_exception)
-
-    @app.errorhandler(jinja2.TemplateNotFound)
-    def template_not_found(error):
-        app.logger.error(f'Template not found: {error.name}')
-        app.logger.error(f'Search Paths: {app.jinja_loader.list_templates()}')
-        return f'Template not found: {error.name}. Check logs for details.', 404
-
-    @app.errorhandler(jinja2.TemplateSyntaxError)
-    def template_syntax_error(error):
-        app.logger.error(f'Template syntax error: {error.message}')
-        app.logger.error(f'In template {error.filename}, line {error.lineno}')
-        return f'Template syntax error: {error.message}', 500
-
+    app.register_error_handler(jinja2.TemplateNotFound, template_not_found_error)
+    app.register_error_handler(jinja2.TemplateSyntaxError, template_syntax_error)
+    app.register_error_handler(Exception, general_exception)

common/utils/eveai_exceptions.py

@@ -34,7 +34,25 @@ class EveAIDoubleURLException(EveAIException):
 class EveAIUnsupportedFileType(EveAIException):
     """Raised when an invalid file type is provided"""
 
-    def __init__(self, message="Filetype is not supported", status_code=400, payload=None):
+    def __init__(self, message="Filetype is not supported by current active processors", status_code=400, payload=None):
+        super().__init__(message, status_code, payload)
+
+
+class EveAINoProcessorFound(EveAIException):
+    """Raised when no processor is found for a given file type"""
+
+    def __init__(self, catalog_id, file_type, file_subtype, status_code=400, payload=None):
+        message = f"No active processor found for catalog {catalog_id} with file type {file_type} and subtype {file_subtype}"
+        super().__init__(message, status_code, payload)
+
+
+class EveAINoContentFound(EveAIException):
+    """Raised when no content is found for a given document"""
+
+    def __init__(self, document_id, document_version_id, status_code=400, payload=None):
+        self.document_id = document_id
+        self.document_version_id = document_version_id
+        message = f"No content found while processing Document with ID {document_id} and version {document_version_id}."
         super().__init__(message, status_code, payload)
 
 
@@ -248,3 +266,14 @@ class EveAIPendingLicensePeriod(EveAIException):
         message = f"Basic Fee Payment has not been received yet. Please ensure payment has been made, and please wait for payment to be processed."
         super().__init__(message, status_code, payload)
 
+
+class EveAISpecialistExecutionError(EveAIException):
+    """Raised when an error occurs during specialist execution"""
+
+    def __init__(self, tenant_id, specialist_id, session_id, details, status_code=400, payload=None):
+        message = (f"Error during specialist {specialist_id} execution \n"
+                   f"with Session ID {session_id} \n"
+                   f"for Tenant {tenant_id}. \n"
+                   f"Details: {details} \n"
+                   f"The System Administrator has been notified. Please try again later.")
+        super().__init__(message, status_code, payload)

common/utils/specialist_utils.py

@@ -1,196 +0,0 @@
-from datetime import datetime as dt, timezone as tz
-from typing import Optional, Dict, Any
-from flask import current_app
-from sqlalchemy.exc import SQLAlchemyError
-
-from common.extensions import db, cache_manager
-from common.models.interaction import (
-    Specialist, EveAIAgent, EveAITask, EveAITool
-)
-from common.utils.model_logging_utils import set_logging_information, update_logging_information
-
-
-def initialize_specialist(specialist_id: int, specialist_type: str, specialist_version: str):
-    """
-    Initialize an agentic specialist by creating all its components based on configuration.
-
-    Args:
-        specialist_id: ID of the specialist to initialize
-        specialist_type: Type of the specialist
-        specialist_version: Version of the specialist type to use
-
-    Raises:
-        ValueError: If specialist not found or invalid configuration
-        SQLAlchemyError: If database operations fail
-    """
-    config = cache_manager.specialists_config_cache.get_config(specialist_type, specialist_version)
-    if not config:
-        raise ValueError(f"No configuration found for {specialist_type} version {specialist_version}")
-    if config['framework'] == 'langchain':
-        pass    # Langchain does not require additional items to be initialized. All configuration is in the specialist.
-
-    specialist = Specialist.query.get(specialist_id)
-    if not specialist:
-        raise ValueError(f"Specialist with ID {specialist_id} not found")
-
-    if config['framework'] == 'crewai':
-        initialize_crewai_specialist(specialist, config)
-
-
-def initialize_crewai_specialist(specialist: Specialist, config: Dict[str, Any]):
-    timestamp = dt.now(tz=tz.utc)
-
-    try:
-        # Initialize agents
-        if 'agents' in config:
-            for agent_config in config['agents']:
-                _create_agent(
-                    specialist_id=specialist.id,
-                    agent_type=agent_config['type'],
-                    agent_version=agent_config['version'],
-                    name=agent_config.get('name'),
-                    description=agent_config.get('description'),
-                    timestamp=timestamp
-                )
-
-        # Initialize tasks
-        if 'tasks' in config:
-            for task_config in config['tasks']:
-                _create_task(
-                    specialist_id=specialist.id,
-                    task_type=task_config['type'],
-                    task_version=task_config['version'],
-                    name=task_config.get('name'),
-                    description=task_config.get('description'),
-                    timestamp=timestamp
-                )
-
-        # Initialize tools
-        if 'tools' in config:
-            for tool_config in config['tools']:
-                _create_tool(
-                    specialist_id=specialist.id,
-                    tool_type=tool_config['type'],
-                    tool_version=tool_config['version'],
-                    name=tool_config.get('name'),
-                    description=tool_config.get('description'),
-                    timestamp=timestamp
-                )
-
-        db.session.commit()
-        current_app.logger.info(f"Successfully initialized crewai specialist {specialist.id}")
-
-    except SQLAlchemyError as e:
-        db.session.rollback()
-        current_app.logger.error(f"Database error initializing crewai specialist {specialist.id}: {str(e)}")
-        raise
-    except Exception as e:
-        db.session.rollback()
-        current_app.logger.error(f"Error initializing crewai specialist {specialist.id}: {str(e)}")
-        raise
-
-
-def _create_agent(
-        specialist_id: int,
-        agent_type: str,
-        agent_version: str,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        timestamp: Optional[dt] = None
-) -> EveAIAgent:
-    """Create an agent with the given configuration."""
-    if timestamp is None:
-        timestamp = dt.now(tz=tz.utc)
-
-    # Get agent configuration from cache
-    agent_config = cache_manager.agents_config_cache.get_config(agent_type, agent_version)
-
-    agent = EveAIAgent(
-        specialist_id=specialist_id,
-        name=name or agent_config.get('name', agent_type),
-        description=description or agent_config.get('metadata').get('description', ''),
-        type=agent_type,
-        type_version=agent_version,
-        role=None,
-        goal=None,
-        backstory=None,
-        tuning=False,
-        configuration=None,
-        arguments=None
-    )
-
-    set_logging_information(agent, timestamp)
-
-    db.session.add(agent)
-    current_app.logger.info(f"Created agent {agent.id} of type {agent_type}")
-    return agent
-
-
-def _create_task(
-        specialist_id: int,
-        task_type: str,
-        task_version: str,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        timestamp: Optional[dt] = None
-) -> EveAITask:
-    """Create a task with the given configuration."""
-    if timestamp is None:
-        timestamp = dt.now(tz=tz.utc)
-
-    # Get task configuration from cache
-    task_config = cache_manager.tasks_config_cache.get_config(task_type, task_version)
-
-    task = EveAITask(
-        specialist_id=specialist_id,
-        name=name or task_config.get('name', task_type),
-        description=description or task_config.get('metadata').get('description', ''),
-        type=task_type,
-        type_version=task_version,
-        task_description=None,
-        expected_output=None,
-        tuning=False,
-        configuration=None,
-        arguments=None,
-        context=None,
-        asynchronous=False,
-    )
-
-    set_logging_information(task, timestamp)
-
-    db.session.add(task)
-    current_app.logger.info(f"Created task {task.id} of type {task_type}")
-    return task
-
-
-def _create_tool(
-        specialist_id: int,
-        tool_type: str,
-        tool_version: str,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        timestamp: Optional[dt] = None
-) -> EveAITool:
-    """Create a tool with the given configuration."""
-    if timestamp is None:
-        timestamp = dt.now(tz=tz.utc)
-
-    # Get tool configuration from cache
-    tool_config = cache_manager.tools_config_cache.get_config(tool_type, tool_version)
-
-    tool = EveAITool(
-        specialist_id=specialist_id,
-        name=name or tool_config.get('name', tool_type),
-        description=description or tool_config.get('metadata').get('description', ''),
-        type=tool_type,
-        type_version=tool_version,
-        tuning=False,
-        configuration=None,
-        arguments=None,
-    )
-
-    set_logging_information(tool, timestamp)
-
-    db.session.add(tool)
-    current_app.logger.info(f"Created tool {tool.id} of type {tool_type}")
-    return tool

config/agents/traicie/TRAICIE_RECRUITER_AGENT/1.0.0.yaml

@@ -0,0 +1,25 @@
+version: "1.0.0"
+name: "Traicie Recruiter"
+role: >
+  You are an Expert Recruiter working for {tenant_name}
+  {custom_role}
+goal: >
+  As an expert recruiter, you identify, attract, and secure top talent by building genuine relationships, deeply 
+  understanding business needs, and ensuring optimal alignment between candidate potential and organizational goals
+  , while championing diversity, culture fit, and long-term retention.
+  {custom_goal}
+backstory: >
+  You started your career in a high-pressure agency setting, where you quickly learned the art of fast-paced hiring and 
+  relationship building. Over the years, you moved in-house, partnering closely with business leaders to shape 
+  recruitment strategies that go beyond filling roles—you focus on finding the right people to drive growth and culture.
+  With a strong grasp of both tech and non-tech profiles, you’ve adapted to changing trends, from remote work to 
+  AI-driven sourcing. You’re more than a recruiter—you’re a trusted advisor, a brand ambassador, and a connector of 
+  people and purpose.
+  {custom_backstory}
+full_model_name: "mistral.magistral-medium-latest"
+temperature: 0.3
+metadata:
+  author: "Josako"
+  date_added: "2025-06-18"
+  description: "Traicie Recruiter Agent"
+  changes: "Initial version"

config/catalogs/globals/DOSSIER_CATALOG/1.0.0.yaml

@@ -0,0 +1,21 @@
+version: "1.0.0"
+name: "Dossier Catalog"
+description: "A Catalog with information in Evie's Library in which several Dossiers can be stored"
+configuration:
+  tagging_fields:
+    name: "Tagging Fields"
+    type: "tagging_fields"
+    description: "Define the metadata fields that will be used for tagging documents.
+                Each field must have:
+                - type: one of 'string', 'integer', 'float', 'date', 'enum'
+                - required: boolean indicating if the field is mandatory
+                - description: field description
+                - allowed_values: list of values (for enum type only)
+                - min_value/max_value: range limits (for numeric types only)"
+    required: true
+    default: {}
+document_version_configurations: ["tagging_fields"]
+metadata:
+  author: "System"
+  date_added: "2023-01-01"
+  description: "A Catalog with information in Evie's Library in which several Dossiers can be stored"

config/catalogs/globals/STANDARD_CATALOG/1.0.0.yaml

@@ -0,0 +1,9 @@
+version: "1.0.0"
+name: "Standard Catalog"
+description: "A Catalog with information in Evie's Library, to be considered as a whole"
+configuration: {}
+document_version_configurations: []
+metadata:
+  author: "System"
+  date_added: "2023-01-01"
+  description: "A Catalog with information in Evie's Library, to be considered as a whole"

config/config.py

@@ -12,10 +12,7 @@ class Config(object):
     DEBUG = False
     DEVELOPMENT = False
     SECRET_KEY = environ.get('SECRET_KEY')
-    SESSION_COOKIE_SECURE = False
-    SESSION_COOKIE_HTTPONLY = True
     COMPONENT_NAME = environ.get('COMPONENT_NAME')
-    SESSION_KEY_PREFIX = f'{COMPONENT_NAME}_'
 
     # Database Settings
     DB_HOST = environ.get('DB_HOST')
@@ -44,8 +41,6 @@ class Config(object):
     # SECURITY_POST_CHANGE_VIEW = '/admin/login'
     # SECURITY_BLUEPRINT_NAME = 'security_bp'
     SECURITY_PASSWORD_SALT = environ.get('SECURITY_PASSWORD_SALT')
-    REMEMBER_COOKIE_SAMESITE = 'strict'
-    SESSION_COOKIE_SAMESITE = 'Lax'
     SECURITY_CONFIRMABLE = True
     SECURITY_TRACKABLE = True
     SECURITY_PASSWORD_COMPLEXITY_CHECKER = 'zxcvbn'
@@ -56,6 +51,10 @@ class Config(object):
     SECURITY_EMAIL_SUBJECT_PASSWORD_NOTICE = 'Your Password Has Been Reset'
     SECURITY_EMAIL_PLAINTEXT = False
     SECURITY_EMAIL_HTML = True
+    SECURITY_SESSION_PROTECTION = 'basic'  # of 'basic' als 'strong' problemen geeft
+    SECURITY_REMEMBER_TOKEN_VALIDITY = timedelta(minutes=60)  # Zelfde als session lifetime
+    SECURITY_AUTO_LOGIN_AFTER_CONFIRM = True
+    SECURITY_AUTO_LOGIN_AFTER_RESET = True
 
     # Ensure Flask-Security-Too is handling CSRF tokens when behind a proxy
     SECURITY_CSRF_PROTECT_MECHANISMS = ['session']
@@ -67,7 +66,89 @@ class Config(object):
     MAX_CONTENT_LENGTH = 50 * 1024 * 1024
 
     # supported languages
-    SUPPORTED_LANGUAGES = ['en', 'fr', 'nl', 'de', 'es']
+    SUPPORTED_LANGUAGES = ['en', 'fr', 'nl', 'de', 'es', 'it', 'pt', 'ru', 'zh', 'ja', 'ko', 'ar', 'hi']
+    SUPPORTED_LANGUAGE_DETAILS = {
+        "English": {
+            "iso 639-1": "en",
+            "iso 639-2": "eng",
+            "iso 639-3": "eng",
+            "flag": "🇬🇧"
+        },
+        "French": {
+            "iso 639-1": "fr",
+            "iso 639-2": "fre",  # of 'fra'
+            "iso 639-3": "fra",
+            "flag": "🇫🇷"
+        },
+        "German": {
+            "iso 639-1": "de",
+            "iso 639-2": "ger",  # of 'deu'
+            "iso 639-3": "deu",
+            "flag": "🇩🇪"
+        },
+        "Spanish": {
+            "iso 639-1": "es",
+            "iso 639-2": "spa",
+            "iso 639-3": "spa",
+            "flag": "🇪🇸"
+        },
+        "Italian": {
+            "iso 639-1": "it",
+            "iso 639-2": "ita",
+            "iso 639-3": "ita",
+            "flag": "🇮🇹"
+        },
+        "Portuguese": {
+            "iso 639-1": "pt",
+            "iso 639-2": "por",
+            "iso 639-3": "por",
+            "flag": "🇵🇹"
+        },
+        "Dutch": {
+            "iso 639-1": "nl",
+            "iso 639-2": "dut",  # of 'nld'
+            "iso 639-3": "nld",
+            "flag": "🇳🇱"
+        },
+        "Russian": {
+            "iso 639-1": "ru",
+            "iso 639-2": "rus",
+            "iso 639-3": "rus",
+            "flag": "🇷🇺"
+        },
+        "Chinese": {
+            "iso 639-1": "zh",
+            "iso 639-2": "chi",  # of 'zho'
+            "iso 639-3": "zho",
+            "flag": "🇨🇳"
+        },
+        "Japanese": {
+            "iso 639-1": "ja",
+            "iso 639-2": "jpn",
+            "iso 639-3": "jpn",
+            "flag": "🇯🇵"
+        },
+        "Korean": {
+            "iso 639-1": "ko",
+            "iso 639-2": "kor",
+            "iso 639-3": "kor",
+            "flag": "🇰🇷"
+        },
+        "Arabic": {
+            "iso 639-1": "ar",
+            "iso 639-2": "ara",
+            "iso 639-3": "ara",
+            "flag": "🇸🇦"
+        },
+        "Hindi": {
+            "iso 639-1": "hi",
+            "iso 639-2": "hin",
+            "iso 639-3": "hin",
+            "flag": "🇮🇳"
+        },
+    }
+
+    SUPPORTED_LANGUAGES_FULL = list(SUPPORTED_LANGUAGE_DETAILS.keys())
 
     # supported currencies
     SUPPORTED_CURRENCIES = ['€', '$']
@@ -75,10 +156,7 @@ class Config(object):
     # supported LLMs
     # SUPPORTED_EMBEDDINGS = ['openai.text-embedding-3-small', 'openai.text-embedding-3-large', 'mistral.mistral-embed']
     SUPPORTED_EMBEDDINGS = ['mistral.mistral-embed']
-    SUPPORTED_LLMS = ['openai.gpt-4o', 'openai.gpt-4o-mini',
-                      'mistral.mistral-large-latest', 'mistral.mistral-medium_latest', 'mistral.mistral-small-latest']
-
-    ANTHROPIC_LLM_VERSIONS = {'claude-3-5-sonnet': 'claude-3-5-sonnet-20240620', }
+    SUPPORTED_LLMS = ['mistral.mistral-large-latest', 'mistral.mistral-medium_latest', 'mistral.mistral-small-latest']
 
     # Annotation text chunk length
     ANNOTATION_TEXT_CHUNK_LENGTH = 10000
@@ -107,6 +185,15 @@ class Config(object):
     PERMANENT_SESSION_LIFETIME = timedelta(minutes=60)
     SESSION_REFRESH_EACH_REQUEST = True
 
+    SESSION_COOKIE_NAME = f'{COMPONENT_NAME}_session'
+    SESSION_COOKIE_DOMAIN = None  # Laat Flask dit automatisch bepalen
+    SESSION_COOKIE_PATH = '/'
+    SESSION_COOKIE_HTTPONLY = True
+    SESSION_COOKIE_SECURE = False  # True voor production met HTTPS
+    SESSION_COOKIE_SAMESITE = 'Lax'
+    REMEMBER_COOKIE_SAMESITE = 'strict'
+    SESSION_KEY_PREFIX = f'{COMPONENT_NAME}_'
+
     # JWT settings
     JWT_SECRET_KEY = environ.get('JWT_SECRET_KEY')
     JWT_ACCESS_TOKEN_EXPIRES = timedelta(hours=1)  # Set token expiry to 1 hour
@@ -172,6 +259,9 @@ class Config(object):
     # Entitlement Constants
     ENTITLEMENTS_MAX_PENDING_DAYS = 5        # Defines the maximum number of days a pending entitlement can be active
 
+    # Content Directory for static content like the changelog, terms & conditions, privacy statement, ...
+    CONTENT_DIR = '/app/content'
+
 
 class DevConfig(Config):
     DEVELOPMENT = True
@@ -182,6 +272,7 @@ class DevConfig(Config):
     # Define the nginx prefix used for the specific apps
     EVEAI_APP_LOCATION_PREFIX = '/admin'
     EVEAI_CHAT_LOCATION_PREFIX = '/chat'
+    CHAT_CLIENT_PREFIX = 'chat-client/chat/'
 
     # file upload settings
     # UPLOAD_FOLDER = '/app/tenant_files'

config/customisations/globals/CHAT_CLIENT_CUSTOMISATION/1.0.0.yaml

@@ -0,0 +1,63 @@
+version: "1.0.0"
+name: "Chat Client Customisation"
+configuration:
+  "primary_color":
+    name: "Primary Color"
+    description: "Primary Color"
+    type: "color"
+    required: false
+  "secondary_color":
+    name: "Secondary Color"
+    description: "Secondary Color"
+    type: "color"
+    required: false
+  "background_color":
+    name: "Background Color"
+    description: "Background Color"
+    type: "color"
+    required: false
+  "text_color":
+    name: "Text Color"
+    description: "Text Color"
+    type: "color"
+    required: false
+  "sidebar_color":
+    name: "Sidebar Color"
+    description: "Sidebar Color"
+    type: "color"
+    required: false
+  "sidebar_background":
+    name: "Sidebar Background"
+    description: "Sidebar Background Color"
+    type: "color"
+    required: false
+  "markdown_background_color":
+    name: "Markdown Background"
+    description: "Markdown Background Color"
+    type: "color"
+    required: false
+  "markdown_text_color":
+    name: "Markdown Text"
+    description: "Markdown Text Color"
+    type: "color"
+    required: false
+  "gradient_start_color":
+    name: "Gradient Start Color"
+    description: "Start Color for the gradient in the Chat Area"
+    type: "color"
+    required: false
+  "gradient_end_color":
+    name: "Gradient End Color"
+    description: "End Color for the gradient in the Chat Area"
+    type: "color"
+    required: false
+  "sidebar_markdown":
+    name: "Sidebar Markdown"
+    description: "Sidebar Markdown-formatted Text"
+    type: "text"
+    required: false
+metadata:
+  author: "Josako"
+  date_added: "2024-06-06"
+  changes: "Initial version"
+  description: "Parameters allowing to customise the chat client"

config/logging_config.py

@@ -1,15 +1,13 @@
+
 import json
 import os
+import sys
 from datetime import datetime as dt, timezone as tz
 
 from flask import current_app
-from graypy import GELFUDPHandler
 import logging
 import logging.config
 
-# Graylog configuration
-GRAYLOG_HOST = os.environ.get('GRAYLOG_HOST', 'localhost')
-GRAYLOG_PORT = int(os.environ.get('GRAYLOG_PORT', 12201))
 env = os.environ.get('FLASK_ENV', 'development')
 
 
@@ -144,23 +142,6 @@ class TuningFormatter(logging.Formatter):
         return formatted_msg
 
 
-class GraylogFormatter(logging.Formatter):
-    """Maintains existing Graylog formatting while adding tuning fields"""
-
-    def format(self, record):
-        if getattr(record, 'is_tuning_log', False):
-            # Add tuning-specific fields to Graylog
-            record.tuning_fields = {
-                'is_tuning_log': True,
-                'tuning_type': record.tuning_type,
-                'tenant_id': record.tenant_id,
-                'catalog_id': record.catalog_id,
-                'specialist_id': record.specialist_id,
-                'retriever_id': record.retriever_id,
-                'processor_id': record.processor_id,
-                'session_id': record.session_id,
-            }
-        return super().format(record)
 
 class TuningLogger:
     """Helper class to manage tuning logs with consistent structure"""
@@ -177,10 +158,10 @@ class TuningLogger:
             specialist_id: Optional specialist ID for context
             retriever_id: Optional retriever ID for context
             processor_id: Optional processor ID for context
-            session_id: Optional session ID for context and log file naming
-            log_file: Optional custom log file name to use
+            session_id: Optional session ID for context
+            log_file: Optional custom log file name (ignored - all logs go to tuning.log)
         """
-
+        # Always use the standard tuning logger
         self.logger = logging.getLogger(logger_name)
         self.tenant_id = tenant_id
         self.catalog_id = catalog_id
@@ -188,63 +169,8 @@ class TuningLogger:
         self.retriever_id = retriever_id
         self.processor_id = processor_id
         self.session_id = session_id
-        self.log_file = log_file
-        # Determine whether to use a session-specific logger
-        if session_id:
-            # Create a unique logger name for this session
-            session_logger_name = f"{logger_name}_{session_id}"
-            self.logger = logging.getLogger(session_logger_name)
 
-            # If this logger doesn't have handlers yet, configure it
-            if not self.logger.handlers:
-                # Determine log file path
-                if not log_file and session_id:
-                    log_file = f"logs/tuning_{session_id}.log"
-                elif not log_file:
-                    log_file = "logs/tuning.log"
-
-                # Configure the logger
-                self._configure_session_logger(log_file)
-        else:
-            # Use the standard tuning logger
-            self.logger = logging.getLogger(logger_name)
-
-    def _configure_session_logger(self, log_file):
-        """Configure a new session-specific logger with appropriate handlers"""
-        # Create and configure a file handler
-        file_handler = logging.handlers.RotatingFileHandler(
-            filename=log_file,
-            maxBytes=1024 * 1024 * 3,  # 3MB
-            backupCount=3
-        )
-        file_handler.setFormatter(TuningFormatter())
-        file_handler.setLevel(logging.DEBUG)
-
-        # Add the file handler to the logger
-        self.logger.addHandler(file_handler)
-
-        # Add Graylog handler in production
-        env = os.environ.get('FLASK_ENV', 'development')
-        if env == 'production':
-            try:
-                graylog_handler = GELFUDPHandler(
-                    host=GRAYLOG_HOST,
-                    port=GRAYLOG_PORT,
-                    debugging_fields=True
-                )
-                graylog_handler.setFormatter(GraylogFormatter())
-                self.logger.addHandler(graylog_handler)
-            except Exception as e:
-                # Fall back to just file logging if Graylog setup fails
-                fallback_logger = logging.getLogger('eveai_app')
-                fallback_logger.warning(f"Failed to set up Graylog handler: {str(e)}")
-
-        # Set logger level and disable propagation
-        self.logger.setLevel(logging.DEBUG)
-        self.logger.propagate = False
-
-
-def log_tuning(self, tuning_type: str, message: str, data=None, level=logging.DEBUG):
+    def log_tuning(self, tuning_type: str, message: str, data=None, level=logging.DEBUG):
         """Log a tuning event with structured data"""
         try:
             # Create a standard LogRecord for tuning
@@ -275,13 +201,82 @@ def log_tuning(self, tuning_type: str, message: str, data=None, level=logging.DE
             self.logger.handle(record)
 
         except Exception as e:
-            fallback_logger = logging.getLogger('eveai_workers')
-            fallback_logger.exception(f"Failed to log tuning message: {str(e)}")
+            print(f"Failed to log tuning message: {str(e)}")
 
 
 # Set the custom log record factory
 logging.setLogRecordFactory(TuningLogRecord)
 
+def configure_logging():
+    """Configure logging based on environment
+
+    When running in Kubernetes, directs logs to stdout in JSON format
+    Otherwise uses file-based logging for development/testing
+    """
+    try:
+        # Verkrijg het absolute pad naar de logs directory
+        base_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
+        logs_dir = os.path.join(base_dir, 'logs')
+
+        # Zorg ervoor dat de logs directory bestaat met de juiste permissies
+        if not os.path.exists(logs_dir):
+            try:
+                os.makedirs(logs_dir, exist_ok=True)
+                print(f"Logs directory aangemaakt op: {logs_dir}")
+            except (IOError, PermissionError) as e:
+                print(f"WAARSCHUWING: Kan logs directory niet aanmaken: {e}")
+                print(f"Logs worden mogelijk niet correct geschreven!")
+
+        # Check if running in Kubernetes
+        in_kubernetes = os.environ.get('KUBERNETES_SERVICE_HOST') is not None
+
+        # Controleer of de pythonjsonlogger pakket beschikbaar is als we in Kubernetes zijn
+        if in_kubernetes:
+            try:
+                import pythonjsonlogger.jsonlogger
+                has_json_logger = True
+            except ImportError:
+                print("WAARSCHUWING: python-json-logger pakket is niet geïnstalleerd.")
+                print("Voer 'pip install python-json-logger>=2.0.7' uit om JSON logging in te schakelen.")
+                print("Terugvallen op standaard logging formaat.")
+                has_json_logger = False
+                in_kubernetes = False  # Fall back to standard logging
+        else:
+            has_json_logger = False
+
+        # Apply the configuration
+        logging_config = dict(LOGGING)
+
+        # Wijzig de json_console handler om terug te vallen op console als pythonjsonlogger niet beschikbaar is
+        if not has_json_logger and 'json_console' in logging_config['handlers']:
+            # Vervang json_console handler door een console handler met standaard formatter
+            logging_config['handlers']['json_console']['formatter'] = 'standard'
+
+        # In Kubernetes, conditionally modify specific loggers to use JSON console output
+        # This preserves the same logger names but changes where/how they log
+        if in_kubernetes:
+            for logger_name in logging_config['loggers']:
+                if logger_name:  # Skip the root logger
+                    logging_config['loggers'][logger_name]['handlers'] = ['json_console']
+
+        # Controleer of de logs directory schrijfbaar is voordat we de configuratie toepassen
+        logs_dir = os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs')
+        if os.path.exists(logs_dir) and not os.access(logs_dir, os.W_OK):
+            print(f"WAARSCHUWING: Logs directory bestaat maar is niet schrijfbaar: {logs_dir}")
+            print("Logs worden mogelijk niet correct geschreven!")
+
+        logging.config.dictConfig(logging_config)
+        logging.info(f"Logging configured. Environment: {'Kubernetes' if in_kubernetes else 'Development/Testing'}")
+        logging.info(f"Logs directory: {logs_dir}")
+    except Exception as e:
+        print(f"Error configuring logging: {str(e)}")
+        print("Gedetailleerde foutinformatie:")
+        import traceback
+        traceback.print_exc()
+        # Fall back to basic configuration
+        logging.basicConfig(level=logging.INFO)
+
+
 
 LOGGING = {
     'version': 1,
@@ -290,7 +285,7 @@ LOGGING = {
         'file_app': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/eveai_app.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'eveai_app.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -298,15 +293,15 @@ LOGGING = {
         'file_workers': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/eveai_workers.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'eveai_workers.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
         },
-        'file_chat': {
+        'file_chat_client': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/eveai_chat.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'eveai_chat_client.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -314,7 +309,7 @@ LOGGING = {
         'file_chat_workers': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/eveai_chat_workers.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'eveai_chat_workers.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -322,7 +317,7 @@ LOGGING = {
         'file_api': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/eveai_api.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'eveai_api.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -330,7 +325,7 @@ LOGGING = {
         'file_beat': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/eveai_beat.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'eveai_beat.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -338,7 +333,7 @@ LOGGING = {
         'file_entitlements': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/eveai_entitlements.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'eveai_entitlements.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -346,7 +341,7 @@ LOGGING = {
         'file_sqlalchemy': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/sqlalchemy.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'sqlalchemy.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -354,7 +349,7 @@ LOGGING = {
         'file_security': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/security.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'security.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -362,7 +357,7 @@ LOGGING = {
         'file_rag_tuning': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/rag_tuning.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'rag_tuning.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -370,7 +365,7 @@ LOGGING = {
         'file_embed_tuning': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/embed_tuning.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'embed_tuning.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -378,7 +373,7 @@ LOGGING = {
         'file_business_events': {
             'level': 'INFO',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/business_events.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'business_events.log'),
             'maxBytes': 1024 * 1024 * 1,  # 1MB
             'backupCount': 2,
             'formatter': 'standard',
@@ -388,100 +383,104 @@ LOGGING = {
             'level': 'DEBUG',
             'formatter': 'standard',
         },
+        'json_console': {
+            'class': 'logging.StreamHandler',
+            'level': 'INFO',
+            'formatter': 'json',
+            'stream': 'ext://sys.stdout',
+        },
         'tuning_file': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/tuning.log',
+            'filename': os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))), 'logs', 'tuning.log'),
             'maxBytes': 1024 * 1024 * 3,  # 3MB
             'backupCount': 3,
             'formatter': 'tuning',
         },
-        'graylog': {
-            'level': 'DEBUG',
-            'class': 'graypy.GELFUDPHandler',
-            'host': GRAYLOG_HOST,
-            'port': GRAYLOG_PORT,
-            'debugging_fields': True,
-            'formatter': 'graylog'
-        },
     },
     'formatters': {
         'standard': {
             'format': '%(asctime)s [%(levelname)s] %(name)s (%(component)s) [%(module)s:%(lineno)d]: %(message)s',
             'datefmt': '%Y-%m-%d %H:%M:%S'
         },
-        'graylog': {
-            'format': '[%(levelname)s] %(name)s (%(component)s) [%(module)s:%(lineno)d in %(funcName)s] '
-                      '[Thread: %(threadName)s]: %(message)s',
-            'datefmt': '%Y-%m-%d %H:%M:%S',
-            '()': GraylogFormatter
-        },
         'tuning': {
             '()': TuningFormatter,
             'datefmt': '%Y-%m-%d %H:%M:%S UTC'
+        },
+        'json': {
+            'format': '%(message)s',
+            'class': 'logging.Formatter' if not 'pythonjsonlogger' in sys.modules else 'pythonjsonlogger.jsonlogger.JsonFormatter',
+            'json_default': lambda obj: str(obj) if isinstance(obj, (dt, Exception)) else None,
+            'json_ensure_ascii': False,
+            'rename_fields': {
+                'asctime': 'timestamp',
+                'levelname': 'severity'
+            },
+            'timestamp': True,
+            'datefmt': '%Y-%m-%dT%H:%M:%S.%fZ'
         }
     },
     'loggers': {
         'eveai_app': {  # logger for the eveai_app
-            'handlers': ['file_app', 'graylog', ] if env == 'production' else ['file_app', ],
+            'handlers': ['file_app'],
             'level': 'DEBUG',
             'propagate': False
         },
         'eveai_workers': {  # logger for the eveai_workers
-            'handlers': ['file_workers', 'graylog', ] if env == 'production' else ['file_workers', ],
+            'handlers': ['file_workers'],
             'level': 'DEBUG',
             'propagate': False
         },
-        'eveai_chat': {  # logger for the eveai_chat
-            'handlers': ['file_chat', 'graylog', ] if env == 'production' else ['file_chat', ],
+        'eveai_chat_client': {  # logger for the eveai_chat
+            'handlers': ['file_chat_client'],
             'level': 'DEBUG',
             'propagate': False
         },
         'eveai_chat_workers': {  # logger for the eveai_chat_workers
-            'handlers': ['file_chat_workers', 'graylog', ] if env == 'production' else ['file_chat_workers', ],
+            'handlers': ['file_chat_workers'],
             'level': 'DEBUG',
             'propagate': False
         },
-        'eveai_api': {  # logger for the eveai_chat_workers
-            'handlers': ['file_api', 'graylog', ] if env == 'production' else ['file_api', ],
+        'eveai_api': {  # logger for the eveai_api
+            'handlers': ['file_api'],
             'level': 'DEBUG',
             'propagate': False
         },
         'eveai_beat': {  # logger for the eveai_beat
-            'handlers': ['file_beat', 'graylog', ] if env == 'production' else ['file_beat', ],
+            'handlers': ['file_beat'],
             'level': 'DEBUG',
             'propagate': False
         },
         'eveai_entitlements': {  # logger for the eveai_entitlements
-            'handlers': ['file_entitlements', 'graylog', ] if env == 'production' else ['file_entitlements', ],
+            'handlers': ['file_entitlements'],
             'level': 'DEBUG',
             'propagate': False
         },
         'sqlalchemy.engine': {  # logger for the sqlalchemy
-            'handlers': ['file_sqlalchemy', 'graylog', ] if env == 'production' else ['file_sqlalchemy', ],
+            'handlers': ['file_sqlalchemy'],
             'level': 'DEBUG',
             'propagate': False
         },
         'security': {  # logger for the security
-            'handlers': ['file_security', 'graylog', ] if env == 'production' else ['file_security', ],
+            'handlers': ['file_security'],
             'level': 'DEBUG',
             'propagate': False
         },
         'business_events': {
-            'handlers': ['file_business_events', 'graylog'],
+            'handlers': ['file_business_events'],
             'level': 'DEBUG',
             'propagate': False
         },
         # Single tuning logger
         'tuning': {
-            'handlers': ['tuning_file', 'graylog'] if env == 'production' else ['tuning_file'],
+            'handlers': ['tuning_file'],
             'level': 'DEBUG',
             'propagate': False,
         },
         '': {  # root logger
-            'handlers': ['console'],
+            'handlers': ['console'] if os.environ.get('KUBERNETES_SERVICE_HOST') is None else ['json_console'],
             'level': 'WARNING',  # Set higher level for root to minimize noise
             'propagate': False
         },
     }
-}
+}

config/processors/globals/AUDIO_PROCESSOR/1.0.0.yaml

@@ -0,0 +1,9 @@
+version: "1.0.0"
+name: "AUDIO Processor"
+file_types: "mp3, mp4, ogg"
+description: "A Processor for audio files"
+configuration: {}
+metadata:
+  author: "System"
+  date_added: "2023-01-01"
+  description: "A Processor for audio files"

config/processors/globals/AUTOMAGIC_HTML_PROCESSOR/1.0.0.yaml

@@ -0,0 +1,14 @@
+version: "1.0.0"
+name: "HTML Processor"
+file_types: "html"
+description: "A processor for HTML files, driven by AI"
+configuration:
+  custom_instructions:
+    name: "Custom Instructions"
+    description: "Some custom instruction to guide our AI agent in parsing your HTML file"
+    type: "text"
+    required: false
+metadata:
+  author: "Josako"
+  date_added: "2025-06-25"
+  description: "A processor for HTML files, driven by AI"

config/processors/globals/DOCX_PROCESSOR/1.0.0.yaml

@@ -0,0 +1,59 @@
+version: "1.0.0"
+name: "DOCX Processor"
+file_types: "docx"
+description: "A processor for DOCX files"
+configuration:
+  chunking_patterns:
+    name: "Chunking Patterns"
+    description: "A list of Patterns used to chunk files into logical pieces"
+    type: "chunking_patterns"
+    required: false
+  chunking_heading_level:
+    name: "Chunking Heading Level"
+    type: "integer"
+    description: "Maximum heading level to consider for chunking (1-6)"
+    required: false
+    default: 2
+  extract_comments:
+    name: "Extract Comments"
+    type: "boolean"
+    description: "Whether to include document comments in the markdown"
+    required: false
+    default: false
+  extract_headers_footers:
+    name: "Extract Headers/Footers"
+    type: "boolean"
+    description: "Whether to include headers and footers in the markdown"
+    required: false
+    default: false
+  preserve_formatting:
+    name: "Preserve Formatting"
+    type: "boolean"
+    description: "Whether to preserve bold, italic, and other text formatting"
+    required: false
+    default: true
+  list_style:
+    name: "List Style"
+    type: "enum"
+    description: "How to format lists in markdown"
+    required: false
+    default: "dash"
+    allowed_values: ["dash", "asterisk", "plus"]
+  image_handling:
+    name: "Image Handling"
+    type: "enum"
+    description: "How to handle embedded images"
+    required: false
+    default: "skip"
+    allowed_values: ["skip", "extract", "placeholder"]
+  table_alignment:
+    name: "Table Alignment"
+    type: "enum"
+    description: "How to align table contents"
+    required: false
+    default: "left"
+    allowed_values: ["left", "center", "preserve"]
+metadata:
+  author: "System"
+  date_added: "2023-01-01"
+  description: "A processor for DOCX files"

config/processors/globals/HTML_PROCESSOR/1.0.0.yaml

@@ -0,0 +1,49 @@
+version: "1.0.0"
+name: "HTML Processor"
+file_types: "html"
+description: "A processor for HTML files"
+configuration:
+  chunking_patterns:
+    name: "Chunking Patterns"
+    description: "A list of Patterns used to chunk files into logical pieces"
+    type: "chunking_patterns"
+    required: false
+  chunking_heading_level:
+    name: "Chunking Heading Level"
+    type: "integer"
+    description: "Maximum heading level to consider for chunking (1-6)"
+    required: false
+    default: 2
+  html_tags:
+    name: "HTML Tags"
+    type: "string"
+    description: "A comma-separated list of HTML tags"
+    required: true
+    default: "p, h1, h2, h3, h4, h5, h6, li, table, thead, tbody, tr, td"
+  html_end_tags:
+    name: "HTML End Tags"
+    type: "string"
+    description: "A comma-separated list of HTML end tags (where can the chunk end)"
+    required: true
+    default: "p, li, table"
+  html_included_elements:
+    name: "HTML Included Elements"
+    type: "string"
+    description: "A comma-separated list of elements to be included"
+    required: true
+    default: "article, main"
+  html_excluded_elements:
+    name: "HTML Excluded Elements"
+    type: "string"
+    description: "A comma-separated list of elements to be excluded"
+    required: false
+    default: "header, footer, nav, script"
+  html_excluded_classes:
+    name: "HTML Excluded Classes"
+    type: "string"
+    description: "A comma-separated list of classes to be excluded"
+    required: false
+metadata:
+  author: "System"
+  date_added: "2023-01-01"
+  description: "A processor for HTML files"

config/processors/globals/MARKDOWN_PROCESSOR/1.0.0.yaml

@@ -0,0 +1,20 @@
+version: "1.0.0"
+name: "Markdown Processor"
+file_types: "md"
+description: "A Processor for markdown files"
+configuration:
+  chunking_patterns:
+    name: "Chunking Patterns"
+    description: "A list of Patterns used to chunk files into logical pieces"
+    type: "chunking_patterns"
+    required: false
+  chunking_heading_level:
+    name: "Chunking Heading Level"
+    type: "integer"
+    description: "Maximum heading level to consider for chunking (1-6)"
+    required: false
+    default: 2
+metadata:
+  author: "System"
+  date_added: "2023-01-01"
+  description: "A Processor for markdown files"

config/processors/globals/PDF_PROCESSOR/1.0.0.yaml

@@ -0,0 +1,20 @@
+version: "1.0.0"
+name: "PDF Processor"
+file_types: "pdf"
+description: "A Processor for PDF files"
+configuration:
+  chunking_patterns:
+    name: "Chunking Patterns"
+    description: "A list of Patterns used to chunk files into logical pieces"
+    type: "chunking_patterns"
+    required: false
+  chunking_heading_level:
+    name: "Chunking Heading Level"
+    type: "integer"
+    description: "Maximum heading level to consider for chunking (1-6)"
+    required: false
+    default: 2
+metadata:
+  author: "System"
+  date_added: "2023-01-01"
+  description: "A Processor for PDF files"

config/prompts/globals/automagic_html_parse/1.0.0.yaml

@@ -0,0 +1,30 @@
+version: "1.0.0"
+content: |
+  You are a top administrative assistant specialized in transforming given HTML into markdown formatted files. The 
+  generated files will be used to generate embeddings in a RAG-system.
+  
+  # Best practices are:
+  - Respect wordings and language(s) used in the HTML.
+  - The following items need to be considered: headings, paragraphs, listed items (numbered or not) and tables. Images can be neglected.
+  - Sub-headers can be used as lists. This is true when a header is followed by a series of sub-headers without content (paragraphs or listed items). Present those sub-headers as a list.  
+  - Be careful of encoding of the text. Everything needs to be human readable.
+
+  You only return relevant information, and filter out non-relevant information, such as:
+  - information found in menu bars, sidebars, footers or headers
+  - information in forms, buttons
+  
+  Process the file or text carefully, and take a stepped approach. The resulting markdown should be the result of the 
+  processing of the complete input html file. Answer with the pure markdown, without any other text.
+  
+  {custom_instructions}
+  
+  HTML to be processed is in between triple backquotes.
+  
+  ```{html}```
+
+llm_model: "mistral.mistral-small-latest"
+metadata:
+  author: "Josako"
+  date_added: "2025-06-25"
+  description: "An aid in transforming HTML-based inputs to markdown, fully automatic"
+  changes: "Initial version"

config/prompts/globals/translation_with_context/1.0.0.yaml

@@ -0,0 +1,15 @@
+version: "1.0.0"
+content: >
+  You are a top translator. We need you to translate {text_to_translate} into {target_language}, taking into account 
+  this context:
+  
+  {context}
+  
+  I only want you to return the translation. No explanation, no options. I need to be able to directly use your answer
+  without further interpretation. If more than one option is available, present me with the most probable one.
+llm_model: "mistral.ministral-8b-latest"
+metadata:
+  author: "Josako"
+  date_added: "2025-06-23"
+  description: "An assistant to translate given a context."
+  changes: "Initial version"

config/prompts/globals/translation_without_context/1.0.0.yaml

@@ -0,0 +1,12 @@
+version: "1.0.0"
+content: >
+  You are a top translator. We need you to translate {text_to_translate} into {target_language}.
+  
+  I only want you to return the translation. No explanation, no options. I need to be able to directly use your answer
+  without further interpretation. If more than one option is available, present me with the most probable one.
+llm_model: "mistral.ministral-8b-latest"
+metadata:
+  author: "Josako"
+  date_added: "2025-06-23"
+  description: "An assistant to translate without context."
+  changes: "Initial version"

config/specialist_forms/globals/PERSONAL_CONTACT_FORM/1.0.0.yaml

@@ -0,0 +1,46 @@
+type: "PERSONAL_CONTACT_FORM"
+version: "1.0.0"
+name: "Personal Contact Form"
+icon: "person"
+fields:
+  name:
+    name: "Name"
+    description: "Your name"
+    type: "str"
+    required: true
+  email:
+    name: "Email"
+    type: "str"
+    description: "Your Name"
+    required: true
+  phone:
+    name: "Phone Number"
+    type: "str"
+    description: "Your Phone Number"
+    context: "Een kleine test om te zien of we context kunnen doorgeven en tonen"
+    required: true
+  address:
+    name: "Address"
+    type: "string"
+    description: "Your Address"
+    required: false
+  zip:
+    name: "Postal Code"
+    type: "string"
+    description: "Postal Code"
+    required: false
+  city:
+    name: "City"
+    type: "string"
+    description: "City"
+    required: false
+  country:
+    name: "Country"
+    type: "string"
+    description: "Country"
+    required: false
+  consent:
+    name: "Consent"
+    type: "boolean"
+    description: "Consent"
+    required: true

config/specialist_forms/globals/PROFESSIONAL_CONTACT_FORM/1.0.0.yaml

@@ -0,0 +1,55 @@
+type: "PROFESSIONAL_CONTACT_FORM"
+version: "1.0.0"
+name: "Professional Contact Form"
+icon: "account_circle"
+fields:
+  name:
+    name: "Name"
+    description: "Your name"
+    type: "str"
+    required: true
+  email:
+    name: "Email"
+    type: "str"
+    description: "Your Name"
+    required: true
+  phone:
+    name: "Phone Number"
+    type: "str"
+    description: "Your Phone Number"
+    required: true
+  company:
+    name: "Company Name"
+    type: "str"
+    description: "Company Name"
+    required: true
+  job_title:
+    name: "Job Title"
+    type: "str"
+    description: "Job Title"
+    required: false
+  address:
+    name: "Address"
+    type: "str"
+    description: "Your Address"
+    required: false
+  zip:
+    name: "Postal Code"
+    type: "str"
+    description: "Postal Code"
+    required: false
+  city:
+    name: "City"
+    type: "str"
+    description: "City"
+    required: false
+  country:
+    name: "Country"
+    type: "str"
+    description: "Country"
+    required: false
+  consent:
+    name: "Consent"
+    type: "bool"
+    description: "Consent"
+    required: true

config/specialists/traicie/TRAICIE_ROLE_DEFINITION_SPECIALIST/1.2.0.yaml

@@ -0,0 +1,44 @@
+version: "1.2.0"
+name: "Traicie Role Definition Specialist"
+framework: "crewai"
+partner: "traicie"
+chat: false
+configuration: {}
+arguments:
+  role_name:
+    name: "Role Name"
+    description: "The name of the role that is being processed. Will be used to create a selection specialist"
+    type: "str"
+    required: true
+  specialist_name:
+    name: "Chatbot Name"
+    description: "The name of the chatbot."
+    type: "str"
+    required: true
+  role_reference:
+    name: "Role Reference"
+    description: "A customer reference to the role"
+    type: "str"
+    required: false
+  vacancy_text:
+    name: "vacancy_text"
+    type: "text"
+    description: "The Vacancy Text"
+    required: true
+results:
+  competencies:
+    name: "competencies"
+    type: "List[str, str]"
+    description: "List of vacancy competencies and their descriptions"
+    required: false
+agents:
+  - type: "TRAICIE_HR_BP_AGENT"
+    version: "1.0"
+tasks:
+  - type: "TRAICIE_GET_COMPETENCIES_TASK"
+    version: "1.1"
+metadata:
+  author: "Josako"
+  date_added: "2025-05-27"
+  changes: "Updated for unified competencies and ko criteria"
+  description: "Assistant to create a new Vacancy based on Vacancy Text"

config/specialists/traicie/TRAICIE_ROLE_DEFINITION_SPECIALIST/1.3.0.yaml

@@ -0,0 +1,50 @@
+version: "1.3.0"
+name: "Traicie Role Definition Specialist"
+framework: "crewai"
+partner: "traicie"
+chat: false
+configuration: {}
+arguments:
+  role_name:
+    name: "Role Name"
+    description: "The name of the role that is being processed. Will be used to create a selection specialist"
+    type: "str"
+    required: true
+  specialist_name:
+    name: "Chatbot Name"
+    description: "The name of the chatbot."
+    type: "str"
+    required: true
+  make:
+    name: "Make"
+    description: "The make for which the role is defined and the selection specialist is created"
+    type: "system"
+    system_name: "tenant_make"
+    required: true
+  role_reference:
+    name: "Role Reference"
+    description: "A customer reference to the role"
+    type: "str"
+    required: false
+  vacancy_text:
+    name: "vacancy_text"
+    type: "text"
+    description: "The Vacancy Text"
+    required: true
+results:
+  competencies:
+    name: "competencies"
+    type: "List[str, str]"
+    description: "List of vacancy competencies and their descriptions"
+    required: false
+agents:
+  - type: "TRAICIE_HR_BP_AGENT"
+    version: "1.0"
+tasks:
+  - type: "TRAICIE_GET_COMPETENCIES_TASK"
+    version: "1.1"
+metadata:
+  author: "Josako"
+  date_added: "2025-05-27"
+  changes: "Added a make to be specified (a selection specialist now is created in context of a make"
+  description: "Assistant to create a new Vacancy based on Vacancy Text"

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.0.0.yaml

@@ -5,12 +5,17 @@ partner: "traicie"
 chat: false
 configuration:
   name:
-    name: "name"
+    name: "Name"
     description: "The name the specialist is called upon."
     type: "str"
     required: true
+  role_reference:
+    name: "Role Reference"
+    description: "A customer reference to the role"
+    type: "str"
+    required: false
   competencies:
-    name: "competencies"
+    name: "Competencies"
     description: "An ordered list of competencies."
     type: "ordered_list"
     list_type: "competency_details"
@@ -41,17 +46,17 @@ configuration:
     required: false
 competency_details:
   title:
-    name: "title"
+    name: "Title"
     description: "Competency Title"
     type: "str"
     required: true
   description:
-    name: "description"
+    name: "Description"
     description: "Description (in context of the role) of the competency"
     type: "text"
     required: true
   is_knockout:
-    name: "Is Knockout"
+    name: "KO"
     description: "Defines if the competency is a knock-out criterium"
     type: "boolean"
     required: true
@@ -63,10 +68,32 @@ competency_details:
     required: true
     default: true
 arguments:
-  vacancy_text:
-    name: "vacancy_text"
-    type: "text"
-    description: "The Vacancy Text"
+  region:
+    name: "Region"
+    type: "str"
+    description: "The region of the specific vacancy"
+    required: false
+  working_schedule:
+    name: "Work Schedule"
+    type: "str"
+    description: "The work schedule or employment type of the specific vacancy"
+    required: false
+  start_date:
+    name: "Start Date"
+    type: "date"
+    description: "The start date of the specific vacancy"
+    required: false
+  language:
+    name: "Language"
+    type: "str"
+    description: "The language (2-letter code) used to start the conversation"
+    required: true
+  interaction_mode:
+    name: "Interaction Mode"
+    type: "enum"
+    description: "The interaction mode the specialist will start working in."
+    allowed_values: ["Job Application", "Seduction"]
+    default: "Job Application"
     required: true
 results:
   competencies:

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.1.0.yaml

@@ -0,0 +1,120 @@
+version: "1.1.0"
+name: "Traicie Selection Specialist"
+framework: "crewai"
+partner: "traicie"
+chat: false
+configuration:
+  name:
+    name: "Name"
+    description: "The name the specialist is called upon."
+    type: "str"
+    required: true
+  role_reference:
+    name: "Role Reference"
+    description: "A customer reference to the role"
+    type: "str"
+    required: false
+  make:
+    name: "Make"
+    description: "The make for which the role is defined and the selection specialist is created"
+    type: "system"
+    system_name: "tenant_make"
+    required: true
+  competencies:
+    name: "Competencies"
+    description: "An ordered list of competencies."
+    type: "ordered_list"
+    list_type: "competency_details"
+    required: true
+  tone_of_voice:
+    name: "Tone of Voice"
+    description: "The tone of voice the specialist uses to communicate"
+    type: "enum"
+    allowed_values: ["Professional & Neutral", "Warm & Empathetic", "Energetic & Enthusiastic", "Accessible & Informal", "Expert & Trustworthy", "No-nonsense & Goal-driven"]
+    default: "Professional & Neutral"
+    required: true
+  language_level:
+    name: "Language Level"
+    description: "Language level to be used when communicating, relating to CEFR levels"
+    type: "enum"
+    allowed_values: ["Basic", "Standard", "Professional"]
+    default: "Standard"
+    required: true
+  welcome_message:
+    name: "Welcome Message"
+    description: "Introductory text given by the specialist - but translated according to Tone of Voice, Language Level and Starting Language"
+    type: "text"
+    required: false
+  closing_message:
+    name: "Closing Message"
+    description: "Closing message given by the specialist - but translated according to Tone of Voice, Language Level and Starting Language"
+    type: "text"
+    required: false
+competency_details:
+  title:
+    name: "Title"
+    description: "Competency Title"
+    type: "str"
+    required: true
+  description:
+    name: "Description"
+    description: "Description (in context of the role) of the competency"
+    type: "text"
+    required: true
+  is_knockout:
+    name: "KO"
+    description: "Defines if the competency is a knock-out criterium"
+    type: "boolean"
+    required: true
+    default: false
+  assess:
+    name: "Assess"
+    description: "Indication if this competency is to be assessed"
+    type: "boolean"
+    required: true
+    default: true
+arguments:
+  region:
+    name: "Region"
+    type: "str"
+    description: "The region of the specific vacancy"
+    required: false
+  working_schedule:
+    name: "Work Schedule"
+    type: "str"
+    description: "The work schedule or employment type of the specific vacancy"
+    required: false
+  start_date:
+    name: "Start Date"
+    type: "date"
+    description: "The start date of the specific vacancy"
+    required: false
+  language:
+    name: "Language"
+    type: "str"
+    description: "The language (2-letter code) used to start the conversation"
+    required: true
+  interaction_mode:
+    name: "Interaction Mode"
+    type: "enum"
+    description: "The interaction mode the specialist will start working in."
+    allowed_values: ["Job Application", "Seduction"]
+    default: "Job Application"
+    required: true
+results:
+  competencies:
+    name: "competencies"
+    type: "List[str, str]"
+    description: "List of vacancy competencies and their descriptions"
+    required: false
+agents:
+  - type: "TRAICIE_HR_BP_AGENT"
+    version: "1.0"
+tasks:
+  - type: "TRAICIE_GET_COMPETENCIES_TASK"
+    version: "1.1"
+metadata:
+  author: "Josako"
+  date_added: "2025-05-27"
+  changes: "Add make to the selection specialist"
+  description: "Assistant to create a new Vacancy based on Vacancy Text"

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.2.0.yaml

@@ -0,0 +1,120 @@
+version: "1.3.0"
+name: "Traicie Selection Specialist"
+framework: "crewai"
+partner: "traicie"
+chat: false
+configuration:
+  name:
+    name: "Name"
+    description: "The name the specialist is called upon."
+    type: "str"
+    required: true
+  role_reference:
+    name: "Role Reference"
+    description: "A customer reference to the role"
+    type: "str"
+    required: false
+  make:
+    name: "Make"
+    description: "The make for which the role is defined and the selection specialist is created"
+    type: "system"
+    system_name: "tenant_make"
+    required: true
+  competencies:
+    name: "Competencies"
+    description: "An ordered list of competencies."
+    type: "ordered_list"
+    list_type: "competency_details"
+    required: true
+  tone_of_voice:
+    name: "Tone of Voice"
+    description: "The tone of voice the specialist uses to communicate"
+    type: "enum"
+    allowed_values: ["Professional & Neutral", "Warm & Empathetic", "Energetic & Enthusiastic", "Accessible & Informal", "Expert & Trustworthy", "No-nonsense & Goal-driven"]
+    default: "Professional & Neutral"
+    required: true
+  language_level:
+    name: "Language Level"
+    description: "Language level to be used when communicating, relating to CEFR levels"
+    type: "enum"
+    allowed_values: ["Basic", "Standard", "Professional"]
+    default: "Standard"
+    required: true
+  welcome_message:
+    name: "Welcome Message"
+    description: "Introductory text given by the specialist - but translated according to Tone of Voice, Language Level and Starting Language"
+    type: "text"
+    required: false
+  closing_message:
+    name: "Closing Message"
+    description: "Closing message given by the specialist - but translated according to Tone of Voice, Language Level and Starting Language"
+    type: "text"
+    required: false
+competency_details:
+  title:
+    name: "Title"
+    description: "Competency Title"
+    type: "str"
+    required: true
+  description:
+    name: "Description"
+    description: "Description (in context of the role) of the competency"
+    type: "text"
+    required: true
+  is_knockout:
+    name: "KO"
+    description: "Defines if the competency is a knock-out criterium"
+    type: "boolean"
+    required: true
+    default: false
+  assess:
+    name: "Assess"
+    description: "Indication if this competency is to be assessed"
+    type: "boolean"
+    required: true
+    default: true
+arguments:
+  region:
+    name: "Region"
+    type: "str"
+    description: "The region of the specific vacancy"
+    required: false
+  working_schedule:
+    name: "Work Schedule"
+    type: "str"
+    description: "The work schedule or employment type of the specific vacancy"
+    required: false
+  start_date:
+    name: "Start Date"
+    type: "date"
+    description: "The start date of the specific vacancy"
+    required: false
+  language:
+    name: "Language"
+    type: "str"
+    description: "The language (2-letter code) used to start the conversation"
+    required: true
+  interaction_mode:
+    name: "Interaction Mode"
+    type: "enum"
+    description: "The interaction mode the specialist will start working in."
+    allowed_values: ["Job Application", "Seduction"]
+    default: "Job Application"
+    required: true
+results:
+  competencies:
+    name: "competencies"
+    type: "List[str, str]"
+    description: "List of vacancy competencies and their descriptions"
+    required: false
+agents:
+  - type: "TRAICIE_RECRUITER"
+    version: "1.0"
+tasks:
+  - type: "TRAICIE_KO_CRITERIA_INTERVIEW_DEFINITION"
+    version: "1.0"
+metadata:
+  author: "Josako"
+  date_added: "2025-06-16"
+  changes: "Realising the actual interaction with the LLM"
+  description: "Assistant to create a new Vacancy based on Vacancy Text"

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.3.0.yaml

@@ -0,0 +1,120 @@
+version: "1.3.0"
+name: "Traicie Selection Specialist"
+framework: "crewai"
+partner: "traicie"
+chat: false
+configuration:
+  name:
+    name: "Name"
+    description: "The name the specialist is called upon."
+    type: "str"
+    required: true
+  role_reference:
+    name: "Role Reference"
+    description: "A customer reference to the role"
+    type: "str"
+    required: false
+  make:
+    name: "Make"
+    description: "The make for which the role is defined and the selection specialist is created"
+    type: "system"
+    system_name: "tenant_make"
+    required: true
+  competencies:
+    name: "Competencies"
+    description: "An ordered list of competencies."
+    type: "ordered_list"
+    list_type: "competency_details"
+    required: true
+  tone_of_voice:
+    name: "Tone of Voice"
+    description: "The tone of voice the specialist uses to communicate"
+    type: "enum"
+    allowed_values: ["Professional & Neutral", "Warm & Empathetic", "Energetic & Enthusiastic", "Accessible & Informal", "Expert & Trustworthy", "No-nonsense & Goal-driven"]
+    default: "Professional & Neutral"
+    required: true
+  language_level:
+    name: "Language Level"
+    description: "Language level to be used when communicating, relating to CEFR levels"
+    type: "enum"
+    allowed_values: ["Basic", "Standard", "Professional"]
+    default: "Standard"
+    required: true
+  welcome_message:
+    name: "Welcome Message"
+    description: "Introductory text given by the specialist - but translated according to Tone of Voice, Language Level and Starting Language"
+    type: "text"
+    required: false
+  closing_message:
+    name: "Closing Message"
+    description: "Closing message given by the specialist - but translated according to Tone of Voice, Language Level and Starting Language"
+    type: "text"
+    required: false
+competency_details:
+  title:
+    name: "Title"
+    description: "Competency Title"
+    type: "str"
+    required: true
+  description:
+    name: "Description"
+    description: "Description (in context of the role) of the competency"
+    type: "text"
+    required: true
+  is_knockout:
+    name: "KO"
+    description: "Defines if the competency is a knock-out criterium"
+    type: "boolean"
+    required: true
+    default: false
+  assess:
+    name: "Assess"
+    description: "Indication if this competency is to be assessed"
+    type: "boolean"
+    required: true
+    default: true
+arguments:
+  region:
+    name: "Region"
+    type: "str"
+    description: "The region of the specific vacancy"
+    required: false
+  working_schedule:
+    name: "Work Schedule"
+    type: "str"
+    description: "The work schedule or employment type of the specific vacancy"
+    required: false
+  start_date:
+    name: "Start Date"
+    type: "date"
+    description: "The start date of the specific vacancy"
+    required: false
+  language:
+    name: "Language"
+    type: "str"
+    description: "The language (2-letter code) used to start the conversation"
+    required: true
+  interaction_mode:
+    name: "Interaction Mode"
+    type: "enum"
+    description: "The interaction mode the specialist will start working in."
+    allowed_values: ["Job Application", "Seduction"]
+    default: "Job Application"
+    required: true
+results:
+  competencies:
+    name: "competencies"
+    type: "List[str, str]"
+    description: "List of vacancy competencies and their descriptions"
+    required: false
+agents:
+  - type: "TRAICIE_RECRUITER_AGENT"
+    version: "1.0"
+tasks:
+  - type: "TRAICIE_KO_CRITERIA_INTERVIEW_DEFINITION_TASK"
+    version: "1.0"
+metadata:
+  author: "Josako"
+  date_added: "2025-06-18"
+  changes: "Add make to the selection specialist"
+  description: "Assistant to create a new Vacancy based on Vacancy Text"

config/tasks/traicie/TRAICIE_COMPETENCIES_INTERVIEW_DEFINITION/1.0.0.yaml

@@ -0,0 +1,30 @@
+version: "1.0.0"
+name: "KO Criteria Interview Definition"
+task_description: >
+  In context of a vacancy in your company {tenant_name}, you are provided with a set of competencies. (both description 
+  and title). The competencies are in between triple backquotes. You need to prepare for the interviews, 
+  and are to provide for each of these ko criteria:
+  
+  - A question to ask the recruitment candidate describing the context of the competency. Use your experience to not 
+  just ask a closed question, but a question from which you can indirectly derive a positive or negative qualification of
+  the competency based on the answer of the candidate.
+  
+  Apply the following tone of voice in both questions and answers: {tone_of_voice}
+  Apply the following language level in both questions and answers: {language_level}
+  Use {language} as language for both questions and answers.
+  
+  ```{competencies}```
+  
+  {custom_description}
+
+expected_output: >
+  For each of the ko criteria, you provide:
+  - the exact title in the original language
+  - the question
+  - a set of answers, with for each answer an indication if it is the correct answer, or a false response.
+  {custom_expected_output}
+metadata:
+  author: "Josako"
+  date_added: "2025-06-15"
+  description: "A Task to define interview Q&A from given KO Criteria"
+  changes: "Initial Version"

config/tasks/traicie/TRAICIE_KO_CRITERIA_INTERVIEW_DEFINITION_TASK/1.0.0.yaml

@@ -0,0 +1,42 @@
+version: "1.0.0"
+name: "KO Criteria Interview Definition"
+task_description: >
+  In context of a vacancy in your company {tenant_name}, you are provided with a set of knock-out criteria 
+  (both description and title). The criteria are in between triple backquotes.You need to prepare for the interviews, 
+  and are to provide for each of these ko criteria:
+  
+  - A short question to ask the recruitment candidate describing the context of the ko criterium. Use your experience to
+  ask a question that enables us to verify compliancy to the criterium.
+  - A set of 2 short answers to that question, from the candidates perspective. One of the answers will result in a 
+  positive evaluation of the criterium, the other one in a negative evaluation. Mark each of the answers as positive
+  or negative. 
+  Describe the answers from the perspective of the candidate. Be sure to include all necessary aspects in you answers. 
+  
+  Apply the following tone of voice in both questions and answers: {tone_of_voice}
+  Use the following description to understand tone of voice:
+  
+  {tone_of_voice_context}
+  
+  Apply the following language level in both questions and answers: {language_level}
+  
+  Use {language} as language for both questions and answers.
+  Use the following description to understand language_level:
+  
+  {language_level_context}
+  
+  ```{ko_criteria}```
+  
+  {custom_description}
+
+expected_output: >
+  For each of the ko criteria, you provide:
+  - the exact title as specified in the original language
+  - the question in {language}
+  - a positive answer, resulting in a positive evaluation of the criterium. In {language}.
+  - a negative answer, resulting in a negative evaluation of the criterium. In {language}.
+  {custom_expected_output}
+metadata:
+  author: "Josako"
+  date_added: "2025-06-15"
+  description: "A Task to define interview Q&A from given KO Criteria"
+  changes: "Initial Version"

config/tasks/traicie/TRAICIE_KO_CRITERIA_INTERVIEW_DEFINITION_TASK/1.0.1.yaml

@@ -0,0 +1,37 @@
+version: "1.0.0"
+name: "KO Criteria Interview Definition"
+task_description: >
+  In context of a vacancy in your company {tenant_name}, you are provided with a set of competencies 
+  (both description and title). The competencies are in between triple backquotes. The competencies provided should be
+  handled as knock-out criteria.
+  For each of the knock-out criteria, you need to define
+  
+  - A short (1 sentence), closed-ended question (Yes / No) to ask the recruitment candidate. Use your experience to ask a question that 
+  enables us to verify compliancy to the criterium.
+  - A set of 2 short answers (1 small sentence each) to that question (positive answer / negative answer), from the 
+  candidates perspective. 
+  The positive answer will result in a positive evaluation of the criterium, the negative answer in a negative evaluation
+  of the criterium. Try to avoid just using Yes / No as positive and negative answers.
+  
+  Apply the following tone of voice in both questions and answers: {tone_of_voice}, i.e. {tone_of_voice_context}
+
+  Apply the following language level in both questions and answers: {language_level}, i.e. {language_level_context}
+  
+  Use {language} as language for both questions and answers.
+  
+  ```{ko_criteria}```
+  
+  {custom_description}
+
+expected_output: >
+  For each of the ko criteria, you provide:
+  - the exact title as specified in the original language
+  - the question in {language}
+  - a positive answer, resulting in a positive evaluation of the criterium. In {language}.
+  - a negative answer, resulting in a negative evaluation of the criterium. In {language}.
+  {custom_expected_output}
+metadata:
+  author: "Josako"
+  date_added: "2025-06-20"
+  description: "A Task to define interview Q&A from given KO Criteria"
+  changes: "Improvement to ensure closed-ended questions and short descriptions"

config/type_defs/agent_types.py

@@ -32,5 +32,10 @@ AGENT_TYPES = {
         "name": "Traicie HR BP Agent",
         "description": "An HR Business Partner Agent",
         "partner": "traicie"
-    }
+    },
+    "TRAICIE_RECRUITER_AGENT": {
+        "name": "Traicie Recruiter Agent",
+        "description": "An Senior Recruiter Agent",
+        "partner": "traicie"
+    },
 }

config/type_defs/catalog_types.py

@@ -2,28 +2,10 @@
 CATALOG_TYPES = {
     "STANDARD_CATALOG": {
         "name": "Standard Catalog",
-        "Description": "A Catalog with information in Evie's Library, to be considered as a whole",
-        "configuration": {},
-        "document_version_configurations": []
+        "description": "A Catalog with information in Evie's Library, to be considered as a whole",
     },
     "DOSSIER_CATALOG": {
         "name": "Dossier Catalog",
-        "Description": "A Catalog with information in Evie's Library in which several Dossiers can be stored",
-        "configuration": {
-            "tagging_fields": {
-                "name": "Tagging Fields",
-                "type": "tagging_fields",
-                "description": """Define the metadata fields that will be used for tagging documents.
-                                Each field must have:
-                                - type: one of 'string', 'integer', 'float', 'date', 'enum'
-                                - required: boolean indicating if the field is mandatory
-                                - description: field description
-                                - allowed_values: list of values (for enum type only)
-                                - min_value/max_value: range limits (for numeric types only)""",
-                "required": True,
-                "default": {},
-            }
-        },
-        "document_version_configurations": ["tagging_fields"]
+        "description": "A Catalog with information in Evie's Library in which several Dossiers can be stored",
     },
 }

config/type_defs/customisation_types.py

@@ -0,0 +1,7 @@
+# Catalog Types
+CUSTOMISATION_TYPES = {
+    "CHAT_CLIENT_CUSTOMISATION": {
+        "name": "Chat Client Customisation",
+        "description": "Parameters allowing to customise the chat client",
+    },
+}

config/type_defs/processor_types.py

@@ -1,168 +1,33 @@
-# Catalog Types
+# Processor Types
 PROCESSOR_TYPES = {
     "HTML_PROCESSOR": {
         "name": "HTML Processor",
+        "description": "A processor for HTML files",
         "file_types": "html",
-        "Description": "A processor for HTML files",
-        "configuration": {
-            "chunking_patterns": {
-                "name": "Chunking Patterns",
-                "description": "A list of Patterns used to chunk files into logical pieces",
-                "type": "chunking_patterns",
-                "required": False
-            },
-            "chunking_heading_level": {
-                "name": "Chunking Heading Level",
-                "type": "integer",
-                "description": "Maximum heading level to consider for chunking (1-6)",
-                "required": False,
-                "default": 2
-            },
-            "html_tags": {
-                "name": "HTML Tags",
-                "type": "string",
-                "description": "A comma-separated list of HTML tags",
-                "required": True,
-                "default": "p, h1, h2, h3, h4, h5, h6, li, table, thead, tbody, tr, td"
-            },
-            "html_end_tags": {
-                "name": "HTML End Tags",
-                "type": "string",
-                "description": "A comma-separated list of HTML end tags (where can the chunk end)",
-                "required": True,
-                "default": "p, li, table"
-            },
-            "html_included_elements": {
-                "name": "HTML Included Elements",
-                "type": "string",
-                "description": "A comma-separated list of elements to be included",
-                "required": True,
-                "default": "article, main"
-            },
-            "html_excluded_elements": {
-                "name": "HTML Excluded Elements",
-                "type": "string",
-                "description": "A comma-separated list of elements to be excluded",
-                "required": False,
-                "default": "header, footer, nav, script"
-            },
-            "html_excluded_classes": {
-                "name": "HTML Excluded Classes",
-                "type": "string",
-                "description": "A comma-separated list of classes to be excluded",
-                "required": False,
-            },
-        },
     },
     "PDF_PROCESSOR": {
         "name": "PDF Processor",
+        "description": "A Processor for PDF files",
         "file_types": "pdf",
-        "Description": "A Processor for PDF files",
-        "configuration": {
-            "chunking_patterns": {
-                "name": "Chunking Patterns",
-                "description": "A list of Patterns used to chunk files into logical pieces",
-                "type": "chunking_patterns",
-                "required": False
-            },
-            "chunking_heading_level": {
-                "name": "Chunking Heading Level",
-                "type": "integer",
-                "description": "Maximum heading level to consider for chunking (1-6)",
-                "required": False,
-                "default": 2
-            },
-        },
     },
     "AUDIO_PROCESSOR": {
         "name": "AUDIO Processor",
+        "description": "A Processor for audio files",
         "file_types": "mp3, mp4, ogg",
-        "Description": "A Processor for audio files",
-        "configuration": {}
     },
     "MARKDOWN_PROCESSOR": {
         "name": "Markdown Processor",
+        "description": "A Processor for markdown files",
         "file_types": "md",
-        "Description": "A Processor for markdown files",
-        "configuration": {
-            "chunking_patterns": {
-                "name": "Chunking Patterns",
-                "description": "A list of Patterns used to chunk files into logical pieces",
-                "type": "chunking_patterns",
-                "required": False
-            },
-            "chunking_heading_level": {
-                "name": "Chunking Heading Level",
-                "type": "integer",
-                "description": "Maximum heading level to consider for chunking (1-6)",
-                "required": False,
-                "default": 2
-            },
-        }
     },
     "DOCX_PROCESSOR": {
         "name": "DOCX Processor",
+        "description": "A processor for DOCX files",
         "file_types": "docx",
-        "Description": "A processor for DOCX files",
-        "configuration": {
-            "chunking_patterns": {
-                "name": "Chunking Patterns",
-                "description": "A list of Patterns used to chunk files into logical pieces",
-                "type": "chunking_patterns",
-                "required": False
-            },
-            "chunking_heading_level": {
-                "name": "Chunking Heading Level",
-                "type": "integer",
-                "description": "Maximum heading level to consider for chunking (1-6)",
-                "required": False,
-                "default": 2
-            },
-            "extract_comments": {
-                "name": "Extract Comments",
-                "type": "boolean",
-                "description": "Whether to include document comments in the markdown",
-                "required": False,
-                "default": False
-            },
-            "extract_headers_footers": {
-                "name": "Extract Headers/Footers",
-                "type": "boolean",
-                "description": "Whether to include headers and footers in the markdown",
-                "required": False,
-                "default": False
-            },
-            "preserve_formatting": {
-                "name": "Preserve Formatting",
-                "type": "boolean",
-                "description": "Whether to preserve bold, italic, and other text formatting",
-                "required": False,
-                "default": True
-            },
-            "list_style": {
-                "name": "List Style",
-                "type": "enum",
-                "description": "How to format lists in markdown",
-                "required": False,
-                "default": "dash",
-                "allowed_values": ["dash", "asterisk", "plus"]
-            },
-            "image_handling": {
-                "name": "Image Handling",
-                "type": "enum",
-                "description": "How to handle embedded images",
-                "required": False,
-                "default": "skip",
-                "allowed_values": ["skip", "extract", "placeholder"]
-            },
-            "table_alignment": {
-                "name": "Table Alignment",
-                "type": "enum",
-                "description": "How to align table contents",
-                "required": False,
-                "default": "left",
-                "allowed_values": ["left", "center", "preserve"]
-            }
-        }
-    }
+    },
+    "AUTOMAGIC_HTML_PROCESSOR": {
+        "name": "AutoMagic HTML Processor",
+        "description": "A processor for HTML files, driven by AI",
+        "file_types": "html, htm",
+    },
 }

config/type_defs/prompt_types.py

@@ -28,4 +28,12 @@ PROMPT_TYPES = {
         "name": "transcript",
         "description": "An assistant to transform a transcript to markdown.",
     },
+    "translation_with_context": {
+        "name": "translation_with_context",
+        "description": "An assistant to translate text with context",
+    },
+    "translation_without_context": {
+        "name": "translation_without_context",
+        "description": "An assistant to translate text without context",
+    },
 }

config/type_defs/specialist_form_types.py

@@ -0,0 +1,11 @@
+# Specialist Form Types
+SPECIALIST_FORM_TYPES = {
+    "PERSONAL_CONTACT_FORM": {
+        "name": "Personal Contact Form",
+        "description": "A form for entering your personal contact details",
+    },
+    "PROFESSIONAL_CONTACT_FORM": {
+        "name": "Professional Contact Form",
+        "description": "A form for entering your professional contact details",
+    },
+}

config/type_defs/specialist_types.py

@@ -16,5 +16,9 @@ SPECIALIST_TYPES = {
         "name": "Traicie Role Definition Specialist",
         "description": "Assistant Defining Competencies and KO Criteria",
         "partner": "traicie"
+    },
+    "TRAICIE_SELECTION_SPECIALIST": {
+        "name": "Traicie Selection Specialist",
+        "description": "Recruitment Selection Assistant",
     }
 }

config/type_defs/task_types.py

@@ -41,5 +41,10 @@ TASK_TYPES = {
         "name": "Traicie Get KO Criteria",
         "description": "A Task to get KO Criteria from a Vacancy Text",
         "partner": "traicie"
+    },
+    "TRAICIE_KO_CRITERIA_INTERVIEW_DEFINITION_TASK": {
+        "name": "Traicie KO Criteria Interview Definition",
+        "description": "A Task to define KO Criteria questions to be used during the interview",
+        "partner": "traicie"
     }
 }

content/changelog/1.0/1.0.0.md

@@ -0,0 +1,446 @@
+# Changelog
+
+All notable changes to EveAI will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.3.8-alfa]
+
+### Added
+- Translation Service
+- Automagic HTML Processor 
+- Allowed languages defined at level of Tenant Make
+
+### Changed
+- For changes in existing functionality.
+- Allow to activate / de-activate Processors
+- Align all document views with session catalog
+- Allow different processor types to handle the same file types
+- Remove welcome message from tenant_make customisation, add to specialist configuration
+
+### Deprecated
+- For soon-to-be removed features.
+
+### Removed
+- For now removed features.
+
+### Fixed
+- Adapt TRAICIE_ROLE_DEFINITION_SPECIALIST to latest requirements
+- Allow for empty historical messages
+- Ensure client can cope with empty customisation options
+- Ensure only tenant-defined makes are selectable throughout the application
+- Refresh partner info when adding Partner Services
+
+### Security
+- In case of vulnerabilities.
+
+## [2.3.7-alfa]
+
+### Added
+- Basic Base Specialist additions for handling phases and transferring data between state and output
+- Introduction of URL and QR-code for MagicLink
+
+### Changed
+- Logging improvement & simplification (remove Graylog)
+- Traicie Selection Specialist v1.3 - full roundtrip & full process
+
+## [2.3.6-alfa]
+
+### Added
+- Full Chat Client functionality, including Forms, ESS, theming
+- First Demo version of Traicie Selection Specialist
+
+## [2.3.5-alfa]
+
+### Added
+- Chat Client Initialisation (based on SpecialistMagicLink code)
+- Definition of framework for the chat_client (using vue.js)
+
+### Changed
+- Remove AllowedLanguages from Tenant
+- Remove Tenant URL (now in Make)
+- Adapt chat client customisation options
+
+### Fixed
+- Several Bugfixes to administrative app
+
+## [2.3.4-alfa]
+
+### Added
+- Introduction of Tenant Make
+- Introduction of 'system' type for dynamic attributes
+- Introduce Tenant Make to Traicie Specialists
+
+### Changed
+- Enable Specialist 'activation' / 'deactivation'
+- Unique constraints introduced for Catalog Name (tenant level) and make name (public level)
+
+## [2.3.3-alfa]
+
+### Added
+- Add Tenant Make
+- Add Chat Client customisation options to Tenant Make
+
+### Changed
+- Catalog name must be unique to avoid mistakes
+
+### Fixed
+- Ensure document version is selected in UI before trying to view it.
+- Remove obsolete tab from tenant overview
+
+## [2.3.2-alfa]
+
+### Added
+- Changelog display
+- Introduction of Specialist Magic Links
+
+### Fixed
+- dynamic fields for adding documents / urls to dossier catalog
+- tabs in latest bootstrap version no longer functional
+- partner association of license tier not working when no partner selected
+- data-type dynamic field needs conversion to isoformat
+- Add public tables to env.py of tenant schema
+
+## [2.3.1-alfa]
+
+### Added
+- Introduction of ordered_list dynamic field type (using tabulator)
+
+### Changed
+- Bring configuration of PROCESSOR_TYPES & CATALOG_TYPES to new config standard
+- Specialist Editor: move general information in tab
+- Role Definition Specialist creates Selection Specialist from generated competencies
+- Improvements to Selection Specialist (Agent definition to be started)
+
+## [2.3.0-alfa]
+
+### Added
+- Introduction of Push Gateway for Prometheus
+- Introduction of Partner Models
+- Introduction of Tenant and Partner codes for more security
+- Introduction of 'Management Partner' type and additional 'Partner Admin'-role
+- Introduction of a technical services layer
+- Introduction of partner-specific configurations
+- Introduction of additional test environment
+- Introduction of strict no-overage usage
+- Introduction of LicensePeriod, Payments & Invoices
+- Introduction of Processed File Viewer
+- Introduction of Traicie Role Definition Specialist
+- Allow invocation of non-interactive specialists in administrative interface (eveai_app)
+- Introduction of advanced JSON editor
+- Introduction of ChatSession (Specialist Execution) follow-up in administrative interface
+- Introduce npm for javascript libraries usage and optimisations
+- Introduction of new top bar in administrative interface to show session defaults (removing old navbar buttons)
+
+### Changed
+- Add 'Register'-button to list views, replacing register menu-items
+- Add additional environment capabilities in docker
+- PDF Processor now uses Mistral OCR
+- Allow additional chunking mechanisms for very long chunks (in case of very large documents)
+- Allow for TrackedMistralAIEmbedding batching to allow for processing long documents
+- RAG & SPIN Specialist improvements
+- Move mail messaging from standard SMTP to Scaleway TEM mails
+- Improve mail layouts
+- Add functionality to add a default dictionary for dynamic forms
+- AI model choices defined by Ask Eve AI iso Tenant (replaces ModelVariables completely)
+- Improve HTML Processing
+- Pagination improvements
+- Update Material Kit Pro to latest version
+
+### Removed
+- Repopack implementation ==> Using PyCharm's new AI capabilities instead
+
+### Fixed
+- Synchronous vs Asynchronous behaviour in crewAI type specialists
+- Nasty dynamic boolean fields bug corrected
+- Several smaller bugfixes
+- Tasks & Tools editors finished
+
+### Security
+- In case of vulnerabilities.
+
+## [2.2.0-alfa]
+
+### Added
+- Mistral AI as main provider for embeddings, chains and specialists
+- Usage measuring for specialists
+- RAG from chain to specialist technology
+- Dossier catalog management possibilities added to eveai_app
+- Asset definition (Paused - other priorities)
+- Prometheus and Grafana
+- Add prometheus monitoring to business events
+- Asynchronous execution of specialists
+
+### Changed
+- Moved choice for AI providers / models to specialists and prompts
+- Improve RAG to not repeat historic answers
+- Fixed embedding model, no more choices allowed
+- clean url (of tracking parameters) before adding it to a catalog
+
+### Deprecated
+- For soon-to-be removed features.
+
+### Removed
+- Add Multiple URLs removed from menu
+- Old Specialist items removed from interaction menu
+- 
+
+### Fixed
+- Set default language when registering Documents or URLs.
+
+## [2.1.0-alfa]
+
+### Added
+- Zapier Refresh Document
+- SPIN Specialist definition - from start to finish
+- Introduction of startup scripts in eveai_app
+- Caching for all configurations added
+- Caching for processed specialist configurations
+- Caching for specialist history
+- Augmented Specialist Editor, including Specialist graphic presentation
+- Introduction of specialist_execution_api, introducting SSE
+- Introduction of crewai framework for specialist implementation
+- Test app for testing specialists - also serves as a sample client application for SSE
+- 
+
+### Changed
+- Improvement of startup of applications using gevent, and better handling and scaling of multiple connections
+- STANDARD_RAG Specialist improvement
+- 
+
+### Deprecated
+- eveai_chat - using sockets - will be replaced with new specialist_execution_api and SSE
+
+## [2.0.1-alfa]
+
+### Added
+- Zapîer Integration (partial - only adding files).
+- Addition of general chunking parameters (chunking_heading_level and chunking_patterns)
+- Addition of DocX and markdown Processor Types
+
+### Changed
+- For changes in existing functionality.
+
+### Deprecated
+- For soon-to-be removed features.
+
+### Removed
+- For now removed features.
+
+### Fixed
+- Ensure the RAG Specialist is using the detailed_question
+- Wordpress Chat Plugin: languages dropdown filled again
+- OpenAI update - proxies no longer supported
+- Build & Release script for Wordpress Plugins (including end user download folder)
+
+### Security
+- In case of vulnerabilities.
+
+## [2.0.0-alfa]
+
+### Added
+- Introduction of dynamic Retrievers & Specialists
+- Introduction of dynamic Processors
+- Introduction of caching system
+- Introduction of a better template manager
+- Modernisation of external API/Socket authentication using projects
+- Creation of new eveai_chat WordPress plugin to support specialists
+
+### Changed
+- Update of eveai_sync WordPress plugin
+
+### Fixed
+- Set default language when registering Documents or URLs.
+
+### Security
+- Security improvements to Docker images
+
+## [1.0.14-alfa]
+
+### Added
+- New release script added to tag images with release number
+- Allow the addition of multiple types of Catalogs
+- Generic functionality to enable dynamic fields
+- Addition of Retrievers to allow for smart collection of information in Catalogs
+- Add dynamic fields to Catalog / Retriever / DocumentVersion
+
+### Changed
+- Processing parameters defined at Catalog level iso Tenant level
+- Reroute 'blank' paths to 'admin'
+
+### Deprecated
+- For soon-to-be removed features.
+
+### Removed
+- For now removed features.
+
+### Fixed
+- Set default language when registering Documents or URLs.
+
+### Security
+- In case of vulnerabilities.
+
+## [1.0.13-alfa]
+
+### Added
+- Finished Catalog introduction
+- Reinitialization of WordPress site for syncing
+
+### Changed
+- Modification of WordPress Sync Component
+- Cleanup of attributes in Tenant
+
+### Fixed
+- Overall bugfixes as result from the Catalog introduction
+
+## [1.0.12-alfa]
+
+### Added
+- Added Catalog functionality
+
+### Changed
+- For changes in existing functionality.
+
+### Deprecated
+- For soon-to-be removed features.
+
+### Removed
+- For now removed features.
+
+### Fixed
+- Set default language when registering Documents or URLs.
+
+### Security
+- In case of vulnerabilities.
+
+## [1.0.11-alfa]
+
+### Added
+- License Usage Calculation realised
+- View License Usages
+- Celery Beat container added
+- First schedule in Celery Beat for calculating usage (hourly)
+
+### Changed
+- repopack can now split for different components
+
+### Fixed
+- Various fixes as consequence of changing file_location / file_name ==> bucket_name / object_name
+- Celery Routing / Queuing updated
+
+## [1.0.10-alfa]
+
+### Added
+- BusinessEventLog monitoring using Langchain native code
+
+### Changed
+- Allow longer audio files (or video) to be uploaded and processed
+- Storage and Embedding usage now expressed in MiB iso tokens (more logical)
+- Views for License / LicenseTier
+
+### Removed
+- Portkey removed for monitoring usage
+
+## [1.0.9-alfa] - 2024/10/01
+
+### Added
+- Business Event tracing (eveai_workers & eveai_chat_workers)
+- Flower Container added for monitoring
+
+### Changed
+- Healthcheck improvements
+- model_utils turned into a class with lazy loading
+
+### Deprecated
+- For soon-to-be removed features.
+
+### Removed
+- For now removed features.
+
+### Fixed
+- Set default language when registering Documents or URLs.
+
+## [1.0.8-alfa] - 2024-09-12
+
+### Added
+- Tenant type defined to allow for active, inactive, demo ... tenants
+- Search and filtering functionality on Tenants
+- Implementation of health checks (1st version)
+- Provision for Prometheus monitoring (no implementation yet)
+- Refine audio_processor and srt_processor to reduce duplicate code and support larger files
+- Introduction of repopack to reason in LLMs about the code
+
+### Fixed
+- Refine audio_processor and srt_processor to reduce duplicate code and support larger files
+
+## [1.0.7-alfa] - 2024-09-12
+
+### Added
+- Full Document API allowing for creation, updating and invalidation of documents.
+- Metadata fields (JSON) added to DocumentVersion, allowing end-users to add structured information
+- Wordpress plugin eveai_sync to synchronize Wordpress content with EveAI
+
+### Fixed
+- Maximal deduplication of code between views and api in document_utils.py
+
+## [1.0.6-alfa] - 2024-09-03
+
+### Fixed
+- Problems with tenant scheme migrations - may have to be revisited
+- Correction of default language settings when uploading docs or URLs
+- Addition of a CHANGELOG.md file
+
+## [1.0.5-alfa] - 2024-09-02
+
+### Added
+- Allow chatwidget to connect to multiple servers (e.g. development and production)
+- Start implementation of API
+- Add API-key functionality to tenants
+- Deduplication of API and Document view code
+- Allow URL addition to accept all types of files, not just HTML
+- Allow new file types upload: srt, mp3, ogg, mp4
+- Improve processing of different file types using Processor classes
+
+### Removed
+- Removed direct upload of Youtube URLs, due to continuous changes in Youtube website
+
+## [1.0.4-alfa] - 2024-08-27
+Skipped
+
+## [1.0.3-alfa] - 2024-08-27
+
+### Added
+- Refinement of HTML processing - allow for excluded classes and elements.
+- Allow for multiple instances of Evie on 1 website (pure + Wordpress plugin)
+
+### Changed
+- PDF Processing extracted in new PDF Processor class.
+- Allow for longer and more complex PDFs to be uploaded.
+
+## [1.0.2-alfa] - 2024-08-22
+
+### Fixed
+- Bugfix for ResetPasswordForm in config.py
+
+## [1.0.1-alfa] - 2024-08-21
+
+### Added
+- Full Document Version Overview
+
+### Changed
+- Improvements to user creation and registration, renewal of passwords, ...
+
+## [1.0.0-alfa] - 2024-08-16
+
+### Added
+- Initial release of the project.
+
+### Changed
+- None
+
+### Fixed
+- None
+
+[Unreleased]: https://github.com/username/repo/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/username/repo/releases/tag/v1.0.0

content/privacy/1.0/1.0.0.md

@@ -0,0 +1,37 @@
+# Privacy Policy
+
+## Version 1.0.0
+
+*Effective Date: 2025-06-03*
+
+### 1. Introduction
+
+This Privacy Policy describes how EveAI collects, uses, and discloses your information when you use our services.
+
+### 2. Information We Collect
+
+We collect information you provide directly to us, such as account information, content you process through our services, and communication data.
+
+### 3. How We Use Your Information
+
+We use your information to provide, maintain, and improve our services, process transactions, send communications, and comply with legal obligations.
+
+### 4. Data Security
+
+We implement appropriate security measures to protect your personal information against unauthorized access, alteration, disclosure, or destruction.
+
+### 5. International Data Transfers
+
+Your information may be transferred to and processed in countries other than the country you reside in, where data protection laws may differ.
+
+### 6. Your Rights
+
+Depending on your location, you may have certain rights regarding your personal information, such as access, correction, deletion, or restriction of processing.
+
+### 7. Changes to This Policy
+
+We may update this Privacy Policy from time to time. We will notify you of any changes by posting the new Privacy Policy on this page.
+
+### 8. Contact Us
+
+If you have any questions about this Privacy Policy, please contact us at privacy@askeveai.be.

content/terms/1.0/1.0.0.md

@@ -0,0 +1,37 @@
+# Terms of Service
+
+## Version 1.0.0
+
+*Effective Date: 2025-06-03*
+
+### 1. Introduction
+
+Welcome to EveAI. By accessing or using our services, you agree to be bound by these Terms of Service.
+
+### 2. Service Description
+
+EveAI provides AI-powered solutions for businesses to optimize their operations through intelligent document processing and specialist execution.
+
+### 3. User Accounts
+
+To access certain features of the Service, you must register for an account. You are responsible for maintaining the confidentiality of your account information.
+
+### 4. Privacy
+
+Your use of the Service is also governed by our Privacy Policy, which can be found [here](/content/privacy).
+
+### 5. Intellectual Property
+
+All content, features, and functionality of the Service are owned by EveAI and are protected by international copyright, trademark, and other intellectual property laws.
+
+### 6. Limitation of Liability
+
+In no event shall EveAI be liable for any indirect, incidental, special, consequential or punitive damages.
+
+### 7. Changes to Terms
+
+We reserve the right to modify these Terms at any time. Your continued use of the Service after such modifications will constitute your acceptance of the new Terms.
+
+### 8. Governing Law
+
+These Terms shall be governed by the laws of Belgium.

docker/compose_dev.yaml

@@ -24,7 +24,7 @@ x-common-variables: &common-variables
   FLOWER_PASSWORD: 'Jungles'
   OPENAI_API_KEY: 'sk-proj-8R0jWzwjL7PeoPyMhJTZT3BlbkFJLb6HfRB2Hr9cEVFWEhU7'
   GROQ_API_KEY: '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'
-  MISTRAL_API_KEY: 'jGDc6fkCbt0iOC0jQsbuZhcjLWBPGc2b'
+  MISTRAL_API_KEY: '0f4ZiQ1kIpgIKTHX8d0a8GOD2vAgVqEn'
   ANTHROPIC_API_KEY: 'sk-ant-api03-c2TmkzbReeGhXBO5JxNH6BJNylRDonc9GmZd0eRbrvyekec2'
   JWT_SECRET_KEY: 'bsdMkmQ8ObfMD52yAFg4trrvjgjMhuIqg2fjDpD/JqvgY0ccCcmlsEnVFmR79WPiLKEA3i8a5zmejwLZKl4v9Q=='
   API_ENCRYPTION_KEY: 'xfF5369IsredSrlrYZqkM9ZNrfUASYYS6TCcAR9UKj4='
@@ -70,6 +70,7 @@ services:
     depends_on:
       - eveai_app
       - eveai_api
+      - eveai_chat_client
     networks:
       - eveai-network
 
@@ -91,6 +92,7 @@ services:
     volumes:
       - ../eveai_app:/app/eveai_app
       - ../common:/app/common
+      - ../content:/app/content
       - ../config:/app/config
       - ../migrations:/app/migrations
       - ../scripts:/app/scripts
@@ -176,6 +178,44 @@ services:
 #    networks:
 #      - eveai-network
 
+  eveai_chat_client:
+    image: josakola/eveai_chat_client:latest
+    build:
+      context: ..
+      dockerfile: ./docker/eveai_chat_client/Dockerfile
+      platforms:
+        - linux/amd64
+        - linux/arm64
+    ports:
+      - 5004:5004
+    expose:
+      - 8000
+    environment:
+      <<: *common-variables
+      COMPONENT_NAME: eveai_chat_client
+    volumes:
+      - ../eveai_chat_client:/app/eveai_chat_client
+      - ../common:/app/common
+      - ../config:/app/config
+      - ../scripts:/app/scripts
+      - ../patched_packages:/app/patched_packages
+      - ./eveai_logs:/app/logs
+    depends_on:
+      db:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      minio:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:5004/healthz/ready"]
+      interval: 30s
+      timeout: 1s
+      retries: 3
+      start_period: 30s
+    networks:
+      - eveai-network
+
   eveai_chat_workers:
     image: josakola/eveai_chat_workers:latest
     build:
@@ -440,4 +480,3 @@ volumes:
 #secrets:
 #  db-password:
 #    file: ./db/password.txt
-

docker/compose_test.yaml

@@ -26,7 +26,7 @@ x-common-variables: &common-variables
   REDIS_PORT: '6379'
   FLOWER_USER: 'Felucia'
   FLOWER_PASSWORD: 'Jungles'
-  MISTRAL_API_KEY: 'Vkwgr67vUs6ScKmcFF2QVw7uHKgq0WEN'
+  MISTRAL_API_KEY: 'qunKSaeOkFfLteNiUO77RCsXXSLK65Ec'
   JWT_SECRET_KEY: '7e9c8b3a215f4d6e90712c5d8f3b97a60e482c15f39a7d68bcd45910ef23a784'
   API_ENCRYPTION_KEY: 'kJ7N9p3IstyRGkluYTryM8ZMnfUBSXWR3TCfDG9VLc4='
   MINIO_ENDPOINT: minio:9000
@@ -56,6 +56,7 @@ services:
     depends_on:
       - eveai_app
       - eveai_api
+      - eveai_chat_client
     networks:
       - eveai-network
     restart: "no"
@@ -106,6 +107,33 @@ services:
       - eveai-network
     restart: "no"
 
+  eveai_chat_client:
+    image: josakola/eveai_chat_client:${EVEAI_VERSION:-latest}
+    ports:
+      - 5004:5004
+    expose:
+      - 8000
+    environment:
+      <<: *common-variables
+      COMPONENT_NAME: eveai_chat_client
+    volumes:
+      - eveai_logs:/app/logs
+      - crewai_storage:/app/crewai_storage
+    depends_on:
+      redis:
+        condition: service_healthy
+      minio:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:5004/healthz/ready"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    networks:
+      - eveai-network
+    restart: "no"
+
   eveai_chat_workers:
     image: josakola/eveai_chat_workers:${EVEAI_VERSION:-latest}
     expose:

docker/docker_env_switch.sh

@@ -115,15 +115,41 @@ echo "Set COMPOSE_FILE to $COMPOSE_FILE"
 echo "Set EVEAI_VERSION to $VERSION"
 echo "Set DOCKER_ACCOUNT to $DOCKER_ACCOUNT"
 
-# Define aliases for common Docker commands
-alias docker-compose="docker compose -f $COMPOSE_FILE"
-alias dc="docker compose -f $COMPOSE_FILE"
-alias dcup="docker compose -f $COMPOSE_FILE up -d --remove-orphans"
-alias dcdown="docker compose -f $COMPOSE_FILE down"
-alias dcps="docker compose -f $COMPOSE_FILE ps"
-alias dclogs="docker compose -f $COMPOSE_FILE logs"
-alias dcpull="docker compose -f $COMPOSE_FILE pull"
-alias dcrefresh="docker compose -f $COMPOSE_FILE pull && docker compose -f $COMPOSE_FILE up -d --remove-orphans"
+docker-compose() {
+  docker compose -f $COMPOSE_FILE "$@"
+}
+
+dc() {
+  docker compose -f $COMPOSE_FILE "$@"
+}
+
+dcup() {
+    docker compose -f $COMPOSE_FILE up -d --remove-orphans "$@"
+}
+
+dcdown() {
+    docker compose -f $COMPOSE_FILE down "$@"
+}
+
+dcps() {
+    docker compose -f $COMPOSE_FILE ps "$@"
+}
+
+dclogs() {
+    docker compose -f $COMPOSE_FILE logs "$@"
+}
+
+dcpull() {
+    docker compose -f $COMPOSE_FILE pull "$@"
+}
+
+dcrefresh() {
+    docker compose -f $COMPOSE_FILE pull && docker compose -f $COMPOSE_FILE up -d --remove-orphans "$@"
+}
+
+# Exporteer de functies zodat ze beschikbaar zijn in andere scripts
+export -f docker-compose dc dcup dcdown dcps dclogs dcpull dcrefresh
+
 
 echo "Docker environment switched to $ENVIRONMENT with version $VERSION"
 echo "You can now use 'docker-compose', 'dc', 'dcup', 'dcdown', 'dcps', 'dclogs', 'dcpull' or 'dcrefresh' commands"

docker/eveai_app/Dockerfile

@@ -56,6 +56,7 @@ COPY config /app/config
 COPY migrations /app/migrations
 COPY scripts /app/scripts
 COPY patched_packages /app/patched_packages
+COPY content /app/content
 
 # Set permissions for entrypoint script
 RUN chmod 777 /app/scripts/entrypoint.sh

docker/eveai_chat_client/Dockerfile

@@ -0,0 +1,72 @@
+ARG PYTHON_VERSION=3.12.7
+FROM python:${PYTHON_VERSION}-slim as base
+
+# Prevents Python from writing pyc files.
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Keeps Python from buffering stdout and stderr to avoid situations where
+# the application crashes without emitting any logs due to buffering.
+ENV PYTHONUNBUFFERED=1
+
+# Create directory for patched packages and set permissions
+RUN mkdir -p /app/patched_packages && \
+    chmod 777 /app/patched_packages
+
+# Ensure patches are applied to the application.
+ENV PYTHONPATH=/app/patched_packages:$PYTHONPATH
+
+WORKDIR /app
+
+# Create a non-privileged user that the app will run under.
+# See https://docs.docker.com/go/dockerfile-user-best-practices/
+ARG UID=10001
+RUN adduser \
+    --disabled-password \
+    --gecos "" \
+    --home "/nonexistent" \
+    --shell "/bin/bash" \
+    --no-create-home \
+    --uid "${UID}" \
+    appuser
+
+# Install necessary packages and build tools
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    postgresql-client \
+    curl \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create logs directory and set permissions
+RUN mkdir -p /app/logs && chown -R appuser:appuser /app/logs
+
+# Download dependencies as a separate step to take advantage of Docker's caching.
+# Leverage a cache mount to /root/.cache/pip to speed up subsequent builds.
+# Leverage a bind mount to requirements.txt to avoid having to copy them into
+# into this layer.
+
+COPY requirements.txt /app/
+RUN python -m pip install -r /app/requirements.txt
+
+# Copy the source code into the container.
+COPY eveai_chat_client /app/eveai_chat_client
+COPY common /app/common
+COPY config /app/config
+COPY scripts /app/scripts
+COPY patched_packages /app/patched_packages
+COPY content /app/content
+
+# Set permissions for scripts
+RUN chmod 777 /app/scripts/entrypoint.sh && \
+    chmod 777 /app/scripts/start_eveai_chat_client.sh
+
+# Set ownership of the application directory to the non-privileged user
+RUN chown -R appuser:appuser /app
+
+# Expose the port that the application listens on.
+EXPOSE 5004
+
+# Set entrypoint and command
+ENTRYPOINT ["/app/scripts/entrypoint.sh"]
+CMD ["/app/scripts/start_eveai_chat_client.sh"]

docker/rebuild_chat_client.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+source ./docker_env_switch.sh dev
+source .env
+
+dcdown eveai_chat_client nginx
+./update_chat_client_statics.sh
+./build_and_push_eveai.sh -b nginx
+dcup eveai_chat_client nginx

docker/update_chat_client_statics.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+# Script to copy eveai_chat_client/static files to nginx/static
+# without overwriting existing files
+
+SRC_DIR="../eveai_chat_client/static/assets"
+DEST_DIR="../nginx/static/assets"
+
+# Check if source directory exists
+if [ ! -d "$SRC_DIR" ]; then
+  echo "Error: Source directory $SRC_DIR does not exist!"
+  exit 1
+fi
+
+# Create destination directory if it doesn't exist
+if [ ! -d "$DEST_DIR" ]; then
+  echo "Destination directory $DEST_DIR does not exist. Creating it..."
+  mkdir -p "$DEST_DIR"
+fi
+
+# Function to recursively copy files without overwriting
+copy_without_overwrite() {
+  local src=$1
+  local dest=$2
+
+  # Loop through all items in source directory
+  for item in "$src"/*; do
+    # Get the filename from the path
+    base_name=$(basename "$item")
+
+    # If it's a directory, create it in the destination and recurse
+    if [ -d "$item" ]; then
+      if [ ! -d "$dest/$base_name" ]; then
+        echo "Creating directory: $dest/$base_name"
+        mkdir -p "$dest/$base_name"
+      fi
+      copy_without_overwrite "$item" "$dest/$base_name"
+    else
+      # If it's a file and doesn't exist in the destination, copy it
+      cp "$item" "$dest/$base_name"
+    fi
+  done
+}
+
+# Start the copy process
+echo "Starting to copy files from $SRC_DIR to $DEST_DIR..."
+copy_without_overwrite "$SRC_DIR" "$DEST_DIR"
+
+echo "Copy completed!"

documentation/Eveai Chat Client Developer Documentation.md

@@ -0,0 +1,516 @@
+# Evie Chat Client - Developer Documentation
+
+## Overview
+
+The Evie Chat Client is a modern, customizable chat interface for interacting with eveai specialists. It supports both anonymous and authenticated modes, with initial focus on anonymous mode. The client provides real-time interaction with AI specialists, customizable tenant branding, European-compliant analytics tracking, and secure QR code access.
+
+## Key Features
+
+- **Anonymous Mode**: Public access with tenant UUID and API key authentication
+- **QR Code Access**: Secure pre-authenticated landing pages for QR code integration
+- **Real-time Communication**: Server-Sent Events (SSE) for live updates and intermediate states
+- **Tenant Customization**: Simple CSS variable-based theming with visual editor
+- **Multiple Choice Options**: Dynamic button/dropdown responses from specialists
+- **Chat History**: Persistent ChatSession and Interaction storage
+- **File Upload Support**: Planned for future implementation
+- **European Analytics**: Umami integration for GDPR-compliant tracking
+
+## Architecture
+
+### Project Structure
+
+```
+evie-project/
+├── common/                         # Shared code across components
+│   ├── services/                   # Reusable business logic
+│   │   ├── chat_service.py         # Chat session management
+│   │   ├── specialist_service.py   # Specialist interaction wrapper
+│   │   ├── tenant_service.py       # Tenant config & theming
+│   │   └── qr_service.py           # QR code session management
+│   └── utils/                      # Utility functions
+│       ├── auth.py                 # API key validation
+│       ├── tracking.py             # Umami analytics integration
+│       └── qr_utils.py             # QR code generation utilities
+├── eveai_chat_client/              # Chat client component
+│   ├── app.py                      # Flask app entry point
+│   ├── routes/
+│   │   ├── __init__.py
+│   │   ├── chat_routes.py          # Main chat interface routes
+│   │   ├── api_routes.py           # SSE/API endpoints
+│   │   └── qr_routes.py            # QR code landing pages
+│   └── templates/
+│       ├── base.html               # Base template
+│       ├── chat.html               # Main chat interface
+│       ├── qr_expired.html         # QR code error page
+│       └── components/
+│           ├── message.html        # Individual message component
+│           ├── options.html        # Multiple choice options
+│           └── thinking.html       # Intermediate states display
+└── eveai_app/                      # Admin interface (existing)
+    └── qr_management/              # QR code creation interface
+        ├── create_qr.py
+        └── qr_templates.html
+```
+
+### Integration Approach
+
+- **Services Layer**: Direct integration with common/services for better performance
+- **Database**: Utilizes existing ChatSession and Interaction models
+- **Caching**: Leverages existing Redis setup
+- **Static Files**: Uses existing nginx/static structure
+
+## QR Code Access Flow
+
+### QR Code System Architecture
+
+```mermaid
+sequenceDiagram
+    participant Admin as Admin (eveai_app)
+    participant QRService as QR Service (common)
+    participant PublicDB as Public Schema
+    participant TenantDB as Tenant Schema
+    participant User as End User
+    participant ChatClient as Chat Client
+    participant ChatSession as Chat Session
+
+    %% QR Code Creation Flow
+    Admin->>QRService: Create QR code with specialist config
+    QRService->>PublicDB: Store qr_lookup (qr_id → tenant_code)
+    QRService->>TenantDB: Store qr_sessions (full config + args)
+    QRService->>Admin: Return QR code image with /qr/{qr_id}
+
+    %% QR Code Usage Flow
+    User->>ChatClient: Scan QR → GET /qr/{qr_id}
+    ChatClient->>PublicDB: Lookup tenant_code by qr_id
+    ChatClient->>TenantDB: Get full QR session data
+    ChatClient->>ChatSession: Create ChatSession with pre-filled args
+    ChatClient->>User: Set temp auth + redirect to chat interface
+    User->>ChatClient: Access chat with pre-authenticated session
+```
+
+### QR Code Data Flow
+
+```mermaid
+flowchart TD
+    A[Admin Creates QR Code] --> B[Generate UUID for QR Session]
+    B --> C[Store Lookup in Public Schema]
+    C --> D[Store Full Data in Tenant Schema]
+    D --> E[Generate QR Code Image]
+    
+    F[User Scans QR Code] --> G[Extract QR Session ID from URL]
+    G --> H[Lookup Tenant Code in Public Schema]
+    H --> I[Retrieve Full QR Data from Tenant Schema]
+    I --> J{QR Valid & Not Expired?}
+    J -->|No| K[Show Error Page]
+    J -->|Yes| L[Create ChatSession with Pre-filled Args]
+    L --> M[Set Temporary Browser Authentication]
+    M --> N[Redirect to Chat Interface]
+    N --> O[Start Chat with Specialist]
+```
+
+## URL Structure & Parameters
+
+### Main Chat Interface
+```
+GET /chat/{tenant_code}/{specialist_id}
+```
+
+**Query Parameters:**
+- `api_key` (required for direct access): Tenant API key for authentication
+- `session` (optional): Existing chat session ID
+- `utm_source`, `utm_campaign`, `utm_medium` (optional): Analytics tracking
+
+**Examples:**
+```
+# Direct access
+/chat/550e8400-e29b-41d4-a716-446655440000/document-analyzer?api_key=xxx&utm_source=email
+
+# QR code access (after redirect)
+/chat/550e8400-e29b-41d4-a716-446655440000/document-analyzer?session=abc123-def456
+```
+
+### QR Code Landing Pages
+```
+GET /qr/{qr_session_id}    # QR code entry point (redirects, no HTML page)
+```
+
+### API Endpoints
+```
+POST /api/chat/{tenant_code}/interact         # Send message to specialist
+GET  /api/chat/{tenant_code}/status/{session_id}  # SSE endpoint for updates
+```
+
+## Authentication & Security
+
+### Anonymous Mode Access Methods
+
+1. **Direct Access**: URL with API key parameter
+2. **QR Code Access**: Pre-authenticated via secure landing page
+
+### QR Code Security Model
+- **QR Code Contains**: Only a UUID session identifier
+- **Sensitive Data**: Stored securely in tenant database schema
+- **Usage Control**: Configurable expiration and usage limits
+- **Audit Trail**: Track QR code creation and usage
+
+### Security Considerations
+- Use tenant UUIDs to prevent enumeration attacks
+- Validate API keys against tenant database
+- Implement CORS policies for cross-origin requests
+- Sanitize all user messages and file uploads
+- QR sessions have configurable expiration and usage limits
+
+## QR Code Management
+
+### Database Schema
+
+#### Public Schema (Routing Only)
+```sql
+CREATE TABLE qr_lookup (
+    qr_session_id UUID PRIMARY KEY,
+    tenant_code UUID NOT NULL,
+    created_at TIMESTAMP DEFAULT NOW(),
+    INDEX idx_tenant_code (tenant_code)
+);
+```
+
+#### Tenant Schema (Full QR Data)
+```sql
+CREATE TABLE qr_sessions (
+    id UUID PRIMARY KEY,
+    specialist_id UUID NOT NULL,
+    api_key VARCHAR(255) NOT NULL,
+    specialist_args JSONB,
+    metadata JSONB,
+    created_at TIMESTAMP DEFAULT NOW(),
+    expires_at TIMESTAMP,
+    usage_count INTEGER DEFAULT 0,
+    usage_limit INTEGER,
+    created_by_user_id UUID
+);
+```
+
+### QR Code Creation (eveai_app)
+```python
+# In eveai_app admin interface
+from common.services.qr_service import QRService
+
+def create_specialist_qr_code():
+    qr_data = {
+        'tenant_code': current_tenant.code,
+        'specialist_id': selected_specialist.id,
+        'api_key': current_tenant.api_key,
+        'specialist_args': {
+            'department': 'sales',
+            'language': 'en',
+            'context': 'product_inquiry'
+        },
+        'metadata': {
+            'name': 'Sales Support QR - Product Brochure',
+            'usage_limit': 500,
+            'expires_days': 90
+        }
+    }
+    
+    qr_service = QRService()
+    qr_session_id, qr_image = qr_service.create_qr_session(qr_data)
+    return qr_image
+```
+
+### QR Code Processing (eveai_chat_client)
+```python
+# In eveai_chat_client routes
+from common.services.qr_service import QRService
+from common.services.chat_service import ChatService
+
+@app.route('/qr/<qr_session_id>')
+def handle_qr_code(qr_session_id):
+    qr_service = QRService()
+    qr_data = qr_service.get_and_validate_qr_session(qr_session_id)
+    
+    if not qr_data:
+        return render_template('qr_expired.html'), 410
+    
+    # Create ChatSession with pre-filled arguments
+    chat_service = ChatService()
+    chat_session = chat_service.create_session(
+        tenant_code=qr_data['tenant_code'],
+        specialist_id=qr_data['specialist_id'],
+        initial_args=qr_data['specialist_args'],
+        source='qr_code'
+    )
+    
+    # Set temporary authentication
+    flask_session['qr_auth'] = {
+        'tenant_code': qr_data['tenant_code'],
+        'api_key': qr_data['api_key'],
+        'chat_session_id': chat_session.id,
+        'expires_at': datetime.utcnow() + timedelta(hours=24)
+    }
+    
+    # Redirect to chat interface
+    return redirect(f"/chat/{qr_data['tenant_code']}/{qr_data['specialist_id']}?session={chat_session.id}")
+```
+
+## Real-time Communication
+
+### Server-Sent Events (SSE)
+- **Connection**: Long-lived SSE connection per chat session
+- **Message Types**:
+  - `message`: Complete specialist response
+  - `thinking`: Intermediate processing states
+  - `options`: Multiple choice response options
+  - `error`: Error messages
+  - `complete`: Interaction completion
+
+### SSE Message Format
+```json
+{
+  "type": "thinking",
+  "data": {
+    "message": "Analyzing your request...",
+    "step": 1,
+    "total_steps": 3
+  }
+}
+```
+
+## Tenant Customization
+
+### Theme Configuration
+Stored in tenant table as JSONB column:
+```sql
+ALTER TABLE tenants ADD COLUMN theme_config JSONB;
+```
+
+### CSS Variables Approach
+Inline CSS variables in chat template:
+```css
+:root {
+  /* Brand Colors */
+  --primary-color: {{ tenant.theme_config.primary_color or '#007bff' }};
+  --secondary-color: {{ tenant.theme_config.secondary_color or '#6c757d' }};
+  --accent-color: {{ tenant.theme_config.accent_color or '#28a745' }};
+  
+  /* Chat Interface */
+  --user-message-bg: {{ tenant.theme_config.user_message_bg or 'var(--primary-color)' }};
+  --bot-message-bg: {{ tenant.theme_config.bot_message_bg or '#f8f9fa' }};
+  --chat-bg: {{ tenant.theme_config.chat_bg or '#ffffff' }};
+  
+  /* Typography */
+  --font-family: {{ tenant.theme_config.font_family or 'system-ui, -apple-system, sans-serif' }};
+  --font-size-base: {{ tenant.theme_config.font_size or '16px' }};
+  
+  /* Branding */
+  --logo-url: url('/api/tenant/{{ tenant.code }}/logo');
+  --header-bg: {{ tenant.theme_config.header_bg or 'var(--primary-color)' }};
+}
+```
+
+### Theme Editor (eveai_app)
+Simple form interface with:
+- Color pickers for brand colors
+- Font selection dropdown
+- Logo upload functionality
+- Live preview of chat interface
+- Reset to defaults option
+
+## Multiple Choice Options
+
+### Dynamic Rendering Logic
+```python
+def render_options(options_list):
+    if len(options_list) <= 3:
+        return render_template('components/options.html', 
+                             display_type='buttons', 
+                             options=options_list)
+    else:
+        return render_template('components/options.html', 
+                             display_type='dropdown', 
+                             options=options_list)
+```
+
+### Option Data Structure
+```json
+{
+  "type": "options",
+  "data": {
+    "question": "How would you like to proceed?",
+    "options": [
+      {"id": "option1", "text": "Continue analysis", "value": "continue"},
+      {"id": "option2", "text": "Generate report", "value": "report"},
+      {"id": "option3", "text": "Start over", "value": "restart"}
+    ]
+  }
+}
+```
+
+## Analytics Integration
+
+### Umami Setup
+- **European Hosting**: Self-hosted Umami instance
+- **Privacy Compliant**: No cookies, GDPR compliant by design
+- **Tracking Events**:
+  - Chat session start (including QR code source)
+  - Message sent
+  - Option selected
+  - Session duration
+  - Specialist interaction completion
+  - QR code usage
+
+### Tracking Implementation
+```javascript
+// Track chat events
+function trackEvent(eventName, eventData) {
+  if (window.umami) {
+    umami.track(eventName, eventData);
+  }
+}
+
+// Track QR code usage
+function trackQRUsage(qrSessionId, tenantCode) {
+  trackEvent('qr_code_used', {
+    qr_session_id: qrSessionId,
+    tenant_code: tenantCode
+  });
+}
+```
+
+## File Upload Support (Future)
+
+### Planned Implementation
+- **Multipart Upload**: Standard HTML5 file upload
+- **File Types**: Documents, images, spreadsheets
+- **Storage**: Tenant-specific S3 buckets
+- **Processing**: Integration with existing document processing pipeline
+- **UI**: Drag-and-drop interface with progress indicators
+
+### Security Considerations
+- File type validation
+- Size limits per tenant
+- Virus scanning integration
+- Temporary file cleanup
+
+## Development Guidelines
+
+### Code Organization
+- **Services**: Place reusable business logic in `common/services/`
+- **Utils**: Place utility functions in `common/utils/`
+- **Multi-tenant**: Maintain data isolation using existing patterns
+- **Error Handling**: Implement proper error handling and logging
+
+### Service Layer Examples
+```python
+# common/services/qr_service.py
+class QRService:
+    def create_qr_session(self, qr_data):
+        # Create QR session with hybrid storage approach
+        pass
+    
+    def get_and_validate_qr_session(self, qr_session_id):
+        # Validate and retrieve QR session data
+        pass
+
+# common/services/chat_service.py  
+class ChatService:
+    def create_session(self, tenant_code, specialist_id, initial_args=None, source='direct'):
+        # Create chat session with optional pre-filled arguments
+        pass
+```
+
+### Testing Strategy
+- Unit tests for services and utilities in `common/`
+- Integration tests for chat flow including QR code access
+- UI tests for theme customization
+- Load testing for SSE connections
+- Cross-browser compatibility testing
+
+### Performance Considerations
+- Cache tenant configurations in Redis
+- Cache QR session lookups in Redis
+- Optimize SSE connection management
+- Implement connection pooling for database
+- Use CDN for static assets
+- Monitor real-time connection limits
+
+## Deployment
+
+### Container Configuration
+- New `eveai_chat_client` container
+- Integration with existing docker setup
+- Environment configuration for tenant isolation
+- Load balancer configuration for SSE connections
+
+### Dependencies
+- Flask and Flask-restx (existing)
+- Celery integration (existing)
+- PostgreSQL and Redis (existing)
+- Umami analytics client library
+- QR code generation library (qrcode)
+
+## Future Enhancements
+
+### Authenticated Mode
+- User login integration
+- Session persistence across devices
+- Advanced specialist access controls
+- User-specific chat history
+
+### Advanced Features
+- Voice message support
+- Screen sharing capabilities
+- Collaborative chat sessions
+- Advanced analytics dashboard
+- Mobile app integration
+
+## Configuration Examples
+
+### Environment Variables
+```bash
+CHAT_CLIENT_PORT=5000
+TENANT_API_VALIDATION_CACHE_TTL=3600
+SSE_CONNECTION_TIMEOUT=300
+QR_SESSION_DEFAULT_EXPIRY_DAYS=30
+QR_SESSION_MAX_USAGE_LIMIT=1000
+UMAMI_WEBSITE_ID=your-website-id
+UMAMI_SCRIPT_URL=https://your-umami.domain/script.js
+```
+
+### Sample Theme Configuration
+```json
+{
+  "primary_color": "#2563eb",
+  "secondary_color": "#64748b",
+  "accent_color": "#059669",
+  "user_message_bg": "#2563eb",
+  "bot_message_bg": "#f1f5f9",
+  "chat_bg": "#ffffff",
+  "font_family": "Inter, system-ui, sans-serif",
+  "font_size": "16px",
+  "header_bg": "#1e40af"
+}
+```
+
+### Sample QR Session Data
+```json
+{
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "tenant_code": "123e4567-e89b-12d3-a456-426614174000",
+  "specialist_id": "789e0123-e45f-67g8-h901-234567890123",
+  "api_key": "tenant_api_key_here",
+  "specialist_args": {
+    "department": "technical_support",
+    "product_category": "software",
+    "priority": "high",
+    "language": "en"
+  },
+  "metadata": {
+    "name": "Technical Support QR - Software Issues",
+    "created_by": "admin_user_id",
+    "usage_limit": 100,
+    "expires_at": "2025-09-01T00:00:00Z"
+  }
+}
+```
+
+This documentation provides a comprehensive foundation for developing the Evie Chat Client with secure QR code integration while maintaining consistency with the existing eveai multi-tenant architecture.

eveai_api/__init__.py

@@ -12,7 +12,7 @@ import logging.config
 from common.models.user import TenantDomain
 from common.utils.cors_utils import get_allowed_origins
 from common.utils.database import Database
-from config.logging_config import LOGGING
+from config.logging_config import configure_logging
 from .api.document_api import document_ns
 from .api.auth import auth_ns
 from .api.specialist_execution_api import specialist_execution_ns
@@ -40,7 +40,7 @@ def create_app(config_file=None):
     app.celery = make_celery(app.name, app.config)
     init_celery(app.celery, app)
 
-    logging.config.dictConfig(LOGGING)
+    configure_logging()
     logger = logging.getLogger(__name__)
 
     logger.info("eveai_api starting up")

eveai_app/__init__.py

@@ -7,15 +7,15 @@ from werkzeug.middleware.proxy_fix import ProxyFix
 import logging.config
 
 from common.extensions import (db, migrate, bootstrap, security, login_manager, cors, csrf, session,
-                               minio_client, simple_encryption, metrics, cache_manager)
+                               minio_client, simple_encryption, metrics, cache_manager, content_manager)
 from common.models.user import User, Role, Tenant, TenantDomain
 import common.models.interaction
 import common.models.entitlements
 import common.models.document
 from common.utils.startup_eveai import perform_startup_actions
-from config.logging_config import LOGGING
+from config.logging_config import configure_logging
 from common.utils.security import set_tenant_session_data
-from .errors import register_error_handlers
+from common.utils.errors import register_error_handlers
 from common.utils.celery_utils import make_celery, init_celery
 from common.utils.template_filters import register_filters
 from config.config import get_config
@@ -47,8 +47,16 @@ def create_app(config_file=None):
     except OSError:
         pass
 
-    logging.config.dictConfig(LOGGING)
-    logger = logging.getLogger(__name__)
+    # Configureer logging op basis van de omgeving (K8s of traditioneel)
+    try:
+        configure_logging()
+        logger = logging.getLogger(__name__)
+        # Test dat logging werkt
+        logger.debug("Logging test in eveai_app")
+    except Exception as e:
+        print(f"Critical Error Initialising Error: {str(e)}")
+        import traceback
+        traceback.print_exc()
 
     logger.info("eveai_app starting up")
 
@@ -92,6 +100,45 @@ def create_app(config_file=None):
     #     app.logger.debug(f"Before request - Session data: {session}")
     #     app.logger.debug(f"Before request - Request headers: {request.headers}")
 
+    @app.before_request
+    def before_request():
+        from flask import session, request
+        from flask_login import current_user
+        import datetime
+
+        app.logger.debug(f"Before request - URL: {request.url}")
+        app.logger.debug(f"Before request - Session permanent: {session.permanent}")
+
+        # Log session expiry tijd als deze bestaat
+        if current_user.is_authenticated:
+            # Controleer of sessie permanent is (nodig voor PERMANENT_SESSION_LIFETIME)
+            if not session.permanent:
+                session.permanent = True
+                app.logger.debug("Session marked as permanent (enables 60min timeout)")
+
+            # Log wanneer sessie zou verlopen
+            if '_permanent' in session:
+                expires_at = datetime.datetime.now() + app.permanent_session_lifetime
+                app.logger.debug(f"Session will expire at: {expires_at} (60 min from now)")
+
+    @app.route('/debug/session')
+    def debug_session():
+        from flask import session
+        from flask_security import current_user
+        import datetime
+
+        if current_user.is_authenticated:
+            info = {
+                'session_permanent': session.permanent,
+                'session_lifetime_minutes': app.permanent_session_lifetime.total_seconds() / 60,
+                'session_refresh_enabled': app.config.get('SESSION_REFRESH_EACH_REQUEST'),
+                'current_time': datetime.datetime.now().isoformat(),
+                'session_data_keys': list(session.keys())
+            }
+            return jsonify(info)
+        else:
+            return jsonify({'error': 'Not authenticated'})
+
     # Register template filters
     register_filters(app)
 
@@ -124,6 +171,7 @@ def register_extensions(app):
     minio_client.init_app(app)
     cache_manager.init_app(app)
     metrics.init_app(app)
+    content_manager.init_app(app)
 
 
 def register_blueprints(app):
@@ -153,8 +201,3 @@ def register_cache_handlers(app):
     register_specialist_cache_handlers(cache_manager)
     from common.utils.cache.license_cache import register_license_cache_handlers
     register_license_cache_handlers(cache_manager)
-
-
-
-
-

eveai_app/templates/base.html

@@ -54,6 +54,7 @@
         <hr>
         {% include 'footer.html' %}
         {% include 'scripts.html' %}
+        {% include 'ordered_list_configs.html' %}
         {% block scripts %}{% endblock %}
     </body>
-</html>
+</html>

eveai_app/templates/basic/view_markdown.html

@@ -0,0 +1,102 @@
+{% extends "base.html" %}
+{% block title %}{{ title }}{% endblock %}
+
+{% block content_title %}{{ title }}{% endblock %}
+{% block content_description %}{{ description }}{% endblock %}
+
+{% block content %}
+<div class="container mt-5">
+    <div class="card">
+        <div class="card-header bg-light d-flex justify-content-between align-items-center">
+            <div class="btn-group" role="group">
+                <button class="btn btn-sm btn-outline-secondary" id="showRaw">Show Raw</button>
+                <button class="btn btn-sm btn-outline-primary active" id="showRendered">Show Rendered</button>
+            </div>
+        </div>
+        <div class="card-body">
+            <!-- Raw markdown view (hidden by default) -->
+            <div id="rawMarkdown" class="code-wrapper" style="display: none;">
+                <pre><code class="language-markdown">{{ markdown_content }}</code></pre>
+            </div>
+
+            <!-- Rendered markdown view -->
+            <div id="renderedMarkdown" class="markdown-body">
+                {{ markdown_content | markdown }}
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %}
+
+{% block styles %}
+{{ super() }}
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@4.0.0/github-markdown.min.css">
+<style>
+    pre, code {
+        margin: 0;
+        padding: 0;
+        white-space: pre-wrap !important;
+        word-wrap: break-word !important;
+        max-width: 100%;
+    }
+
+    pre code {
+        padding: 1rem !important;
+        border-radius: 4px;
+        font-size: 0.75rem;
+        line-height: 1.5;
+        white-space: pre-wrap !important;
+    }
+
+    .code-wrapper {
+        position: relative;
+        width: 100%;
+    }
+
+    .markdown-body {
+        padding: 1rem;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+        line-height: 1.6;
+    }
+
+    /* Dark mode styling (optional) */
+    @media (prefers-color-scheme: dark) {
+        .markdown-body {
+            color: #c9d1d9;
+            background-color: #0d1117;
+        }
+    }
+</style>
+{% endblock %}
+
+{% block scripts %}
+{{ super() }}
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    // Initialize syntax highlighting
+    document.querySelectorAll('pre code').forEach((block) => {
+        hljs.highlightElement(block);
+    });
+
+    // Toggle buttons for display
+    const showRawBtn = document.getElementById('showRaw');
+    const showRenderedBtn = document.getElementById('showRendered');
+    const rawMarkdown = document.getElementById('rawMarkdown');
+    const renderedMarkdown = document.getElementById('renderedMarkdown');
+
+    showRawBtn.addEventListener('click', function() {
+        rawMarkdown.style.display = 'block';
+        renderedMarkdown.style.display = 'none';
+        showRawBtn.classList.add('active');
+        showRenderedBtn.classList.remove('active');
+    });
+
+    showRenderedBtn.addEventListener('click', function() {
+        rawMarkdown.style.display = 'none';
+        renderedMarkdown.style.display = 'block';
+        showRawBtn.classList.remove('active');
+        showRenderedBtn.classList.add('active');
+    });
+});
+</script>
+{% endblock %}

eveai_app/templates/document/document_versions.html

@@ -4,17 +4,19 @@
 {% block title %}Document Versions{% endblock %}
 
 {% block content_title %}Document Versions{% endblock %}
-{% block content_description %}View Versions for {{ document }}{% endblock %}
-{% block content_class %}<div class="col-xl-12 col-lg-5 col-md-7 mx-auto">{% endblock %}
+{% block content_description %}View Versions for Document <b>{{ document }}</b>{% endblock %}
+{% block content_class %}<div class="col-xl-12 col-lg-5 col-md-7 mx-auto"></div>{% endblock %}
 
 {% block content %}
 <div class="container">
-    <form method="POST" action="{{ url_for('document_bp.handle_document_version_selection') }}">
-        {{ render_selectable_table(headers=["ID", "URL", "Object Name", "File Type", "Process.", "Proces. Start", "Proces. Finish", "Proces. Error"], rows=rows, selectable=True, id="versionsTable") }}
-        <div class="form-group mt-3">
-            <button type="submit" name="action" value="edit_document_version" class="btn btn-primary">Edit Document Version</button>
-            <button type="submit" name="action" value="view_document_version_markdown" class="btn btn-danger">View Processed Document</button>
-            <button type="submit" name="action" value="process_document_version" class="btn btn-danger">Process Document Version</button>
+    <form method="POST" action="{{ url_for('document_bp.handle_document_version_selection') }}" id="documentVersionsForm">
+        {{ render_selectable_table(headers=["ID", "File Type", "File Size", "Process.", "Proces. Start", "Proces. Finish", "Proces. Error"], rows=rows, selectable=True, id="versionsTable") }}
+        <div class="form-group mt-3 d-flex justify-content-between">
+            <div>
+                <button type="submit" name="action" value="edit_document_version" class="btn btn-primary" onclick="return validateTableSelection('documentVersionsForm')">Edit Document Version</button>
+                <button type="submit" name="action" value="view_document_version_markdown" class="btn btn-danger" onclick="return validateTableSelection('documentVersionsForm')">View Processed Document</button>
+                <button type="submit" name="action" value="process_document_version" class="btn btn-danger" onclick="return validateTableSelection('documentVersionsForm')">Process Document Version</button>
+            </div>
         </div>
     </form>
 </div>

eveai_app/templates/document/document_versions_list_view.html

@@ -37,7 +37,7 @@
             <div class="form-group mt-3 d-flex justify-content-between">
                 <div>
                     <button type="submit" name="action" value="edit_document_version" class="btn btn-primary" onclick="return validateTableSelection('documentVersionsForm')">Edit Document Version</button>
-                    <button type="submit" name="action" value="view_document_version_markdown" class="btn btn-danger">View Processed Document</button>
+                    <button type="submit" name="action" value="view_document_version_markdown" class="btn btn-danger" onclick="return validateTableSelection('documentVersionsForm')">View Processed Document</button>
                     <button type="submit" name="action" value="process_document_version" class="btn btn-danger" onclick="return validateTableSelection('documentVersionsForm')">Process Document Version</button>
                 </div>
             </div>

eveai_app/templates/document/documents.html

@@ -4,14 +4,13 @@
 {% block title %}Documents{% endblock %}
 
 {% block content_title %}Documents{% endblock %}
-{% block content_description %}View Documents for Tenant{% endblock %}
+{% block content_description %}View Documents for Catalog <b>{% if session.catalog_name %}{{ session.catalog_name }}{% else %}No Catalog{% endif %}</b>{% endblock %}
 {% block content_class %}<div class="col-xl-12 col-lg-5 col-md-7 mx-auto"></div>{% endblock %}
 
 {% block content %}
     <!-- Filter Form -->
     {% set filter_form %}
         <form method="GET" action="{{ url_for('document_bp.documents') }}">
-            {{ render_filter_field('catalog_id', 'Catalog', filter_options['catalog_id'], filters.get('catalog_id', [])) }}
             {{ render_filter_field('validity', 'Validity', filter_options['validity'], filters.get('validity', [])) }}
 
             <button type="submit" class="btn btn-primary">Apply Filters</button>
@@ -27,7 +26,6 @@
                 headers=[
                     {"text": "ID", "sort": "id"},
                     {"text": "Name", "sort": "name"},
-                    {"text": "Catalog", "sort": "catalog_name"},
                     {"text": "Valid From", "sort": "valid_from"},
                     {"text": "Valid To", "sort": "valid_to"}
                 ],

eveai_app/templates/document/edit_processor.html

@@ -4,7 +4,7 @@
 {% block title %}Edit Processor{% endblock %}
 
 {% block content_title %}Edit Processor{% endblock %}
-{% block content_description %}Edit a Processor (for a Catalog){% endblock %}
+{% block content_description %}Edit Processor for Catalog <b>{% if session.catalog_name %}{{ session.catalog_name }}{% else %}No Catalog{% endif %}</b>{% endblock %}
 
 {% block content %}
     <form method="post">

eveai_app/templates/document/edit_retriever.html

@@ -4,7 +4,7 @@
 {% block title %}Edit Retriever{% endblock %}
 
 {% block content_title %}Edit Retriever{% endblock %}
-{% block content_description %}Edit a Retriever (for a Catalog){% endblock %}
+{% block content_description %}Edit a Retriever for catalog <b>{% if session.catalog_name %}{{ session.catalog_name }}{% else %}No Catalog{% endif %}</b>{% endblock %}
 
 {% block content %}
     <form method="post">

eveai_app/templates/document/processor.html

@@ -4,7 +4,7 @@
 {% block title %}Processor Registration{% endblock %}
 
 {% block content_title %}Register Processor{% endblock %}
-{% block content_description %}Define a new processor (for a catalog){% endblock %}
+{% block content_description %}Define a new processor for Catalog <b>{% if session.catalog_name %}{{ session.catalog_name }}{% else %}No Catalog{% endif %}</b>{% endblock %}
 
 {% block content %}
     <form method="post">

eveai_app/templates/document/processors.html

@@ -4,13 +4,13 @@
 {% block title %}Processors{% endblock %}
 
 {% block content_title %}Processors{% endblock %}
-{% block content_description %}View Processors for Tenant{% endblock %}
+{% block content_description %}View Processors for Catalog <b>{% if session.catalog_name %}{{ session.catalog_name }}{% else %}No Catalog{% endif %}</b>{% endblock %}
 {% block content_class %}<div class="col-xl-12 col-lg-5 col-md-7 mx-auto"></div>{% endblock %}
 
 {% block content %}
 <div class="container">
     <form method="POST" action="{{ url_for('document_bp.handle_processor_selection') }}" id="processorsForm">
-        {{ render_selectable_table(headers=["Processor ID", "Name", "Type", "Catalog ID"], rows=rows, selectable=True, id="retrieversTable") }}
+        {{ render_selectable_table(headers=["Processor ID", "Name", "Type", "Active"], rows=rows, selectable=True, id="retrieversTable") }}
         <div class="form-group mt-3 d-flex justify-content-between">
             <div>
                 <button type="submit" name="action" value="edit_processor" class="btn btn-primary" onclick="return validateTableSelection('processorsForm')">Edit Processor</button>

eveai_app/templates/document/retriever.html

@@ -4,7 +4,7 @@
 {% block title %}Retriever Registration{% endblock %}
 
 {% block content_title %}Register Retriever{% endblock %}
-{% block content_description %}Define a new retriever (for a catalog){% endblock %}
+{% block content_description %}Define a new retriever for Catalog <b>{% if session.catalog_name %}{{ session.catalog_name }}{% else %}No Catalog{% endif %}</b>{% endblock %}
 
 {% block content %}
     <form method="post">

eveai_app/templates/document/retrievers.html

@@ -4,13 +4,13 @@
 {% block title %}Retrievers{% endblock %}
 
 {% block content_title %}Retrievers{% endblock %}
-{% block content_description %}View Retrievers for Tenant{% endblock %}
+{% block content_description %}View Retrievers for Catalog <b>{% if session.catalog_name %}{{ session.catalog_name }}{% else %}No Catalog{% endif %}</b>{% endblock %}
 {% block content_class %}<div class="col-xl-12 col-lg-5 col-md-7 mx-auto"></div>{% endblock %}
 
 {% block content %}
 <div class="container">
     <form method="POST" action="{{ url_for('document_bp.handle_retriever_selection') }}" id="retrieversForm">
-        {{ render_selectable_table(headers=["Retriever ID", "Name", "Type", "Catalog ID"], rows=rows, selectable=True, id="retrieversTable") }}
+        {{ render_selectable_table(headers=["Retriever ID", "Name", "Type"], rows=rows, selectable=True, id="retrieversTable") }}
         <div class="form-group mt-3 d-flex justify-content-between">
             <div>
                 <button type="submit" name="action" value="edit_retriever" class="btn btn-primary" onclick="return validateTableSelection('retrieversForm')">Edit Retriever</button>

eveai_app/templates/entitlements/edit_license.html

@@ -19,17 +19,17 @@
                 <div class="nav-wrapper position-relative end-0">
                     <ul class="nav nav-pills nav-fill p-1" role="tablist">
                         <li class="nav-item" role="presentation">
-                            <a class="nav-link mb-0 px-0 py-1 active" data-toggle="tab" href="#storage-tab" role="tab" aria-controls="model-info" aria-selected="true">
+                            <a class="nav-link mb-0 px-0 py-1 active" data-bs-toggle="tab" href="#storage-tab" role="tab" aria-controls="model-info" aria-selected="true">
                                 Storage
                             </a>
                         </li>
                         <li class="nav-item">
-                            <a class="nav-link mb-0 px-0 py-1" data-toggle="tab" href="#embedding-tab" role="tab" aria-controls="license-info" aria-selected="false">
+                            <a class="nav-link mb-0 px-0 py-1" data-bs-toggle="tab" href="#embedding-tab" role="tab" aria-controls="license-info" aria-selected="false">
                                 Embedding
                             </a>
                         </li>
                         <li class="nav-item">
-                            <a class="nav-link mb-0 px-0 py-1" data-toggle="tab" href="#interaction-tab" role="tab" aria-controls="chunking" aria-selected="false">
+                            <a class="nav-link mb-0 px-0 py-1" data-bs-toggle="tab" href="#interaction-tab" role="tab" aria-controls="chunking" aria-selected="false">
                                 Interaction
                             </a>
                         </li>

eveai_app/templates/entitlements/license.html

@@ -19,17 +19,17 @@
                 <div class="nav-wrapper position-relative end-0">
                     <ul class="nav nav-pills nav-fill p-1" role="tablist">
                         <li class="nav-item" role="presentation">
-                            <a class="nav-link mb-0 px-0 py-1 active" data-toggle="tab" href="#storage-tab" role="tab" aria-controls="model-info" aria-selected="true">
+                            <a class="nav-link mb-0 px-0 py-1 active" data-bs-toggle="tab" href="#storage-tab" role="tab" aria-controls="model-info" aria-selected="true">
                                 Storage
                             </a>
                         </li>
                         <li class="nav-item">
-                            <a class="nav-link mb-0 px-0 py-1" data-toggle="tab" href="#embedding-tab" role="tab" aria-controls="license-info" aria-selected="false">
+                            <a class="nav-link mb-0 px-0 py-1" data-bs-toggle="tab" href="#embedding-tab" role="tab" aria-controls="license-info" aria-selected="false">
                                 Embedding
                             </a>
                         </li>
                         <li class="nav-item">
-                            <a class="nav-link mb-0 px-0 py-1" data-toggle="tab" href="#interaction-tab" role="tab" aria-controls="chunking" aria-selected="false">
+                            <a class="nav-link mb-0 px-0 py-1" data-bs-toggle="tab" href="#interaction-tab" role="tab" aria-controls="chunking" aria-selected="false">
                                 Interaction
                             </a>
                         </li>

eveai_app/templates/entitlements/license_periods.html

@@ -107,17 +107,17 @@
                 <!-- Nav Tabs -->
                 <ul class="nav nav-tabs" id="periodTabs" role="tablist">
                     <li class="nav-item">
-                        <a class="nav-link active" id="status-tab" data-toggle="tab" href="#status" role="tab">
+                        <a class="nav-link active" id="status-tab" data-bs-toggle="tab" href="#status" role="tab">
                             Status & Timeline
                         </a>
                     </li>
                     <li class="nav-item">
-                        <a class="nav-link" id="usage-tab" data-toggle="tab" href="#usage" role="tab">
+                        <a class="nav-link" id="usage-tab" data-bs-toggle="tab" href="#usage" role="tab">
                             Usage
                         </a>
                     </li>
                     <li class="nav-item">
-                        <a class="nav-link" id="financial-tab" data-toggle="tab" href="#financial" role="tab">
+                        <a class="nav-link" id="financial-tab" data-bs-toggle="tab" href="#financial" role="tab">
                             Financial
                         </a>
                     </li>

eveai_app/templates/entitlements/license_tier.html

@@ -1,3 +1,4 @@
+
 {% extends 'base.html' %}
 {% from "macros.html" import render_field, render_included_field %}
 
@@ -19,17 +20,17 @@
                 <div class="nav-wrapper position-relative end-0">
                     <ul class="nav nav-pills nav-fill p-1" role="tablist">
                         <li class="nav-item" role="presentation">
-                            <a class="nav-link mb-0 px-0 py-1 active" data-toggle="tab" href="#storage-tab" role="tab" aria-controls="model-info" aria-selected="true">
+                            <a class="nav-link mb-0 px-0 py-1 active" data-bs-toggle="tab" href="#storage-tab" role="tab" aria-controls="storage-tab" aria-selected="true">
                                 Storage
                             </a>
                         </li>
                         <li class="nav-item">
-                            <a class="nav-link mb-0 px-0 py-1" data-toggle="tab" href="#embedding-tab" role="tab" aria-controls="license-info" aria-selected="false">
+                            <a class="nav-link mb-0 px-0 py-1" data-bs-toggle="tab" href="#embedding-tab" role="tab" aria-controls="embedding-tab" aria-selected="false">
                                 Embedding
                             </a>
                         </li>
                         <li class="nav-item">
-                            <a class="nav-link mb-0 px-0 py-1" data-toggle="tab" href="#interaction-tab" role="tab" aria-controls="chunking" aria-selected="false">
+                            <a class="nav-link mb-0 px-0 py-1" data-bs-toggle="tab" href="#interaction-tab" role="tab" aria-controls="interaction-tab" aria-selected="false">
                                 Interaction
                             </a>
                         </li>
@@ -68,4 +69,4 @@
 
 {% block content_footer %}
 
-{% endblock %}
+{% endblock %}

eveai_app/templates/eveai_ordered_list_editor.html

@@ -0,0 +1,364 @@
+<script type="module">
+window.EveAI = window.EveAI || {};
+window.EveAI.OrderedListEditors = {
+    instances: {},
+    initialize: function(containerId, data, listType, options = {}) {
+        console.log('Initializing OrderedListEditor for', containerId, 'with data', data, 'and listType', listType);
+        const container = document.getElementById(containerId);
+        if (!container || typeof container !== 'object' || !('classList' in container)) {
+            console.error(`Container with ID ${containerId} not found or not a valid element:`, container);
+            return null;
+        }
+
+        if (this.instances[containerId]) return this.instances[containerId];
+
+        if (typeof window.Tabulator !== 'function') {
+            console.error('Tabulator not loaded (window.Tabulator missing).');
+            container.innerHTML = `<div class="alert alert-danger p-3">
+                <strong>Error:</strong> Tabulator not loaded
+            </div>`;
+            return null;
+        }
+
+        // Get the list type configuration
+        const listTypeConfig = this._getListTypeConfig(listType);
+        if (!listTypeConfig) {
+            console.error(`List type configuration for ${listType} not found.`);
+            container.innerHTML = `<div class="alert alert-danger p-3">
+                <strong>Error:</strong> List type configuration for ${listType} not found
+            </div>`;
+            return null;
+        }
+
+        // Create column definitions from list type
+        const columns = this._createColumnsFromListType(listTypeConfig);
+
+        // Debug log for data and columns
+        console.log('Data for Tabulator:', data);
+        console.log('Columns for Tabulator:', columns);
+
+        // Debug log for column titles
+        console.log('Column titles:', columns.map(col => col.title || ''));
+
+        // Initialize Tabulator
+        try {
+            console.log('Creating Tabulator for', containerId);
+            const table = new Tabulator(container, {
+                data: data || [],
+                columns: columns,
+                layout: "fitColumns", // Changed to fitColumns to ensure columns display horizontally
+                movableRows: true,
+                movableRowsPlaceholder: false, // Don't use placeholder, show actual row content
+                movableRowsSender: "table", // Keep a copy of the row in the table while dragging
+                rowHeader: {headerSort:false, resizable: false, minWidth:30, width:30, rowHandle:true, formatter:"handle"},
+                maxHeight: "50%", // Auto height to display all rows
+                placeholder: "No Data Available",
+                autoResize: false,
+                resizableColumnFit: true,
+                responsiveLayout: false,
+                tooltips: true, // Enable tooltips
+                tooltipsHeader: true,
+                selectable: false, // Disable row selection to prevent jumping
+                selectableRangeMode: "click", // Only select on click, not on drag
+                selectableRollingSelection: false, // Disable rolling selection
+                scrollToRowIfVisible: false, // Don't scroll to row even if it's already visible
+                scrollToRowPosition: "nearest",
+                ...options
+            });
+
+            console.log('Tabulator created for', containerId);
+            container.classList.add('tabulator-initialized');
+
+            // Debug: Log table structure
+            console.log('Table structure:', {
+                tableElement: container,
+                tableData: table.getData(),
+                tableColumns: table.getColumnDefinitions()
+            });
+
+            // Add row button
+            const addRowBtn = document.createElement('button');
+            addRowBtn.className = 'btn btn-sm btn-primary mt-2';
+            addRowBtn.innerHTML = 'Add Row';
+            addRowBtn.addEventListener('click', () => {
+                const newRow = {};
+                // Create empty row with default values
+                Object.entries(listTypeConfig).forEach(([key, field]) => {
+                    if (field.type === 'boolean') {
+                        newRow[key] = field.default === true;
+                    } else {
+                        newRow[key] = field.default !== undefined ? field.default : '';
+                    }
+                });
+                table.addRow(newRow);
+                this._updateTextarea(containerId, table);
+            });
+            container.parentNode.insertBefore(addRowBtn, container.nextSibling);
+
+            // Add explode button for fullscreen mode
+            const explodeBtn = document.createElement('button');
+            explodeBtn.className = 'btn btn-sm btn-secondary mt-2 ms-2';
+            explodeBtn.innerHTML = '<i class="material-icons">fullscreen</i> Expand';
+            explodeBtn.addEventListener('click', () => {
+                container.classList.toggle('fullscreen-mode');
+
+                // Update button text based on current state
+                if (container.classList.contains('fullscreen-mode')) {
+                    explodeBtn.innerHTML = '<i class="material-icons">fullscreen_exit</i> Collapse';
+                } else {
+                    explodeBtn.innerHTML = '<i class="material-icons">fullscreen</i> Expand';
+                }
+
+                // Redraw table to adjust to new size
+                table.redraw(true);
+            });
+            container.parentNode.insertBefore(explodeBtn, addRowBtn.nextSibling);
+
+            // Store instance
+            this.instances[containerId] = {
+                table: table,
+                textarea: document.getElementById(containerId.replace('-editor', ''))
+            };
+
+            // Prevent scrolling when clicking on cells
+            container.addEventListener('click', function(e) {
+                // Prevent the default behavior which might cause scrolling
+                if (e.target.closest('.tabulator-cell')) {
+                    e.preventDefault();
+                }
+            }, { passive: false });
+
+            // Update textarea on various events that change data
+            table.on("dataChanged", () => {
+                console.log("dataChanged event triggered");
+                this._updateTextarea(containerId, table);
+            });
+
+            // Listen for row movement
+            table.on("rowMoved", () => {
+                console.log("rowMoved event triggered");
+                this._updateTextarea(containerId, table);
+            });
+
+            // Listen for cell edits
+            table.on("cellEdited", () => {
+                console.log("cellEdited event triggered");
+                this._updateTextarea(containerId, table);
+            });
+
+            return table;
+        } catch (e) {
+            console.error(`Error initializing Tabulator for ${containerId}:`, e);
+            container.innerHTML = `<div class="alert alert-danger p-3">
+                <strong>Error initializing Tabulator:</strong><br>${e.message}
+            </div>`;
+            return null;
+        }
+    },
+
+    _updateTextarea: function(containerId, table) {
+        const instance = this.instances[containerId];
+        if (instance && instance.textarea) {
+            const data = table.getData();
+            console.log('Updating textarea with data:', data);
+            instance.textarea.value = JSON.stringify(data);
+            console.log('Textarea value updated:', instance.textarea.value);
+
+            // Trigger change event on textarea to ensure form validation recognizes the change
+            const event = new Event('change', { bubbles: true });
+            instance.textarea.dispatchEvent(event);
+
+            // Also trigger input event for any listeners that might be using that
+            const inputEvent = new Event('input', { bubbles: true });
+            instance.textarea.dispatchEvent(inputEvent);
+        } else {
+            console.error('Cannot update textarea: instance or textarea not found for', containerId);
+        }
+    },
+
+    _getListTypeConfig: function(listType) {
+        // Try to get the list type configuration from window.listTypeConfigs
+        if (window.listTypeConfigs && window.listTypeConfigs[listType]) {
+            return window.listTypeConfigs[listType];
+        }
+
+        // If not found, log a warning and return a default configuration
+        console.warn(`List type configuration for ${listType} not found in window.listTypeConfigs. Using a default configuration.`);
+        return {
+            title: {
+                name: "Title",
+                description: "Title",
+                type: "str",
+                required: true
+            },
+            description: {
+                name: "Description",
+                description: "Description",
+                type: "text",
+                required: true
+            }
+        };
+    },
+
+    // Custom formatter for text columns to truncate text in normal mode
+    _truncateFormatter: function(cell, formatterParams, onRendered) {
+        const value = cell.getValue();
+        const maxLength = formatterParams.maxLength || 100;
+
+        if (value && value.length > maxLength) {
+            // Create a truncated version with "..." and show more indicator
+            const truncated = value.substring(0, maxLength) + "...";
+
+            // Return HTML with truncated text and a "show more" button
+            return `<div class="truncated-cell">
+                      <div class="truncated-content">${truncated}</div>
+                      <div class="show-more" title="Click to edit and see full text">
+                        <i class="material-icons">more_horiz</i>
+                      </div>
+                    </div>`;
+        }
+
+        return value;
+    },
+
+    _createColumnsFromListType: function(listTypeConfig) {
+        const columns = [];
+
+        // Add columns for each field in the list type
+        Object.entries(listTypeConfig).forEach(([key, field]) => {
+            const column = {
+                title: field.name || key,
+                field: key,
+                headerTooltip: field.description,
+                headerSort: false,
+                visible: true,
+                resizable: "header",
+            };
+            console.log("Column ", field.name, " type: ", field.type)
+            // Set width based on field type
+            if (field.type === 'boolean') {
+                column.minWidth = 50;
+                column.maxWidth = 80; // Limit maximum width
+                column.widthGrow = 0; // Don't allow boolean columns to grow
+            } else if (field.type === 'text') {
+                column.width = 400; // Much larger width for text columns (especially description)
+                column.minWidth = 300; // Ensure text columns have adequate minimum width
+                column.widthGrow = 2; // Allow text columns to grow significantly more
+            } else {
+                column.width = 150; // Default width for other columns
+                column.minWidth = 100;
+                column.widthGrow = 1; // Allow some growth
+            }
+
+            // Ensure consistent width calculation
+            column.widthShrink = 0; // Don't allow shrinking below minWidth
+
+            // Set editor based on field type
+            if (field.type === 'boolean') {
+                column.formatter = 'tickCross';
+                column.editor = 'tickCross';
+                column.hozAlign = 'center';
+                column.headerHozAlign = 'center';
+                column.formatterParams = {
+                    allowEmpty: true,
+                    allowTruthy: true,
+                    tickElement: "<i class='material-icons'>check_circle</i>",
+                    crossElement: "<i class='material-icons'>cancel</i>"
+                };
+            } else if (field.type === 'enum' && field.allowed_values) {
+                column.editor = 'select';
+                column.editorParams = {
+                    values: field.allowed_values
+                };
+                column.hozAlign = 'left';
+                column.headerHozAlign = 'left';
+            } else if (field.type === 'text') {
+                column.editor = 'textarea';
+                column.formatter = this._truncateFormatter; // Use custom formatter to truncate text
+                column.variableHeight = true;
+                // Configure formatter parameters
+                column.formatterParams = {
+                    maxLength: 50,
+                    autoResize: true
+                };
+                // Prevent scrolling when editing text cells
+                column.editorParams = {
+                    elementAttributes: {
+                        preventScroll: true
+                    }
+                };
+                column.hozAlign = 'left';
+                column.headerHozAlign = 'left';
+            } else {
+                column.editor = 'input';
+                column.hozAlign = 'left';
+                column.headerHozAlign = 'left';
+            }
+
+            columns.push(column);
+        });
+
+        // We don't add a delete button column as per requirements
+        // to prevent users from deleting rows
+
+        return columns;
+    },
+
+    get: function(containerId) {
+        return this.instances[containerId] || null;
+    },
+
+    destroy: function(containerId) {
+        if (this.instances[containerId]) {
+            if (this.instances[containerId].table && typeof this.instances[containerId].table.destroy === 'function') {
+                this.instances[containerId].table.destroy();
+            }
+            delete this.instances[containerId];
+        }
+        const container = document.getElementById(containerId);
+        if (container) {
+            container.classList.remove('tabulator-initialized');
+            container.innerHTML = '';
+        }
+    }
+};
+
+document.addEventListener('DOMContentLoaded', function() {
+    // Initialize list type configurations
+    window.listTypeConfigs = window.listTypeConfigs || {};
+
+    // Initialize ordered list editors
+    document.querySelectorAll('.ordered-list-field').forEach(function(textarea) {
+        const containerId = textarea.id + '-editor';
+        console.log('Initializing ordered list editor for', containerId);
+
+        // Create container if it doesn't exist
+        let container = document.getElementById(containerId);
+        if (!container) {
+            container = document.createElement('div');
+            container.id = containerId;
+            container.className = 'ordered-list-editor';
+            textarea.parentNode.insertBefore(container, textarea.nextSibling);
+            textarea.classList.add('d-none'); // Hide the textarea
+        }
+
+        try {
+            const data = textarea.value ? JSON.parse(textarea.value) : [];
+            const listType = textarea.getAttribute('data-list-type');
+
+            // Check if we have the list type configuration
+            if (listType && !window.listTypeConfigs[listType]) {
+                console.warn(`List type configuration for ${listType} not found. Using default configuration.`);
+            }
+
+            window.EveAI.OrderedListEditors.initialize(containerId, data, listType);
+        } catch (e) {
+            console.error('Error initializing ordered list editor:', e);
+            container.innerHTML = `<div class="alert alert-danger p-3">
+                <strong>Error initializing ordered list editor:</strong><br>${e.message}
+            </div>`;
+        }
+    });
+});
+</script>
+

eveai_app/templates/interaction/edit_specialist.html

@@ -15,29 +15,17 @@
                     {{ form.hidden_tag() }}
                     {% set disabled_fields = ['type', 'type_version'] %}
                     {% set exclude_fields = [] %}
-                    <!-- Render Static Fields -->
-                    {% for field in form.get_static_fields() %}
-                        {{ render_field(field, disabled_fields, exclude_fields) }}
-                    {% endfor %}
-
-                    <!-- Overview Section -->
-                    <div class="row mb-4">
-                        <div class="col-12">
-                            <div class="card">
-                                <div class="card-body">
-                                    <div class="specialist-overview" id="specialist-svg">
-                                        <img src="{{ svg_path }}" alt="Specialist Overview" class="w-100">
-                                    </div>
-                                </div>
-                            </div>
-                        </div>
-                    </div>
 
                     <!-- Nav Tabs -->
                     <div class="row mt-5">
                         <div class="col-lg-12">
                             <div class="nav-wrapper position-relative end-0">
                                 <ul class="nav nav-pills nav-fill p-1" role="tablist">
+                                    <li class="nav-item">
+                                        <a class="nav-link mb-0 px-0 py-1" data-bs-toggle="tab" href="#general-tab" role="tab">
+                                            General
+                                        </a>
+                                    </li>
                                     <li class="nav-item">
                                         <a class="nav-link mb-0 px-0 py-1 active" data-bs-toggle="tab" href="#configuration-tab" role="tab">
                                             Configuration
@@ -67,6 +55,27 @@
                             </div>
 
                             <div class="tab-content tab-space">
+                                <!-- General Tab -->
+                                <div class="tab-pane fade" id="general-tab" role="tabpanel">
+                                    <!-- Render Static Fields -->
+                                    {% for field in form.get_static_fields() %}
+                                        {{ render_field(field, disabled_fields, exclude_fields) }}
+                                    {% endfor %}
+
+                                    <!-- Overview Section -->
+                                    <div class="row mb-4">
+                                        <div class="col-12">
+                                            <div class="card">
+                                                <div class="card-body">
+                                                    <div class="specialist-overview" id="specialist-svg">
+                                                        <img src="{{ svg_path }}" alt="Specialist Overview" class="w-100">
+                                                    </div>
+                                                </div>
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+
                                 <!-- Configuration Tab -->
                                 <div class="tab-pane fade show active" id="configuration-tab" role="tabpanel">
                                     {% for collection_name, fields in form.get_dynamic_fields().items() %}
@@ -420,6 +429,14 @@ document.addEventListener('DOMContentLoaded', function() {
     color: #344767 !important;  /* Default dark color */
 }
 
+/* Style for active tabs */
+.nav-link.active {
+    background-color: #5e72e4 !important;  /* Primary blue color */
+    color: white !important;
+    font-weight: 600;
+    box-shadow: 0 4px 6px rgba(50, 50, 93, 0.11), 0 1px 3px rgba(0, 0, 0, 0.08);
+}
+
 /* Style for disabled tabs */
 .nav-link.disabled {
     opacity: 0.5;
@@ -476,4 +493,3 @@ document.addEventListener('DOMContentLoaded', function() {
 }
 </style>
 {% endblock %}
-

eveai_app/templates/interaction/edit_specialist_magic_link.html

@@ -0,0 +1,52 @@
+{% extends 'base.html' %}
+{% from "macros.html" import render_field %}
+
+{% block title %}Edit Specialist Magic Link{% endblock %}
+
+{% block content_title %}Edit Specialist Magic Link{% endblock %}
+{% block content_description %}Edit a Specialist Magic Link{% endblock %}
+
+{% block content %}
+    <form method="post">
+        {{ form.hidden_tag() }}
+        {% set disabled_fields = ['magic_link_code', 'chat_client_url', 'qr_code_url'] %}
+        {% set exclude_fields = [] %}
+        <!-- Render Static Fields -->
+        {% for field in form.get_static_fields() %}
+            {% if field.name == 'qr_code_url' and field.data %}
+                <div class="form-group">
+                    <label for="{{ field.id }}">{{ field.label.text }}</label>
+                    <div style="max-width: 200px;">
+                        <img src="{{ field.data }}" alt="QR Code" class="img-fluid">
+                    </div>
+                    <input type="hidden" name="{{ field.name }}" value="{{ field.data|e }}">
+                </div>
+            {% elif field.name == 'chat_client_url' %}
+                <div class="form-group">
+                    <label for="{{ field.id }}" class="form-label">{{ field.label.text }}</label>
+                    <div class="input-group">
+                        <input type="text" class="form-control" value="{{ field.data }}" id="{{ field.id }}" readonly>
+                        <a href="{{ field.data }}" class="btn btn-primary" target="_blank">Open link</a>
+                    </div>
+                    <input type="hidden" name="{{ field.name }}" value="{{ field.data|e }}">
+                </div>
+            {% else %}
+                {{ render_field(field, disabled_fields, exclude_fields) }}
+            {% endif %}
+        {% endfor %}
+        <!-- Render Dynamic Fields -->
+        {% for collection_name, fields in form.get_dynamic_fields().items() %}
+            {% if fields|length > 0 %}
+                <h4 class="mt-4">{{ collection_name }}</h4>
+            {% endif %}
+            {% for field in fields %}
+                {{ render_field(field, disabled_fields, exclude_fields) }}
+            {% endfor %}
+        {% endfor %}
+        <button type="submit" class="btn btn-primary">Save Specialist Magic Link</button>
+    </form>
+{% endblock %}
+
+{% block content_footer %}
+
+{% endblock %}

eveai_app/templates/interaction/specialist_magic_link.html

@@ -0,0 +1,23 @@
+{% extends 'base.html' %}
+{% from "macros.html" import render_field %}
+
+{% block title %}Specialist Magic Link{% endblock %}
+
+{% block content_title %}Register Specialist Magic Link{% endblock %}
+{% block content_description %}Define a new specialist magic link{% endblock %}
+
+{% block content %}
+    <form method="post">
+        {{ form.hidden_tag() }}
+        {%  set disabled_fields = [] %}
+        {%  set exclude_fields = [] %}
+        {% for field in form %}
+            {{ render_field(field, disabled_fields, exclude_fields) }}
+        {% endfor %}
+        <button type="submit" class="btn btn-primary">Register Specialist Magic Link</button>
+    </form>
+{% endblock %}
+
+{% block content_footer %}
+
+{% endblock %}

eveai_app/templates/interaction/specialist_magic_links.html

@@ -0,0 +1,26 @@
+{% extends 'base.html' %}
+{%  from 'macros.html' import render_selectable_table, render_pagination %}
+
+{% block title %}Specialist Magic Links{% endblock %}
+
+{% block content_title %}Specialist Magic Links{% endblock %}
+{% block content_description %}View Specialists Magic Links{% endblock %}
+{% block content_class %}<div class="col-xl-12 col-lg-5 col-md-7 mx-auto"></div>{% endblock %}
+
+{% block content %}
+<div class="container">
+    <form method="POST" action="{{ url_for('interaction_bp.handle_specialist_magic_link_selection') }}" id="specialistMagicLinksForm">
+        {{ render_selectable_table(headers=["Specialist ML ID", "Name", "Magic Link Code"], rows=rows, selectable=True, id="specialistMagicLinksTable") }}
+        <div class="form-group mt-3 d-flex justify-content-between">
+            <div>
+                <button type="submit" name="action" value="edit_specialist_magic_link" class="btn btn-primary" onclick="return validateTableSelection('specialistMagicLinksForm')">Edit Specialist Magic Link</button>
+            </div>
+            <button type="submit" name="action" value="create_specialist_magic_link" class="btn btn-success">Register Specialist Magic Link</button>
+        </div>
+    </form>
+</div>
+{% endblock %}
+
+{% block content_footer %}
+    {{ render_pagination(pagination, 'interaction_bp.specialist_magic_links') }}
+{% endblock %}

eveai_app/templates/interaction/specialists.html

@@ -1,7 +1,7 @@
 {% extends 'base.html' %}
 {%  from 'macros.html' import render_selectable_table, render_pagination %}
 
-{% block title %}Retrievers{% endblock %}
+{% block title %}Specialists{% endblock %}
 
 {% block content_title %}Specialists{% endblock %}
 {% block content_description %}View Specialists for Tenant{% endblock %}
@@ -10,7 +10,7 @@
 {% block content %}
 <div class="container">
     <form method="POST" action="{{ url_for('interaction_bp.handle_specialist_selection') }}" id="specialistsForm">
-        {{ render_selectable_table(headers=["Specialist ID", "Name", "Type"], rows=rows, selectable=True, id="specialistsTable") }}
+        {{ render_selectable_table(headers=["Specialist ID", "Name", "Type", "Type Version", "Active"], rows=rows, selectable=True, id="specialistsTable") }}
         <div class="form-group mt-3 d-flex justify-content-between">
             <div>
                 <button type="submit" name="action" value="edit_specialist" class="btn btn-primary" onclick="return validateTableSelection('specialistsForm')">Edit Specialist</button>

eveai_app/templates/macros.html

@@ -1,5 +1,26 @@
+{# Helper functie om veilig de class van een veld te krijgen #}
+{% macro get_field_class(field, default='') %}
+    {% if field.render_kw is not none and field.render_kw.get('class') is not none %}
+        {{ field.render_kw.get('class') }}
+    {% else %}
+        {{ default }}
+    {% endif %}
+{% endmacro %}
+
 {% macro render_field_content(field, disabled=False, readonly=False, class='') %}
-    {% if field.type == 'BooleanField' %}
+    {# Check if this is a hidden input field, if so, render only the field without label #}
+    {{ debug_to_console("Field Class: ", field.widget.__class__.__name__) }}
+    {% if field.widget.__class__.__name__ == 'HiddenInput' %}
+        {{ debug_to_console("Hidden Field: ", "Detected") }}
+        {{ field(class="form-control " + class, disabled=disabled, readonly=readonly) }}
+        {% if field.errors %}
+            <div class="invalid-feedback d-block">
+                {% for error in field.errors %}
+                    {{ error }}
+                {% endfor %}
+            </div>
+        {% endif %}
+    {% elif field.type == 'BooleanField' %}
         <div class="form-group">
             <div class="form-check form-switch">
                 {{ field(class="form-check-input " + class, disabled=disabled, readonly=readonly, required=False) }}
@@ -55,9 +76,14 @@
                 {% endif %}
             {% endif %}
 
+            {% set field_class = get_field_class(field) %}
             {% if field.type == 'TextAreaField' and 'json-editor' in class %}
                 <div id="{{ field.id }}-editor" class="json-editor-container"></div>
                 {{ field(class="form-control d-none " + class, disabled=disabled, readonly=readonly) }}
+            {% elif field.type == 'OrderedListField' or 'ordered-list-field' in field_class %}
+                {# Create container for ordered list editor and hide the textarea #}
+                <div id="{{ field.id }}-editor" class="ordered-list-editor"></div>
+                {{ field(class="form-control d-none " + field_class|trim, disabled=disabled, readonly=readonly) }}
             {% elif field.type == 'SelectField' %}
                 {{ field(class="form-control form-select " + class, disabled=disabled, readonly=readonly) }}
             {% else %}
@@ -76,6 +102,7 @@
 {% endmacro %}
 
 
+
 {% macro render_field(field, disabled_fields=[], readonly_fields=[], exclude_fields=[], class='') %}
     <!-- Debug info -->
     <!-- Field name: {{ field.name }}, Field type: {{ field.__class__.__name__ }} -->
@@ -123,7 +150,7 @@
                 {% elif cell.type == 'badge' %}
                   <span class="badge badge-sm {{ cell.badge_class }}">{{ cell.value }}</span>
                 {% elif cell.type == 'link' %}
-                  <a href="{{ cell.href }}" class="text-secondary font-weight-normal text-xs" data-toggle="tooltip" data-original-title="{{ cell.title }}">{{ cell.value }}</a>
+                  <a href="{{ cell.href }}" class="text-secondary font-weight-normal text-xs" data-bs-toggle="tooltip" data-original-title="{{ cell.title }}">{{ cell.value }}</a>
                 {% else %}
                   {{ cell.value }}
                 {% endif %}
@@ -177,7 +204,7 @@
                 {% elif cell.type == 'badge' %}
                   <span class="badge badge-sm {{ cell.badge_class }}">{{ cell.value }}</span>
                 {% elif cell.type == 'link' %}
-                  <a href="{{ cell.href }}" class="text-secondary font-weight-normal text-xs" data-toggle="tooltip" data-original-title="{{ cell.title }}">{{ cell.value }}</a>
+                  <a href="{{ cell.href }}" class="text-secondary font-weight-normal text-xs" data-bs-toggle="tooltip" data-original-title="{{ cell.title }}">{{ cell.value }}</a>
                 {% else %}
                   {{ cell.value }}
                 {% endif %}
@@ -342,7 +369,7 @@
                   {% elif cell.type == 'badge' %}
                     <span class="badge badge-sm {{ cell.badge_class }}">{{ cell.value }}</span>
                   {% elif cell.type == 'link' %}
-                    <a href="{{ cell.href }}" class="text-secondary font-weight-normal text-xs" data-toggle="tooltip" data-original-title="{{ cell.title }}">{{ cell.value }}</a>
+                    <a href="{{ cell.href }}" class="text-secondary font-weight-normal text-xs" data-bs-toggle="tooltip" data-original-title="{{ cell.title }}">{{ cell.value }}</a>
                   {% else %}
                     {{ cell.value }}
                   {% endif %}
@@ -436,3 +463,9 @@
 </div>
 {% endmacro %}
 
+{% macro debug_to_console(var_name, var_value) %}
+    <script>
+        console.log('{{ var_name }}:', {{ var_value|tojson }});
+    </script>
+{% endmacro %}
+

eveai_app/templates/navbar.html

@@ -73,6 +73,7 @@
                                     {'name': 'Tenant Overview', 'url': '/user/tenant_overview', 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
                                     {'name': 'Edit Tenant', 'url': '/user/tenant/' ~ session['tenant'].get('id'), 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
                                     {'name': 'Tenant Domains', 'url': '/user/view_tenant_domains', 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
+                                    {'name': 'Tenant Makes', 'url': '/user/tenant_makes', 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
                                     {'name': 'Tenant Projects', 'url': '/user/tenant_projects', 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
                                     {'name': 'Users', 'url': '/user/view_users', 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
                                 ]) }}
@@ -106,6 +107,7 @@
                             {% if current_user.is_authenticated %}
                                 {{ dropdown('Interactions', 'hub', [
                                     {'name': 'Specialists', 'url': '/interaction/specialists', 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
+                                    {'name': 'Specialist Magic Links', 'url': '/interaction/specialist_magic_links', 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
                                     {'name': 'Chat Sessions', 'url': '/interaction/chat_sessions', 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
                                 ]) }}
                             {% endif %}
@@ -120,6 +122,7 @@
                             {% if current_user.is_authenticated %}
                                 {{ dropdown(current_user.user_name, 'person', [
                                     {'name': 'Session Defaults', 'url': '/session_defaults', 'roles': ['Super User', 'Tenant Admin']},
+                                    {'name': 'Release Notes', 'url': '/release_notes', 'roles': ['Super User', 'Partner Admin', 'Tenant Admin']},
                                     {'name': 'Logout', 'url': '/logout'}
                                 ]) }}
                             {% else %}
@@ -133,4 +136,4 @@
             </nav>
         </div>
     </div>
-</div>
+</div>

eveai_app/templates/ordered_list_configs.html

@@ -0,0 +1,7 @@
+{# Include this template in any page that uses ordered_list fields #}
+{# Usage: {% include 'ordered_list_configs.html' %} #}
+{# The form must be available in the template context as 'form' #}
+
+{% if form and form.get_list_type_configs_js %}
+    {{ form.get_list_type_configs_js()|safe }}
+{% endif %}

eveai_app/templates/partner/edit_partner_service.html

@@ -1,9 +1,9 @@
 {% extends "base.html" %}
-{% from "macros.html" import render_field %}
-{% block title %}Register Partner Service{% endblock %}
+{% from "macros.html" import render_field, debug_to_console %}
+{% block title %}Edit Partner Service{% endblock %}
 
-{% block content_title %}Register Partner Service{% endblock %}
-{% block content_description %}Register Partner Service{% endblock %}
+{% block content_title %}Edit Partner Service{% endblock %}
+{% block content_description %}Edit Partner Service{% endblock %}
 
 {% block content %}
     <form method="post">
@@ -16,6 +16,8 @@
         {% endfor %}
         <!-- Render Dynamic Fields -->
         {% for collection_name, fields in form.get_dynamic_fields().items() %}
+            {{ debug_to_console('collection_name', collection_name) }}
+            {{ debug_to_console('fields', fields) }}
             {% if fields|length > 0 %}
                 <h4 class="mt-4">{{ collection_name }}</h4>
             {% endif %}
@@ -23,6 +25,6 @@
                 {{ render_field(field, disabled_fields, exclude_fields) }}
             {% endfor %}
         {% endfor %}
-        <button type="submit" class="btn btn-primary">Register Partner Service</button>
+        <button type="submit" class="btn btn-primary">Save Partner Service</button>
     </form>
 {% endblock %}

eveai_app/templates/scripts.html

@@ -9,14 +9,19 @@
 <script src="{{url_for('static', filename='assets/js/material-kit-pro.min.js')}}"></script>
 
 {% include 'eveai_json_editor.html' %}
+{% include 'eveai_ordered_list_editor.html' %}
 
 <script>
 document.addEventListener('DOMContentLoaded', function() {
-    // Initialize tooltips
-    var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'))
-    var tooltipList = tooltipTriggerList.map(function (tooltipTriggerEl) {
-        return new bootstrap.Tooltip(tooltipTriggerEl)
-    });
+    // Initialize tooltips if bootstrap is available
+    if (typeof bootstrap !== 'undefined') {
+        var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'))
+        var tooltipList = tooltipTriggerList.map(function (tooltipTriggerEl) {
+            return new bootstrap.Tooltip(tooltipTriggerEl)
+        });
+    } else {
+        console.warn('Bootstrap is not defined. Tooltips will not be initialized.');
+    }
 
     // De JSON editor initialisatie is hierboven al samengevoegd.
     // Deze dubbele DOMContentLoaded listener en .json-editor initialisatie kan verwijderd worden.
@@ -46,9 +51,12 @@ document.addEventListener('DOMContentLoaded', function() {
 
                     // Find and click the corresponding tab button
                     const tabButton = document.querySelector(`[data-bs-toggle="tab"][data-bs-target="#${tabId}"]`);
-                    if (tabButton) {
+                    if (tabButton && typeof bootstrap !== 'undefined') {
                         const tab = new bootstrap.Tab(tabButton);
                         tab.show();
+                    } else if (tabButton) {
+                        // Fallback if bootstrap is not available
+                        tabButton.click();
                     }
 
                     // Scroll the invalid field into view and focus it

eveai_app/templates/user/edit_tenant.html

@@ -19,3 +19,37 @@
 {% endblock %}
 
 {% block content_footer %} {% endblock %}
+
+{% block scripts %}
+<script>
+    // JavaScript om de gebruiker's timezone te detecteren
+    document.addEventListener('DOMContentLoaded', (event) => {
+        // Detect timezone
+        const userTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+        // Send timezone to the server via a POST request
+        fetch('/set_user_timezone', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ timezone: userTimezone })
+        }).then(response => {
+            if (response.ok) {
+                console.log('Timezone sent to server successfully');
+            } else {
+                console.error('Failed to send timezone to server');
+            }
+        });
+
+        // Initialiseer Select2 voor timezone selectie
+        $('#timezone').select2({
+            placeholder: 'Selecteer een timezone...',
+            allowClear: true,
+            maximumSelectionLength: 10,
+            theme: 'bootstrap',
+            width: '100%'
+        });
+    });
+</script>
+{% endblock %}

eveai_app/templates/user/edit_tenant_make.html

@@ -0,0 +1,33 @@
+{% extends 'base.html' %}
+{% from "macros.html" import render_field %}
+
+{% block title %}Edit Tenant Make{% endblock %}
+
+{% block content_title %}Edit Tenant Make{% endblock %}
+{% block content_description %}Edit a Tenant Make.{% endblock %}
+
+{% block content %}
+    <form method="post">
+        {{ form.hidden_tag() }}
+        {% set disabled_fields = [] %}
+        {% set exclude_fields = [] %}
+        <!-- Render Static Fields -->
+        {% for field in form.get_static_fields() %}
+            {{ render_field(field, disabled_fields, exclude_fields) }}
+        {% endfor %}
+        <!-- Render Dynamic Fields -->
+        {% for collection_name, fields in form.get_dynamic_fields().items() %}
+            {% if fields|length > 0 %}
+                <h4 class="mt-4">{{ collection_name }}</h4>
+            {% endif %}
+            {% for field in fields %}
+                {{ render_field(field, disabled_fields, exclude_fields) }}
+            {% endfor %}
+        {% endfor %}
+        <button type="submit" class="btn btn-primary">Save Tenant Make</button>
+    </form>
+{% endblock %}
+
+{% block content_footer %}
+
+{% endblock %}

eveai_app/templates/user/tenant.html

@@ -26,7 +26,7 @@
 
 {% block scripts %}
 <script>
-    // JavaScript to detect user's timezone
+    // JavaScript om de gebruiker's timezone te detecteren
     document.addEventListener('DOMContentLoaded', (event) => {
         // Detect timezone
         const userTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -45,6 +45,31 @@
                 console.error('Failed to send timezone to server');
             }
         });
+
+        $('#timezone').select2({
+            placeholder: 'Selecteer een timezone...',
+            allowClear: true,
+            theme: 'bootstrap',
+            width: '100%',
+            dropdownAutoWidth: true,
+            dropdownCssClass: 'timezone-dropdown', // Een custom class voor specifieke styling
+            scrollAfterSelect: false,
+            // Verbeterd scroll gedrag
+            dropdownParent: $('body')
+        });
+
+        // Stel de huidige waarde in als de dropdown wordt geopend
+        $('#timezone').on('select2:open', function() {
+            if ($(this).val()) {
+                setTimeout(function() {
+                    let selectedOption = $('.select2-results__option[aria-selected=true]');
+                    if (selectedOption.length) {
+                        selectedOption[0].scrollIntoView({ behavior: 'auto', block: 'center' });
+                    }
+                }, 0);
+            }
+        });
     });
 </script>
+
 {% endblock %}