- Fixed bug where negative answers in KO Criteria resulted in a blank answer

- Fixed bug where removal of audio processor caused eveai_workers to not start up, resulting in documents not being processed.

.gitignore

@@ -53,7 +53,5 @@ 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
+/nginx/.parcel-cache/
+/nginx/static/

README.md.k8s-logging

@@ -1,67 +0,0 @@
-# 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

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

common/eveai_model/tracked_mistral_embeddings.py

@@ -44,7 +44,6 @@ class TrackedMistralAIEmbeddings(EveAIEmbeddings):
         for i in range(0, len(texts), self.batch_size):
             batch = texts[i:i + self.batch_size]
             batch_num = i // self.batch_size + 1
-            current_app.logger.debug(f"Processing embedding batch {batch_num}, size: {len(batch)}")
 
             start_time = time.time()
             try:
@@ -70,9 +69,6 @@ class TrackedMistralAIEmbeddings(EveAIEmbeddings):
                 }
                 current_event.log_llm_metrics(metrics)
 
-                current_app.logger.debug(f"Batch {batch_num} processed: {len(batch)} texts, "
-                                         f"{result.usage.total_tokens} tokens, {batch_time:.2f}s")
-
                 # If processing multiple batches, add a small delay to avoid rate limits
                 if len(texts) > self.batch_size and i + self.batch_size < len(texts):
                     time.sleep(0.25)  # 250ms pause between batches
@@ -82,7 +78,6 @@ class TrackedMistralAIEmbeddings(EveAIEmbeddings):
                 # If a batch fails, try to process each text individually
                 for j, text in enumerate(batch):
                     try:
-                        current_app.logger.debug(f"Attempting individual embedding for item {i + j}")
                         single_start_time = time.time()
                         single_result = self.client.embeddings.create(
                             model=self.model,

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

@@ -11,6 +11,7 @@ class Catalog(db.Model):
     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")
+    type_version = db.Column(db.String(20), nullable=True, default="1.0.0")
 
     min_chunk_size = db.Column(db.Integer, nullable=True, default=1500)
     max_chunk_size = db.Column(db.Integer, nullable=True, default=2500)
@@ -26,6 +27,20 @@ class Catalog(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 to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'description': self.description,
+            'type': self.type,
+            'type_version': self.type_version,
+            'min_chunk_size': self.min_chunk_size,
+            'max_chunk_size': self.max_chunk_size,
+            'user_metadata': self.user_metadata,
+            'system_metadata': self.system_metadata,
+            'configuration': self.configuration,
+        }
+
 
 class Processor(db.Model):
     id = db.Column(db.Integer, primary_key=True)
@@ -34,6 +49,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)
@@ -89,6 +105,12 @@ class Document(db.Model):
     # Relations
     versions = db.relationship('DocumentVersion', backref='document', lazy=True)
 
+    @property
+    def latest_version(self):
+        """Returns the latest document version (the one with highest id)"""
+        from sqlalchemy import desc
+        return DocumentVersion.query.filter_by(doc_id=self.id).order_by(desc(DocumentVersion.id)).first()
+
     def __repr__(self):
         return f"<Document {self.id}: {self.name}>"
 

common/models/interaction.py

@@ -67,25 +67,23 @@ class EveAIAsset(db.Model):
     description = db.Column(db.Text, nullable=True)
     type = db.Column(db.String(50), nullable=False, default="DOCUMENT_TEMPLATE")
     type_version = db.Column(db.String(20), nullable=True, default="1.0.0")
-    valid_from = db.Column(db.DateTime, nullable=True)
-    valid_to = db.Column(db.DateTime, 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(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))
-
-    # Relations
-    versions = db.relationship('EveAIAssetVersion', backref='asset', lazy=True)
-
-
-class EveAIAssetVersion(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
-    asset_id = db.Column(db.Integer, db.ForeignKey(EveAIAsset.id), nullable=False)
+    # Storage information
     bucket_name = db.Column(db.String(255), nullable=True)
+    object_name = db.Column(db.String(200), nullable=True)
+    file_type = db.Column(db.String(20), nullable=True)
+    file_size = db.Column(db.Float, nullable=True)
+
+    # Metadata information
+    user_metadata = db.Column(JSONB, nullable=True)
+    system_metadata = db.Column(JSONB, nullable=True)
+
+    # Configuration information
     configuration = db.Column(JSONB, nullable=True)
-    arguments = db.Column(JSONB, nullable=True)
+
+    # Cost information
+    prompt_tokens = db.Column(db.Integer, nullable=True)
+    completion_tokens = db.Column(db.Integer, nullable=True)
 
     # Versioning Information
     created_at = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
@@ -93,25 +91,25 @@ class EveAIAssetVersion(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))
 
-    # Relations
-    instructions = db.relationship('EveAIAssetInstruction', backref='asset_version', lazy=True)
+    last_used_at = db.Column(db.DateTime, nullable=True)
 
 
-class EveAIAssetInstruction(db.Model):
+class EveAIDataCapsule(db.Model):
     id = db.Column(db.Integer, primary_key=True)
-    asset_version_id = db.Column(db.Integer, db.ForeignKey(EveAIAssetVersion.id), nullable=False)
-    name = db.Column(db.String(255), nullable=False)
-    content = db.Column(db.Text, nullable=True)
+    chat_session_id = db.Column(db.Integer, db.ForeignKey(ChatSession.id), nullable=False)
+    type = db.Column(db.String(50), nullable=False, default="STANDARD_RAG")
+    type_version = db.Column(db.String(20), nullable=True, default="1.0.0")
+    configuration = db.Column(JSONB, nullable=True)
+    data = 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(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))
 
-class EveAIProcessedAsset(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
-    asset_version_id = db.Column(db.Integer, db.ForeignKey(EveAIAssetVersion.id), nullable=False)
-    specialist_id = db.Column(db.Integer, db.ForeignKey(Specialist.id), nullable=True)
-    chat_session_id = db.Column(db.Integer, db.ForeignKey(ChatSession.id), nullable=True)
-    bucket_name = db.Column(db.String(255), nullable=True)
-    object_name = db.Column(db.String(255), nullable=True)
-    created_at = db.Column(db.DateTime, nullable=True, server_default=db.func.now())
+    # Unieke constraint voor chat_session_id, type en type_version
+    __table_args__ = (db.UniqueConstraint('chat_session_id', 'type', 'type_version', name='uix_data_capsule_session_type_version'),)
 
 
 class EveAIAgent(db.Model):

common/models/user.py

@@ -26,9 +26,6 @@ class Tenant(db.Model):
     timezone = db.Column(db.String(50), nullable=True, default='UTC')
     type = db.Column(db.String(20), nullable=True, server_default='Active')
 
-    # language information
-    default_language = db.Column(db.String(2), nullable=True)
-
    # Entitlements
     currency = db.Column(db.String(20), nullable=True)
     storage_dirty = db.Column(db.Boolean, nullable=True, default=False)
@@ -61,7 +58,6 @@ class Tenant(db.Model):
             'website': self.website,
             'timezone': self.timezone,
             'type': self.type,
-            'default_language': self.default_language,
             'currency': self.currency,
             'default_tenant_make_id': self.default_tenant_make_id,
         }
@@ -186,6 +182,8 @@ class TenantMake(db.Model):
     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)
+    default_language = db.Column(db.String(2), nullable=True)
+    allowed_languages = db.Column(ARRAY(sa.String(2)), nullable=True)
 
     # Chat customisation options
     chat_customisation_options = db.Column(JSONB, nullable=True)
@@ -208,6 +206,8 @@ class TenantMake(db.Model):
             'website': self.website,
             'logo_url': self.logo_url,
             'chat_customisation_options': self.chat_customisation_options,
+            'allowed_languages': self.allowed_languages,
+            'default_language': self.default_language,
         }
 
 
@@ -317,3 +317,40 @@ class SpecialistMagicLinkTenant(db.Model):
 
     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=True)
+    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)
+
+
+class PartnerRAGRetriever(db.Model):
+    __bind_key__ = 'public'
+    __table_args__ = (
+        db.PrimaryKeyConstraint('tenant_id', 'retriever_id'),
+        db.UniqueConstraint('partner_id', 'tenant_id', 'retriever_id'),
+        {'schema': 'public'},
+    )
+
+    partner_id = db.Column(db.Integer, db.ForeignKey('public.partner.id'), nullable=False)
+    tenant_id = db.Column(db.Integer, db.ForeignKey('public.tenant.id'), nullable=False)
+    retriever_id = db.Column(db.Integer, nullable=False)

common/services/entitlements/license_period_services.py

@@ -41,7 +41,7 @@ class LicensePeriodServices:
                 current_app.logger.debug(f"Found license period {license_period.id} for tenant {tenant_id} "
                                          f"with status {license_period.status}")
                 match license_period.status:
-                    case PeriodStatus.UPCOMING:
+                    case PeriodStatus.UPCOMING | PeriodStatus.PENDING:
                         current_app.logger.debug(f"In upcoming state")
                         LicensePeriodServices._complete_last_license_period(tenant_id=tenant_id)
                         current_app.logger.debug(f"Completed last license period for tenant {tenant_id}")
@@ -71,10 +71,10 @@ class LicensePeriodServices:
                             delta = abs(current_date - license_period.period_start)
                             if delta > timedelta(days=current_app.config.get('ENTITLEMENTS_MAX_PENDING_DAYS', 5)):
                                 raise EveAIPendingLicensePeriod()
+                            else:
+                                return license_period
                     case PeriodStatus.ACTIVE:
                         return license_period
-                    case PeriodStatus.PENDING:
-                        return license_period
             else:
                 raise EveAILicensePeriodsExceeded(license_id=None)
         except SQLAlchemyError as e:
@@ -125,7 +125,7 @@ class LicensePeriodServices:
             tenant_id=tenant_id,
             period_number=next_period_number,
             period_start=the_license.start_date + relativedelta(months=next_period_number-1),
-            period_end=the_license.end_date + relativedelta(months=next_period_number, days=-1),
+            period_end=the_license.start_date + relativedelta(months=next_period_number, days=-1),
             status=PeriodStatus.UPCOMING,
             upcoming_at=dt.now(tz.utc),
         )

common/services/interaction/asset_services.py

@@ -0,0 +1,9 @@
+from common.models.interaction import EveAIAsset
+from common.extensions import minio_client
+
+
+class AssetServices:
+
+    @staticmethod
+    def add_or_replace_asset_file(asset_id, file_data):
+        asset = EveAIAsset.query.get_or_404(asset_id)

common/services/interaction/capsule_services.py

@@ -0,0 +1,25 @@
+from datetime import datetime as dt, timezone as tz
+
+from common.models.interaction import EveAIDataCapsule
+from common.extensions import db
+from common.utils.model_logging_utils import set_logging_information, update_logging_information
+
+
+class CapsuleServices:
+    @staticmethod
+    def push_capsule_data(chat_session_id: str, type: str, type_version: str, configuration: dict, data: dict):
+        capsule = EveAIDataCapsule.query.filter_by(chat_session_id=chat_session_id, type=type, type_version=type_version).first()
+        if capsule:
+            # Update bestaande capsule als deze al bestaat
+            capsule.configuration = configuration
+            capsule.data = data
+            update_logging_information(capsule, dt.now(tz.utc))
+        else:
+            # Maak nieuwe capsule aan als deze nog niet bestaat
+            capsule = EveAIDataCapsule(chat_session_id=chat_session_id, type=type, type_version=type_version,
+                                       configuration=configuration, data=data)
+            set_logging_information(capsule, dt.now(tz.utc))
+            db.session.add(capsule)
+
+        db.session.commit()
+        return capsule

common/services/user/partner_services.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Dict, Any
 
 from flask import session
 from sqlalchemy.exc import SQLAlchemyError
@@ -43,5 +43,11 @@ class PartnerServices:
 
         return license_tier_ids
 
+    @staticmethod
+    def get_management_service() -> Dict[str, Any]:
+        management_service = next((service for service in session['partner']['services']
+                                   if service.get('type') == 'MANAGEMENT_SERVICE'), None)
+        return management_service
+
 
 

common/services/user/tenant_services.py

@@ -47,101 +47,101 @@ class TenantServices:
             current_app.logger.error(f"Error associating tenant {tenant_id} with partner: {str(e)}")
             raise e
 
-        @staticmethod
-        def get_available_types_for_tenant(tenant_id: int, config_type: str) -> Dict[str, Dict[str, str]]:
-            """
-            Get available configuration types for a tenant based on partner relationships
+    @staticmethod
+    def get_available_types_for_tenant(tenant_id: int, config_type: str) -> Dict[str, Dict[str, str]]:
+        """
+        Get available configuration types for a tenant based on partner relationships
 
-            Args:
-                tenant_id: The tenant ID
-                config_type: The configuration type ('specialists', 'agents', 'tasks', etc.)
+        Args:
+            tenant_id: The tenant ID
+            config_type: The configuration type ('specialists', 'agents', 'tasks', etc.)
 
-            Returns:
-                Dictionary of available types for the tenant
-            """
-            # Get the appropriate cache handler based on config_type
-            cache_handler = None
-            if config_type == 'specialists':
-                cache_handler = cache_manager.specialists_types_cache
-            elif config_type == 'agents':
-                cache_handler = cache_manager.agents_types_cache
-            elif config_type == 'tasks':
-                cache_handler = cache_manager.tasks_types_cache
-            elif config_type == 'tools':
-                cache_handler = cache_manager.tools_types_cache
-            else:
-                raise ValueError(f"Unsupported config type: {config_type}")
+        Returns:
+            Dictionary of available types for the tenant
+        """
+        # Get the appropriate cache handler based on config_type
+        cache_handler = None
+        if config_type == 'specialists':
+            cache_handler = cache_manager.specialists_types_cache
+        elif config_type == 'agents':
+            cache_handler = cache_manager.agents_types_cache
+        elif config_type == 'tasks':
+            cache_handler = cache_manager.tasks_types_cache
+        elif config_type == 'tools':
+            cache_handler = cache_manager.tools_types_cache
+        elif config_type == 'catalogs':
+            cache_handler = cache_manager.catalogs_types_cache
+        elif config_type == 'retrievers':
+            cache_handler = cache_manager.retrievers_types_cache
+        else:
+            raise ValueError(f"Unsupported config type: {config_type}")
 
-            # Get all types with their metadata (including partner info)
-            all_types = cache_handler.get_types()
+        # Get all types with their metadata (including partner info)
+        all_types = cache_handler.get_types()
 
-            # Filter to include:
-            # 1. Types with no partner (global)
-            # 2. Types with partners that have a SPECIALIST_SERVICE relationship with this tenant
-            available_partners = TenantServices.get_tenant_partner_names(tenant_id)
+        # Filter to include:
+        # 1. Types with no partner (global)
+        # 2. Types with partners that have a SPECIALIST_SERVICE relationship with this tenant
+        available_partners = TenantServices.get_tenant_partner_specialist_denominators(tenant_id)
 
-            available_types = {
-                type_id: info for type_id, info in all_types.items()
-                if info.get('partner') is None or info.get('partner') in available_partners
-            }
+        available_types = {
+            type_id: info for type_id, info in all_types.items()
+            if info.get('partner') is None or info.get('partner') in available_partners
+        }
 
-            return available_types
+        return available_types
 
-        @staticmethod
-        def get_tenant_partner_names(tenant_id: int) -> List[str]:
-            """
-            Get names of partners that have a SPECIALIST_SERVICE relationship with this tenant
+    @staticmethod
+    def get_tenant_partner_specialist_denominators(tenant_id: int) -> List[str]:
+        """
+        Get names of partners that have a SPECIALIST_SERVICE relationship with this tenant, that can be used for
+        filtering configurations.
 
-            Args:
-                tenant_id: The tenant ID
+        Args:
+            tenant_id: The tenant ID
 
-            Returns:
-                List of partner names (tenant names)
-            """
-            # Find all PartnerTenant relationships for this tenant
-            partner_names = []
-            try:
-                # Get all partner services of type SPECIALIST_SERVICE
-                specialist_services = (
+        Returns:
+            List of partner names (tenant names)
+        """
+        # Find all PartnerTenant relationships for this tenant
+        partner_service_denominators = []
+        try:
+            # Get all partner services of type SPECIALIST_SERVICE
+            specialist_services = (
+                PartnerService.query
+                .filter_by(type='SPECIALIST_SERVICE')
+                .all()
+            )
+
+            if not specialist_services:
+                return []
+
+            # Find tenant relationships with these services
+            partner_tenants = (
+                PartnerTenant.query
+                .filter_by(tenant_id=tenant_id)
+                .filter(PartnerTenant.partner_service_id.in_([svc.id for svc in specialist_services]))
+                .all()
+            )
+
+            # Get the partner names (their tenant names)
+            for pt in partner_tenants:
+                partner_service = (
                     PartnerService.query
-                    .filter_by(type='SPECIALIST_SERVICE')
-                    .all()
+                    .filter_by(id=pt.partner_service_id)
+                    .first()
                 )
 
-                if not specialist_services:
-                    return []
+                if partner_service:
+                    partner_service_denominators.append(partner_service.configuration.get("specialist_denominator", ""))
 
-                # Find tenant relationships with these services
-                partner_tenants = (
-                    PartnerTenant.query
-                    .filter_by(tenant_id=tenant_id)
-                    .filter(PartnerTenant.partner_service_id.in_([svc.id for svc in specialist_services]))
-                    .all()
-                )
+        except SQLAlchemyError as e:
+            current_app.logger.error(f"Database error retrieving partner names: {str(e)}")
 
-                # Get the partner names (their tenant names)
-                for pt in partner_tenants:
-                    partner_service = (
-                        PartnerService.query
-                        .filter_by(id=pt.partner_service_id)
-                        .first()
-                    )
+        return partner_service_denominators
 
-                    if partner_service:
-                        partner = Partner.query.get(partner_service.partner_id)
-                        if partner:
-                            # Get the tenant associated with this partner
-                            partner_tenant = Tenant.query.get(partner.tenant_id)
-                            if partner_tenant:
-                                partner_names.append(partner_tenant.name)
-
-            except SQLAlchemyError as e:
-                current_app.logger.error(f"Database error retrieving partner names: {str(e)}")
-
-            return partner_names
-
-        @staticmethod
-        def can_use_specialist_type(tenant_id: int, specialist_type: str) -> bool:
+    @staticmethod
+    def can_use_specialist_type(tenant_id: int, specialist_type: str) -> bool:
             """
             Check if a tenant can use a specific specialist type
 
@@ -166,7 +166,7 @@ class TenantServices:
 
                 # If it's a partner-specific specialist, check if tenant has access
                 partner_name = specialist_def.get('partner')
-                available_partners = TenantServices.get_tenant_partner_names(tenant_id)
+                available_partners = TenantServices.get_tenant_partner_specialist_denominators(tenant_id)
 
                 return partner_name in available_partners
 

common/services/utils/human_answer_services.py

@@ -0,0 +1,108 @@
+from flask import current_app, session
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+
+from common.utils.business_event import BusinessEvent
+from common.utils.business_event_context import current_event
+from common.utils.model_utils import get_template
+from eveai_chat_workers.outputs.globals.a2q_output.q_a_output_v1_0 import A2QOutput
+from eveai_chat_workers.outputs.globals.q_a_output.q_a_output_v1_0 import QAOutput
+
+
+class HumanAnswerServices:
+    @staticmethod
+    def check_affirmative_answer(tenant_id: int, question: str, answer: str, language_iso: str) -> bool:
+        return HumanAnswerServices._check_answer(tenant_id, question, answer, language_iso, "check_affirmative_answer",
+                                                 "Check Affirmative Answer")
+
+    @staticmethod
+    def check_additional_information(tenant_id: int, question: str, answer: str, language_iso: str) -> bool:
+        result = HumanAnswerServices._check_answer(tenant_id, question, answer, language_iso,
+                                                   "check_additional_information", "Check Additional Information")
+
+        return result
+
+    @staticmethod
+    def get_answer_to_question(tenant_id: int, question: str, answer: str, language_iso: str) -> str:
+
+        language = HumanAnswerServices._process_arguments(question, answer, language_iso)
+        span_name = "Get Answer To Question"
+        template_name = "get_answer_to_question"
+
+        if not current_event:
+            with BusinessEvent('Answer Check Service', tenant_id):
+                with current_event.create_span(span_name):
+                    return HumanAnswerServices._get_answer_to_question_logic(question, answer, language, template_name)
+        else:
+            with current_event.create_span('Check Affirmative Answer'):
+                return HumanAnswerServices._get_answer_to_question_logic(question, answer, language, template_name)
+
+    @staticmethod
+    def _check_answer(tenant_id: int, question: str, answer: str, language_iso: str, template_name: str,
+                      span_name: str) -> bool:
+        language = HumanAnswerServices._process_arguments(question, answer, language_iso)
+        if not current_event:
+            with BusinessEvent('Answer Check Service', tenant_id):
+                with current_event.create_span(span_name):
+                    return HumanAnswerServices._check_answer_logic(question, answer, language, template_name)
+        else:
+            with current_event.create_span(span_name):
+                return HumanAnswerServices._check_answer_logic(question, answer, language, template_name)
+
+    @staticmethod
+    def _check_answer_logic(question: str, answer: str, language: str, template_name: str) -> bool:
+        prompt_params = {
+            'question': question,
+            'answer': answer,
+            'language': language,
+        }
+
+        template, llm = get_template(template_name)
+        check_answer_prompt = ChatPromptTemplate.from_template(template)
+        setup = RunnablePassthrough()
+
+        output_schema = QAOutput
+        structured_llm = llm.with_structured_output(output_schema)
+
+        chain = (setup | check_answer_prompt | structured_llm )
+
+        raw_answer = chain.invoke(prompt_params)
+
+        return raw_answer.answer
+
+    @staticmethod
+    def _get_answer_to_question_logic(question: str, answer: str, language: str, template_name: str) \
+            -> str:
+        prompt_params = {
+            'question': question,
+            'answer': answer,
+            'language': language,
+        }
+
+        template, llm = get_template(template_name)
+        check_answer_prompt = ChatPromptTemplate.from_template(template)
+        setup = RunnablePassthrough()
+
+        output_schema = A2QOutput
+        structured_llm = llm.with_structured_output(output_schema)
+
+        chain = (setup | check_answer_prompt | structured_llm)
+
+        raw_answer = chain.invoke(prompt_params)
+
+        return raw_answer.answer
+
+    @staticmethod
+    def _process_arguments(question, answer, language_iso: str) -> str:
+        if language_iso.strip() == '':
+            raise ValueError("Language cannot be empty")
+        language = current_app.config.get('SUPPORTED_LANGUAGE_ISO639_1_LOOKUP').get(language_iso)
+        if language is None:
+            raise ValueError(f"Unsupported language: {language_iso}")
+        if question.strip() == '':
+            raise ValueError("Question cannot be empty")
+        if answer.strip() == '':
+            raise ValueError("Answer cannot be empty")
+
+        return language

common/services/utils/translation_services.py

@@ -0,0 +1,148 @@
+import json
+from typing import Dict, Any, Optional
+
+from flask import session
+
+from common.extensions import cache_manager
+from common.utils.business_event import BusinessEvent
+from common.utils.business_event_context import current_event
+
+class TranslationServices:
+
+    @staticmethod
+    def translate_config(tenant_id: int, config_data: Dict[str, Any], field_config: str, target_language: str,
+                         source_language: Optional[str] = None, context: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Vertaalt een configuratie op basis van een veld-configuratie.
+
+        Args:
+            tenant_id: Identificatie van de tenant waarvoor we de vertaling doen.
+            config_data: Een dictionary of JSON (die dan wordt geconverteerd naar een dictionary) met configuratiegegevens
+            field_config: De naam van een veld-configuratie (bijv. 'fields')
+            target_language: De taal waarnaar vertaald moet worden
+            source_language: Optioneel, de brontaal van de configuratie
+            context: Optioneel, een specifieke context voor de vertaling
+
+        Returns:
+            Een dictionary met de vertaalde configuratie
+        """
+        config_type = config_data.get('type', 'Unknown')
+        config_version = config_data.get('version', 'Unknown')
+        span_name = f"{config_type}-{config_version}-{field_config}"
+
+        if current_event:
+            with current_event.create_span(span_name):
+                translated_config = TranslationServices._translate_config(tenant_id, config_data, field_config,
+                                                                          target_language, source_language, context)
+                return translated_config
+        else:
+            with BusinessEvent('Config Translation Service', tenant_id):
+                with current_event.create_span(span_name):
+                    translated_config = TranslationServices._translate_config(tenant_id, config_data, field_config,
+                                                                              target_language, source_language, context)
+                    return translated_config
+
+    @staticmethod
+    def _translate_config(tenant_id: int, config_data: Dict[str, Any], field_config: str, target_language: str,
+                          source_language: Optional[str] = None, context: Optional[str] = None) -> Dict[str, Any]:
+
+        # Zorg ervoor dat we een dictionary hebben
+        if isinstance(config_data, str):
+            config_data = json.loads(config_data)
+
+        # Maak een kopie van de originele data om te wijzigen
+        translated_config = config_data.copy()
+
+        # Haal type en versie op voor de Business Event span
+        config_type = config_data.get('type', 'Unknown')
+        config_version = config_data.get('version', 'Unknown')
+
+        if field_config in config_data:
+            fields = config_data[field_config]
+
+            # Haal description uit metadata voor context als geen context is opgegeven
+            description_context = ""
+            if not context and 'metadata' in config_data and 'description' in config_data['metadata']:
+                description_context = config_data['metadata']['description']
+
+            # Loop door elk veld in de configuratie
+            for field_name, field_data in fields.items():
+                # Vertaal name als het bestaat en niet leeg is
+                if 'name' in field_data and field_data['name']:
+                    # Gebruik context indien opgegeven, anders description_context
+                    field_context = context if context else description_context
+                    translated_name = cache_manager.translation_cache.get_translation(
+                        text=field_data['name'],
+                        target_lang=target_language,
+                        source_lang=source_language,
+                        context=field_context
+                    )
+                    if translated_name:
+                        translated_config[field_config][field_name]['name'] = translated_name.translated_text
+
+                if 'title' in field_data and field_data['title']:
+                    # Gebruik context indien opgegeven, anders description_context
+                    field_context = context if context else description_context
+                    translated_title = cache_manager.translation_cache.get_translation(
+                        text=field_data['title'],
+                        target_lang=target_language,
+                        source_lang=source_language,
+                        context=field_context
+                    )
+                    if translated_title:
+                        translated_config[field_config][field_name]['title'] = translated_title.translated_text
+
+                # Vertaal description als het bestaat en niet leeg is
+                if 'description' in field_data and field_data['description']:
+                    # Gebruik context indien opgegeven, anders description_context
+                    field_context = context if context else description_context
+                    translated_desc = cache_manager.translation_cache.get_translation(
+                        text=field_data['description'],
+                        target_lang=target_language,
+                        source_lang=source_language,
+                        context=field_context
+                    )
+                    if translated_desc:
+                        translated_config[field_config][field_name]['description'] = translated_desc.translated_text
+
+                # Vertaal context als het bestaat en niet leeg is
+                if 'context' in field_data and field_data['context']:
+                    translated_ctx = cache_manager.translation_cache.get_translation(
+                        text=field_data['context'],
+                        target_lang=target_language,
+                        source_lang=source_language,
+                        context=context
+                    )
+                    if translated_ctx:
+                        translated_config[field_config][field_name]['context'] = translated_ctx.translated_text
+
+                # vertaal allowed values als het veld bestaat en de waarden niet leeg zijn.
+                if 'allowed_values' in field_data and field_data['allowed_values']:
+                    translated_allowed_values = []
+                    for allowed_value in field_data['allowed_values']:
+                        translated_allowed_value = cache_manager.translation_cache.get_translation(
+                            text=allowed_value,
+                            target_lang=target_language,
+                            source_lang=source_language,
+                            context=context
+                        )
+                        translated_allowed_values.append(translated_allowed_value.translated_text)
+                    if translated_allowed_values:
+                        translated_config[field_config][field_name]['allowed_values'] = translated_allowed_values
+
+            return translated_config
+
+    @staticmethod
+    def translate(tenant_id: int, text: str, target_language: str, source_language: Optional[str] = None,
+                  context: Optional[str] = None)-> str:
+        if current_event:
+            with current_event.create_span('Translation'):
+                translation_cache = cache_manager.translation_cache.get_translation(text, target_language,
+                                                                                    source_language, context)
+                return translation_cache.translated_text
+        else:
+            with BusinessEvent('Translation Service', tenant_id):
+                with current_event.create_span('Translation'):
+                    translation_cache = cache_manager.translation_cache.get_translation(text, target_language,
+                                                                                        source_language, context)
+                    return translation_cache.translated_text

common/utils/asset_utils.py

@@ -4,59 +4,9 @@ from flask import current_app
 from sqlalchemy.exc import SQLAlchemyError
 
 from common.extensions import cache_manager, minio_client, db
-from common.models.interaction import EveAIAsset, EveAIAssetVersion
+from common.models.interaction import EveAIAsset
 from common.utils.model_logging_utils import set_logging_information
 
 
-def create_asset_stack(api_input, tenant_id):
-    type_version = cache_manager.assets_version_tree_cache.get_latest_version(api_input['type'])
-    api_input['type_version'] = type_version
-    new_asset = create_asset(api_input, tenant_id)
-    new_asset_version = create_version_for_asset(new_asset, tenant_id)
-    db.session.add(new_asset)
-    db.session.add(new_asset_version)
-
-    try:
-        db.session.commit()
-    except SQLAlchemyError as e:
-        current_app.logger.error(f"Could not add asset for tenant {tenant_id}: {str(e)}")
-        db.session.rollback()
-        raise e
-
-    return new_asset, new_asset_version
-
-
-def create_asset(api_input, tenant_id):
-    new_asset = EveAIAsset()
-    new_asset.name = api_input['name']
-    new_asset.description = api_input['description']
-    new_asset.type = api_input['type']
-    new_asset.type_version = api_input['type_version']
-    if api_input['valid_from'] and api_input['valid_from'] != '':
-        new_asset.valid_from = api_input['valid_from']
-    else:
-        new_asset.valid_from = dt.now(tz.utc)
-    new_asset.valid_to = api_input['valid_to']
-    set_logging_information(new_asset, dt.now(tz.utc))
-
-    return new_asset
-
-
-def create_version_for_asset(asset, tenant_id):
-    new_asset_version = EveAIAssetVersion()
-    new_asset_version.asset = asset
-    new_asset_version.bucket_name = minio_client.create_tenant_bucket(tenant_id)
-    set_logging_information(new_asset_version, dt.now(tz.utc))
-
-    return new_asset_version
-
-
-def add_asset_version_file(asset_version, field_name, file, tenant_id):
-    object_name, file_size = minio_client.upload_file(asset_version.bucket_name, asset_version.id, field_name,
-                                                      file.content_type)
-    # mark_tenant_storage_dirty(tenant_id)
-    # TODO - zorg ervoor dat de herberekening van storage onmiddellijk gebeurt!
-    return object_name
-
 
 

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, processor_types, customisation_types, specialist_form_types
+    catalog_types, partner_service_types, processor_types, customisation_types, specialist_form_types, capsule_types
 
 
 def is_major_minor(version: str) -> bool:
@@ -332,24 +332,22 @@ class BaseConfigTypesCacheHandler(CacheHandler[Dict[str, Any]]):
         """
         return isinstance(value, dict)  # Cache all dictionaries
 
-    def _load_type_definitions(self) -> Dict[str, Dict[str, str]]:
+    def _load_type_definitions(self) -> Dict[str, Dict[str, Any]]:
         """Load type definitions from the corresponding type_defs module"""
         if not self._types_module:
             raise ValueError("_types_module must be set by subclass")
 
-        type_definitions = {
-            type_id: {
-                'name': info['name'],
-                'description': info['description'],
-                'partner': info.get('partner')  # Include partner info if available
-            }
-            for type_id, info in self._types_module.items()
-        }
+        type_definitions = {}
+        for type_id, info in self._types_module.items():
+            # Kopieer alle velden uit de type definitie
+            type_definitions[type_id] = {}
+            for key, value in info.items():
+                type_definitions[type_id][key] = value
 
         return type_definitions
 
-    def get_types(self) -> Dict[str, Dict[str, str]]:
-        """Get dictionary of available types with name and description"""
+    def get_types(self) -> Dict[str, Dict[str, Any]]:
+        """Get dictionary of available types with all defined properties"""
         result = self.get(
             lambda type_name: self._load_type_definitions(),
             type_name=f'{self.config_type}_types',
@@ -487,6 +485,15 @@ SpecialistFormConfigCacheHandler, SpecialistFormConfigVersionTreeCacheHandler, S
 )
 
 
+CapsuleConfigCacheHandler, CapsuleConfigVersionTreeCacheHandler, CapsuleConfigTypesCacheHandler = (
+    create_config_cache_handlers(
+        config_type='data_capsules',
+        config_dir='config/data_capsules',
+        types_module=capsule_types.CAPSULE_TYPES
+    )
+)
+
+
 def register_config_cache_handlers(cache_manager) -> None:
     cache_manager.register_handler(AgentConfigCacheHandler, 'eveai_config')
     cache_manager.register_handler(AgentConfigTypesCacheHandler, 'eveai_config')

common/utils/cache/regions.py

@@ -42,7 +42,7 @@ def create_cache_regions(app):
     # Region for model-related caching (ModelVariables etc)
     model_region = make_region(name='eveai_model').configure(
         'dogpile.cache.redis',
-        arguments=redis_config,
+        arguments={**redis_config, 'db': 6},
         replace_existing_backend=True
     )
     regions['eveai_model'] = model_region

common/utils/cache/translation_cache.py

@@ -0,0 +1,223 @@
+import json
+import re
+from typing import Dict, Any, Optional
+from datetime import datetime as dt, timezone as tz
+
+import xxhash
+from flask import current_app
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from sqlalchemy.inspection import inspect
+
+from common.langchain.persistent_llm_metrics_handler import PersistentLLMMetricsHandler
+from common.utils.business_event_context import current_event
+from common.utils.cache.base import CacheHandler, T
+from common.extensions import db
+
+from common.models.user import TranslationCache
+from flask_security import current_user
+
+from common.utils.model_utils import get_template
+
+
+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)
+
+        metrics = {
+            'total_tokens': translation.prompt_tokens + translation.completion_tokens,
+            'prompt_tokens': translation.prompt_tokens,
+            'completion_tokens': translation.completion_tokens,
+            'time_elapsed': 0,
+            'interaction_type': 'TRANSLATION-CACHE'
+        }
+        current_event.log_llm_metrics(metrics)
+
+        return translation
+
+    def _should_cache(self, value) -> bool:
+        """Validate if the translation should be cached"""
+        if value is None:
+            return False
+
+        # Handle both TranslationCache objects and serialized data (dict)
+        if isinstance(value, TranslationCache):
+            return value.cache_key is not None
+        elif isinstance(value, dict):
+            return value.get('cache_key') is not None
+
+        return False
+
+    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
+        """
+        if not context:
+            context = 'No context provided.'
+
+        def creator_func(hash_key: str) -> Optional[TranslationCache]:
+            # Check if translation already exists in database
+            existing_translation = db.session.query(TranslationCache).filter_by(cache_key=hash_key).first()
+
+            if existing_translation:
+                # Update last used timestamp
+                existing_translation.last_used_at = dt.now(tz=tz.utc)
+                metrics = {
+                    'total_tokens': existing_translation.prompt_tokens + existing_translation.completion_tokens,
+                    'prompt_tokens': existing_translation.prompt_tokens,
+                    'completion_tokens': existing_translation.completion_tokens,
+                    'time_elapsed': 0,
+                    'interaction_type': 'TRANSLATION-DB'
+                }
+                current_event.log_llm_metrics(metrics)
+                db.session.commit()
+                return existing_translation
+
+            # Translation not found in DB, need to create it
+            # Get the translation and metrics
+            translated_text, metrics = self.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=hash_key,
+                source_text=text,
+                translated_text=translated_text,
+                source_language=source_lang,
+                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
+
+        # Generate the hash key using your existing method
+        hash_key = self._generate_cache_key(text, target_lang, source_lang, context)
+
+        # Pass the hash_key to the get method
+        return self.get(creator_func, hash_key=hash_key)
+
+    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 translate_text(self, text_to_translate: str, target_lang: str, source_lang: str = None, context: str = None) \
+            -> tuple[str, dict[str, int | float]]:
+        target_language = current_app.config['SUPPORTED_LANGUAGE_ISO639_1_LOOKUP'][target_lang]
+        prompt_params = {
+            "text_to_translate": text_to_translate,
+            "target_language": target_language,
+        }
+        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)
+
+        # Remove double square brackets from translation
+        translation = re.sub(r'\[\[(.*?)\]\]', r'\1', translation)
+
+        metrics = metrics_handler.get_metrics()
+
+        return translation, metrics
+
+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

@@ -1,14 +1,19 @@
+import json
+import re
+
 """
 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_customization (dict, optional): The tenant's customization options.
-            Defaults to None.
+        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
@@ -16,18 +21,22 @@ def get_default_chat_customisation(tenant_customisation=None):
     """
     # Default customization options
     default_customisation = {
-        'primary_color': '#007bff',
-        'secondary_color': '#6c757d',
-        'background_color': '#ffffff',
-        'text_color': '#212529',
+        'sidebar_markdown': '',
         '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?',
+        'gradient_start_color': '#f5f7fa',
+        'gradient_end_color': '#c3cfe2',
+        'progress_tracker_insights': 'No Information',
+        'form_title_display': 'Full Title',
+        'active_background_color': '#ffffff',
+        'history_background': 10,
+        'ai_message_background': '#ffffff',
+        'ai_message_text_color': '#212529',
+        'human_message_background': '#212529',
+        'human_message_text_color': '#ffffff',
+
     }
 
     # If no tenant customization is provided, return the defaults
@@ -37,9 +46,127 @@ def get_default_chat_customisation(tenant_customisation=None):
     # 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)
+        except json.JSONDecodeError as e:
+            current_app.logger.error(f"Error parsing JSON customisation: {e}")
+            return default_customisation
+
     # Update with tenant customization
-    for key, value in tenant_customisation.items():
-        if key in customisation:
-            customisation[key] = value
+    if tenant_customisation:
+        for key, value in tenant_customisation.items():
+            if key in customisation:
+                customisation[key] = value
 
     return customisation
+
+
+def hex_to_rgb(hex_color):
+    """
+    Convert hex color to RGB tuple.
+    
+    Args:
+        hex_color (str): Hex color string (e.g., '#ffffff' or 'ffffff')
+    
+    Returns:
+        tuple: RGB values as (r, g, b)
+    """
+    # Remove # if present
+    hex_color = hex_color.lstrip('#')
+    
+    # Handle 3-character hex codes
+    if len(hex_color) == 3:
+        hex_color = ''.join([c*2 for c in hex_color])
+    
+    # Convert to RGB
+    try:
+        return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+    except ValueError:
+        # Return white as fallback
+        return (255, 255, 255)
+
+
+def adjust_color_alpha(percentage):
+    """
+    Convert percentage to RGBA color with appropriate base color and alpha.
+    
+    Args:
+        percentage (int): Percentage (-50 to 50)
+                         Positive = white base (lighten)
+                         Negative = black base (darken)
+                         Zero = transparent
+    
+    Returns:
+        str: RGBA color string for CSS
+    """
+    if percentage == 0:
+        return 'rgba(255, 255, 255, 0)'  # Volledig transparant
+    
+    # Bepaal basis kleur
+    if percentage > 0:
+        # Positief = wit voor verheldering
+        base_color = (255, 255, 255)
+    else:
+        # Negatief = zwart voor verdonkering  
+        base_color = (0, 0, 0)
+    
+    # Bereken alpha op basis van percentage (max 50 = alpha 1.0)
+    alpha = abs(percentage) / 50.0
+    alpha = max(0.0, min(1.0, alpha))  # Zorg voor 0.0-1.0 range
+    
+    return f'rgba({base_color[0]}, {base_color[1]}, {base_color[2]}, {alpha})'
+
+
+def adjust_color_brightness(hex_color, percentage):
+    """
+    Adjust the brightness of a hex color by a percentage.
+    
+    Args:
+        hex_color (str): Hex color string (e.g., '#ffffff')
+        percentage (int): Percentage to adjust (-100 to 100)
+                         Positive = lighter, Negative = darker
+    
+    Returns:
+        str: RGBA color string for CSS (e.g., 'rgba(255, 255, 255, 0.9)')
+    """
+    if not hex_color or not isinstance(hex_color, str):
+        return 'rgba(255, 255, 255, 0.1)'
+    
+    # Get RGB values
+    r, g, b = hex_to_rgb(hex_color)
+    
+    # Calculate adjustment factor
+    if percentage > 0:
+        # Lighten: move towards white
+        factor = percentage / 100.0
+        r = int(r + (255 - r) * factor)
+        g = int(g + (255 - g) * factor)
+        b = int(b + (255 - b) * factor)
+    else:
+        # Darken: move towards black
+        factor = abs(percentage) / 100.0
+        r = int(r * (1 - factor))
+        g = int(g * (1 - factor))
+        b = int(b * (1 - factor))
+    
+    # Ensure values are within 0-255 range
+    r = max(0, min(255, r))
+    g = max(0, min(255, g))
+    b = max(0, min(255, b))
+    
+    # Return as rgba with slight transparency for better blending
+    return f'rgba({r}, {g}, {b}, 0.9)'
+
+
+def get_base_background_color():
+    """
+    Get the base background color for history adjustments.
+    This should be the main chat background color.
+    
+    Returns:
+        str: Hex color string
+    """
+    # Use a neutral base color that works well with adjustments
+    return '#f8f9fa'

common/utils/content_utils.py

@@ -4,8 +4,6 @@ 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
@@ -16,10 +14,10 @@ class ContentManager:
         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']}")
+        # 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):
         """
@@ -66,12 +64,12 @@ class ContentManager:
             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}")
+                current_app.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)
+                available_versions = [f for f in os.listdir(content_path) if not f.startswith('.')]
                 if not available_versions:
                     return None
 
@@ -81,16 +79,19 @@ class ContentManager:
 
             # Nu we major_minor hebben, zoek de hoogste patch
             major_minor_path = os.path.join(content_path, major_minor)
+            current_app.logger.debug(f"Major/Minor path: {major_minor_path}")
 
             if not os.path.exists(major_minor_path):
-                logger.error(f"Version path does not exist: {major_minor_path}")
+                current_app.logger.error(f"Version path does not exist: {major_minor_path}")
                 return None
 
-            files = os.listdir(major_minor_path)
+            files = [f for f in os.listdir(major_minor_path) if not f.startswith('.')]
+            current_app.logger.debug(f"Files in version path: {files}")
             version_files = []
 
             for file in files:
                 mm, p = self._parse_version(file)
+                current_app.logger.debug(f"File: {file}, mm: {mm}, p: {p}")
                 if mm == major_minor and p:
                     version_files.append((mm, p, f"{mm}.{p}"))
 
@@ -99,10 +100,12 @@ class ContentManager:
 
             # Sorteer op patch nummer
             version_files.sort(key=lambda v: int(v[1]))
+
+            current_app.logger.debug(f"Latest version: {version_files[-1]}")
             return version_files[-1]
 
         except Exception as e:
-            logger.error(f"Error finding latest version for {content_type}: {str(e)}")
+            current_app.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):
@@ -125,11 +128,12 @@ class ContentManager:
             } of None bij fout
         """
         try:
+            current_app.logger.debug(f"Reading content {content_type}")
             # 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}")
+                    current_app.logger.error(f"No versions found for {content_type}")
                     return None
 
                 major_minor, patch, full_version = version_info
@@ -138,7 +142,7 @@ class ContentManager:
             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}")
+                    current_app.logger.error(f"No versions found for {content_type} {major_minor}")
                     return None
 
                 major_minor, patch, full_version = version_info
@@ -147,14 +151,17 @@ class ContentManager:
 
             # Nu hebben we major_minor en patch, lees het bestand
             file_path = self.get_content_path(content_type, major_minor, patch)
+            current_app.logger.debug(f"Content File path: {file_path}")
 
             if not os.path.exists(file_path):
-                logger.error(f"Content file does not exist: {file_path}")
+                current_app.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()
 
+            current_app.logger.debug(f"Content read: {content}")
+
             return {
                 'content': content,
                 'version': full_version,
@@ -162,7 +169,7 @@ class ContentManager:
             }
 
         except Exception as e:
-            logger.error(f"Error reading content {content_type} {major_minor}.{patch}: {str(e)}")
+            current_app.logger.error(f"Error reading content {content_type} {major_minor}.{patch}: {str(e)}")
             return None
 
     def list_content_types(self):
@@ -171,7 +178,7 @@ class ContentManager:
             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)}")
+            current_app.logger.error(f"Error listing content types: {str(e)}")
             return []
 
     def list_versions(self, content_type):
@@ -211,5 +218,5 @@ class ContentManager:
             return versions
 
         except Exception as e:
-            logger.error(f"Error listing versions for {content_type}: {str(e)}")
+            current_app.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,15 +11,15 @@ 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)
+from .minio_utils import MIB_CONVERTOR
 from ..models.user import Tenant
 from common.utils.model_logging_utils import set_logging_information, update_logging_information
 from common.services.entitlements import LicenseUsageServices
 
-MB_CONVERTOR = 1_048_576
-
 
 def get_file_size(file):
     try:
@@ -38,7 +38,7 @@ def get_file_size(file):
 def create_document_stack(api_input, file, filename, extension, tenant_id):
     # Precheck if we can add a document to the stack
 
-    LicenseUsageServices.check_storage_and_embedding_quota(tenant_id, get_file_size(file)/MB_CONVERTOR)
+    LicenseUsageServices.check_storage_and_embedding_quota(tenant_id, get_file_size(file) / MIB_CONVERTOR)
 
     # Create the Document
     catalog_id = int(api_input.get('catalog_id'))
@@ -143,7 +143,7 @@ def upload_file_for_version(doc_vers, file, extension, tenant_id):
         )
         doc_vers.bucket_name = bn
         doc_vers.object_name = on
-        doc_vers.file_size = size / MB_CONVERTOR  # Convert bytes to MB
+        doc_vers.file_size = size / MIB_CONVERTOR  # Convert bytes to MB
 
         db.session.commit()
         current_app.logger.info(f'Successfully saved document to MinIO for tenant {tenant_id} for '
@@ -192,9 +192,32 @@ def process_url(url, tenant_id):
     existing_doc = DocumentVersion.query.filter_by(url=url).first()
     if existing_doc:
         raise EveAIDoubleURLException
+    # Prepare the headers for maximal chance of downloading url
+    referer = get_referer_from_url(url)
+    headers = {
+        "User-Agent": (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/115.0.0.0 Safari/537.36"
+        ),
+        "Accept": (
+            "text/html,application/xhtml+xml,application/xml;"
+            "q=0.9,image/avif,image/webp,image/apng,*/*;"
+            "q=0.8,application/signed-exchange;v=b3;q=0.7"
+        ),
+        "Accept-Encoding": "gzip, deflate, br",
+        "Accept-Language": "nl-BE,nl;q=0.9,en-US;q=0.8,en;q=0.7",
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+        "Referer": referer,
+        "Sec-Fetch-Dest": "document",
+        "Sec-Fetch-Mode": "navigate",
+        "Sec-Fetch-Site": "same-origin",
+        "Sec-Fetch-User": "?1",
+    }
 
     # Download the content
-    response = requests.get(url)
+    response = requests.get(url, headers=headers)
     response.raise_for_status()
     file_content = response.content
 
@@ -353,7 +376,7 @@ def refresh_document_with_content(doc_id: int, tenant_id: int, file_content: byt
     old_doc_vers = DocumentVersion.query.filter_by(doc_id=doc_id).order_by(desc(DocumentVersion.id)).first()
 
     # Precheck if we have enough quota for the new version
-    LicenseUsageServices.check_storage_and_embedding_quota(tenant_id, get_file_size(file_content) / MB_CONVERTOR)
+    LicenseUsageServices.check_storage_and_embedding_quota(tenant_id, get_file_size(file_content) / MIB_CONVERTOR)
 
     # Create new version with same file type as original
     extension = old_doc_vers.file_type
@@ -469,3 +492,19 @@ 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()
+
+def get_referer_from_url(url):
+    parsed = urlparse(url)
+    return f"{parsed.scheme}://{parsed.netloc}/"

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)
 
 

common/utils/filtered_list_view.py

@@ -1,54 +0,0 @@
-from flask import request, render_template, abort
-from sqlalchemy import desc, asc
-
-
-class FilteredListView:
-    def __init__(self, model, template, per_page=10):
-        self.model = model
-        self.template = template
-        self.per_page = per_page
-
-    def get_query(self):
-        return self.model.query
-
-    def apply_filters(self, query):
-        filters = request.args.get('filters', {})
-        for key, value in filters.items():
-            if hasattr(self.model, key):
-                column = getattr(self.model, key)
-                if value.startswith('like:'):
-                    query = query.filter(column.like(f"%{value[5:]}%"))
-                else:
-                    query = query.filter(column == value)
-        return query
-
-    def apply_sorting(self, query):
-        sort_by = request.args.get('sort_by')
-        if sort_by and hasattr(self.model, sort_by):
-            sort_order = request.args.get('sort_order', 'asc')
-            column = getattr(self.model, sort_by)
-            if sort_order == 'desc':
-                query = query.order_by(desc(column))
-            else:
-                query = query.order_by(asc(column))
-        return query
-
-    def paginate(self, query):
-        page = request.args.get('page', 1, type=int)
-        return query.paginate(page=page, per_page=self.per_page, error_out=False)
-
-    def get(self):
-        query = self.get_query()
-        query = self.apply_filters(query)
-        query = self.apply_sorting(query)
-        pagination = self.paginate(query)
-
-        context = {
-            'items': pagination.items,
-            'pagination': pagination,
-            'model': self.model.__name__,
-            'filters': request.args.get('filters', {}),
-            'sort_by': request.args.get('sort_by'),
-            'sort_order': request.args.get('sort_order', 'asc')
-        }
-        return render_template(self.template, **context)

common/utils/mail_utils.py

@@ -6,22 +6,17 @@ from flask import current_app
 
 
 def send_email(to_email, to_name, subject, html):
-    current_app.logger.debug(f"Sending email to {to_email} with subject {subject}")
     access_key = current_app.config['SW_EMAIL_ACCESS_KEY']
     secret_key = current_app.config['SW_EMAIL_SECRET_KEY']
     default_project_id = current_app.config['SW_PROJECT']
     default_region = "fr-par"
-    current_app.logger.debug(f"Access Key: {access_key}\nSecret Key: {secret_key}\n"
-                             f"Default Project ID: {default_project_id}\nDefault Region: {default_region}")
     client = Client(
         access_key=access_key,
         secret_key=secret_key,
         default_project_id=default_project_id,
         default_region=default_region
     )
-    current_app.logger.debug(f"Scaleway Client Initialized")
     tem = TemV1Alpha1API(client)
-    current_app.logger.debug(f"Tem Initialized")
     from_ = CreateEmailRequestAddress(email=current_app.config['SW_EMAIL_SENDER'],
                                       name=current_app.config['SW_EMAIL_NAME'])
     to_ = CreateEmailRequestAddress(email=to_email, name=to_name)
@@ -34,7 +29,6 @@ def send_email(to_email, to_name, subject, html):
         html=html,
         project_id=default_project_id,
     )
-    current_app.logger.debug(f"Email sent to {to_email}")
 
 
 def html_to_text(html_content):

common/utils/minio_utils.py

@@ -4,6 +4,9 @@ from flask import Flask
 import io
 from werkzeug.datastructures import FileStorage
 
+MIB_CONVERTOR = 1_048_576
+
+
 class MinioClient:
     def __init__(self):
         self.client = None
@@ -33,8 +36,8 @@ class MinioClient:
     def generate_object_name(self, document_id, language, version_id, filename):
         return f"{document_id}/{language}/{version_id}/{filename}"
 
-    def generate_asset_name(self, asset_version_id, file_name, content_type):
-        return f"assets/{asset_version_id}/{file_name}.{content_type}"
+    def generate_asset_name(self, asset_id, asset_type, content_type):
+        return f"assets/{asset_type}/{asset_id}.{content_type}"
 
     def upload_document_file(self, tenant_id, document_id, language, version_id, filename, file_data):
         bucket_name = self.generate_bucket_name(tenant_id)
@@ -57,8 +60,10 @@ class MinioClient:
         except S3Error as err:
             raise Exception(f"Error occurred while uploading file: {err}")
 
-    def upload_asset_file(self, bucket_name, asset_version_id, file_name, file_type, file_data):
-        object_name = self.generate_asset_name(asset_version_id, file_name, file_type)
+    def upload_asset_file(self, tenant_id: int, asset_id: int, asset_type: str, file_type: str,
+                          file_data: bytes | FileStorage | io.BytesIO | str, ) -> tuple[str, str, int]:
+        bucket_name = self.generate_bucket_name(tenant_id)
+        object_name = self.generate_asset_name(asset_id, asset_type, file_type)
 
         try:
             if isinstance(file_data, FileStorage):
@@ -73,7 +78,7 @@ class MinioClient:
             self.client.put_object(
                 bucket_name, object_name, io.BytesIO(file_data), len(file_data)
             )
-            return object_name, len(file_data)
+            return bucket_name, object_name, len(file_data)
         except S3Error as err:
             raise Exception(f"Error occurred while uploading asset: {err}")
 
@@ -84,6 +89,13 @@ class MinioClient:
         except S3Error as err:
             raise Exception(f"Error occurred while downloading file: {err}")
 
+    def download_asset_file(self, tenant_id, bucket_name, object_name):
+        try:
+            response = self.client.get_object(bucket_name, object_name)
+            return response.read()
+        except S3Error as err:
+            raise Exception(f"Error occurred while downloading asset: {err}")
+
     def list_document_files(self, tenant_id, document_id, language=None, version_id=None):
         bucket_name = self.generate_bucket_name(tenant_id)
         prefix = f"{document_id}/"
@@ -105,3 +117,16 @@ class MinioClient:
             return True
         except S3Error as err:
             raise Exception(f"Error occurred while deleting file: {err}")
+
+    def delete_object(self, bucket_name, object_name):
+        try:
+            self.client.remove_object(bucket_name, object_name)
+        except S3Error as err:
+            raise Exception(f"Error occurred while deleting object: {err}")
+
+    def get_bucket_size(self, tenant_id: int) -> int:
+        bucket_name = self.generate_bucket_name(tenant_id)
+        total_size = 0
+        for obj in self.client.list_objects(bucket_name, recursive=True):
+            total_size += obj.size
+        return total_size

common/utils/model_utils.py

@@ -56,7 +56,9 @@ def replace_variable_in_template(template: str, variable: str, value: str) -> st
     Returns:
         str: Template with variable placeholder replaced
     """
-    return template.replace(variable, value or "")
+
+    modified_template = template.replace(f"{{{variable}}}", value or "")
+    return modified_template
 
 
 def get_embedding_model_and_class(tenant_id, catalog_id, full_embedding_name="mistral.mistral-embed"):

common/utils/nginx_utils.py

@@ -12,7 +12,16 @@ def prefixed_url_for(endpoint, **values):
 
     if external:
         path, query, fragment = urlsplit(generated_url)[2:5]
-        new_path = prefix + path
+        # Check if the prefix is already present in the path
+        if prefix and not path.startswith(prefix):
+            new_path = prefix + path
+        else:
+            new_path = path
         return urlunsplit((scheme, host, new_path, query, fragment))
     else:
-        return prefix + generated_url
+        # Check if the prefix is already present in the generated URL
+        if prefix and not generated_url.startswith(prefix):
+            return prefix + generated_url
+        else:
+            return generated_url
+

common/utils/security.py

@@ -12,7 +12,6 @@ from datetime import datetime as dt, timezone as tz
 def set_tenant_session_data(sender, user, **kwargs):
     tenant = Tenant.query.filter_by(id=user.tenant_id).first()
     session['tenant'] = tenant.to_dict()
-    session['default_language'] = tenant.default_language
     partner = Partner.query.filter_by(tenant_id=user.tenant_id).first()
     if partner:
         session['partner'] = partner.to_dict()

common/utils/template_filters.py

@@ -5,6 +5,7 @@ import markdown
 from markupsafe import Markup
 from datetime import datetime
 from common.utils.nginx_utils import prefixed_url_for as puf
+from common.utils.chat_utils import adjust_color_brightness, adjust_color_alpha, get_base_background_color
 from flask import current_app, url_for
 
 
@@ -98,7 +99,6 @@ def get_pagination_html(pagination, endpoint, **kwargs):
         if page:
             is_active = 'active' if page == pagination.page else ''
             url = url_for(endpoint, page=page, **kwargs)
-            current_app.logger.debug(f"URL for page {page}: {url}")
             html.append(f'<li class="page-item {is_active}"><a class="page-link" href="{url}">{page}</a></li>')
         else:
             html.append('<li class="page-item disabled"><span class="page-link">...</span></li>')
@@ -117,7 +117,10 @@ def register_filters(app):
     app.jinja_env.filters['prefixed_url_for'] = prefixed_url_for
     app.jinja_env.filters['markdown'] = render_markdown
     app.jinja_env.filters['clean_markdown'] = clean_markdown
+    app.jinja_env.filters['adjust_color_brightness'] = adjust_color_brightness
+    app.jinja_env.filters['adjust_color_alpha'] = adjust_color_alpha
 
     app.jinja_env.globals['prefixed_url_for'] = prefixed_url_for
     app.jinja_env.globals['get_pagination_html'] = get_pagination_html
+    app.jinja_env.globals['get_base_background_color'] = get_base_background_color
 

config/agents/evie_partner/PARTNER_RAG_AGENT/1.0.0.yaml

@@ -0,0 +1,26 @@
+version: "1.0.0"
+name: "Partner Rag Agent"
+role: >
+  You are a virtual assistant responsible for answering user questions about the Evie platform (Ask Eve AI) and products 
+  developed by partners on top of it. You are reliable point of contact for end-users seeking help, clarification, or 
+  deeper understanding of features, capabilities, integrations, or workflows related to these AI-powered solutions.
+goal: >
+  Your primary goal is to:
+  	•	Provide clear, relevant, and accurate responses to user questions.
+  	•	Reduce friction in user onboarding and daily usage.
+  	•	Increase user confidence and adoption of both the platform and partner-developed products.
+  	•	Act as a bridge between documentation and practical application, enabling users to help themselves through intelligent guidance.
+backstory: >
+  You have availability Evie’s own documentation, partner product manuals, and real user interactions. You are designed 
+  to replace passive documentation with active, contextual assistance. 
+  You have evolved beyond a support bot: you combine knowledge, reasoning, and a friendly tone to act as a product 
+  companion that grows with the ecosystem. As partner products expand, the agent updates its knowledge and learns to 
+  distinguish between general platform capabilities and product-specific nuances, offering a personalised experience 
+  each time.
+full_model_name: "mistral.mistral-medium-latest"
+temperature: 0.3
+metadata:
+  author: "Josako"
+  date_added: "2025-07-16"
+  description: "An Agent that does RAG based on a user's question, RAG content & history"
+  changes: "Initial version"

config/agents/globals/RAG_AGENT/1.1.0.yaml

@@ -0,0 +1,23 @@
+version: "1.0.0"
+name: "Rag Agent"
+role: >
+  {tenant_name} Spokesperson. {custom_role}
+goal: >
+  You get questions by a human correspondent, and give answers based on a given context, taking into account the history
+  of the current conversation.
+  {custom_goal}
+backstory: >
+  You are the primary contact for {tenant_name}. You are known by {name}, and can be addressed by this name, or you. You are
+  a very good communicator, and adapt to the style used by the human asking for information (e.g. formal or informal). 
+  You always stay correct and polite, whatever happens. And you ensure no discriminating language is used.
+  You are perfectly multilingual in all known languages, and do your best to answer questions in {language}, whatever
+  language the context provided to you is in. You are participating in a conversation, not writing e.g. an email. Do not
+  include a salutation or closing greeting in your answer.
+  {custom_backstory}
+full_model_name: "mistral.mistral-medium-latest"
+temperature: 0.5
+metadata:
+  author: "Josako"
+  date_added: "2025-01-08"
+  description: "An Agent that does RAG based on a user's question, RAG content & history"
+  changes: "Initial version"

config/agents/traicie/TRAICIE_RECRUITER_AGENT/1.0.0.yaml

@@ -16,7 +16,7 @@ backstory: >
   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"
+full_model_name: "mistral.mistral-medium-latest"
 temperature: 0.3
 metadata:
   author: "Josako"

config/agents/traicie/TRAICIE_RECRUITER_AGENT/1.0.1.yaml

@@ -0,0 +1,25 @@
+version: "1.0.1"
+name: "Traicie Recruiter"
+role: >
+  You are an Expert Recruiter working for {tenant_name}, known as {name}. You can be addressed as {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.mistral-medium-latest"
+temperature: 0.3
+metadata:
+  author: "Josako"
+  date_added: "2025-07-03"
+  description: "Traicie Recruiter Agent"
+  changes: "Ensure recruiter can be addressed by a name"

config/assets/traicie/TRAICIE_KO_CRITERIA_QUESTIONS/1.0.0.yaml

@@ -0,0 +1,15 @@
+version: "1.0.0"
+name: "Traicie KO Criteria Questions"
+file_type: "yaml"
+dynamic: true
+configuration:
+  specialist_id:
+    name: "Specialist ID"
+    type: "int"
+    description: "The Specialist this asset is created for"
+    required: True
+metadata:
+  author: "Josako"
+  date_added: "2025-07-01"
+  description: "Asset that defines a KO Criteria Questions and Answers"
+  changes: "Initial version"

config/catalogs/traicie/TRAICIE_ROLE_DEFINITION_CATALOG/1.0.0.yaml

@@ -0,0 +1,19 @@
+version: "1.0.0"
+name: "Role Definition Catalog"
+description: "A Catalog containing information specific to a specific role"
+configuration:
+  tagging_fields:
+    role_reference:
+      type: "string"
+      required: true
+      description: "A unique identification for the role"
+    document_type:
+      type: "enum"
+      required: true
+      description: "Type of document"
+      allowed_values: [ "Intake", "Vacancy Text", "Additional Information" ]
+document_version_configurations: ["tagging_fields"]
+metadata:
+  author: "Josako"
+  date_added: "2025-07-07"
+  description: "A Catalog containing information specific to a specific role"

config/config.py

@@ -66,7 +66,6 @@ class Config(object):
     MAX_CONTENT_LENGTH = 50 * 1024 * 1024
 
     # supported languages
-    SUPPORTED_LANGUAGES = ['en', 'fr', 'nl', 'de', 'es', 'it', 'pt', 'ru', 'zh', 'ja', 'ko', 'ar', 'hi']
     SUPPORTED_LANGUAGE_DETAILS = {
         "English": {
             "iso 639-1": "en",
@@ -148,7 +147,10 @@ class Config(object):
         },
     }
 
-    SUPPORTED_LANGUAGES_Full = list(SUPPORTED_LANGUAGE_DETAILS.keys())
+    # Afgeleide taalconstanten
+    SUPPORTED_LANGUAGES = [lang_details["iso 639-1"] for lang_details in SUPPORTED_LANGUAGE_DETAILS.values()]
+    SUPPORTED_LANGUAGES_FULL = list(SUPPORTED_LANGUAGE_DETAILS.keys())
+    SUPPORTED_LANGUAGE_ISO639_1_LOOKUP = {lang_details["iso 639-1"]: lang_name for lang_name, lang_details in SUPPORTED_LANGUAGE_DETAILS.items()}
 
     # supported currencies
     SUPPORTED_CURRENCIES = ['€', '$']
@@ -156,10 +158,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
@@ -296,6 +295,8 @@ class DevConfig(Config):
     CHAT_WORKER_CACHE_URL = f'{REDIS_BASE_URI}/4'
     # specialist execution pub/sub Redis Settings
     SPECIALIST_EXEC_PUBSUB = f'{REDIS_BASE_URI}/5'
+    # eveai_model cache Redis setting
+    MODEL_CACHE_URL = f'{REDIS_BASE_URI}/6'
 
 
     # Unstructured settings

config/customisations/globals/CHAT_CLIENT_CUSTOMISATION/1.0.0.yaml

@@ -1,68 +1,89 @@
 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":
+  sidebar_markdown:
     name: "Sidebar Markdown"
     description: "Sidebar Markdown-formatted Text"
     type: "text"
     required: false
-  "welcome_message":
-    name: "Welcome Message"
-    description: "Text to be shown as Welcome"
-    type: "text"
+  sidebar_color:
+    name: "Sidebar Text Color"
+    description: "Sidebar Color"
+    type: "color"
+    required: false
+  sidebar_background:
+    name: "Sidebar Background Color"
+    description: "Sidebar Background Color"
+    type: "color"
+    required: false
+  markdown_background_color:
+    name: "Markdown Background Color"
+    description: "Markdown Background Color"
+    type: "color"
+    required: false
+  markdown_text_color:
+    name: "Markdown Text Color"
+    description: "Markdown Text Color"
+    type: "color"
+    required: false
+  gradient_start_color:
+    name: "Chat Gradient Background Start Color"
+    description: "Start Color for the gradient in the Chat Area"
+    type: "color"
+    required: false
+  gradient_end_color:
+    name: "Chat Gradient Background End Color"
+    description: "End Color for the gradient in the Chat Area"
+    type: "color"
+    required: false
+  progress_tracker_insights:
+    name: "Progress Tracker Insights Level"
+    description: "Level of information shown by the Progress Tracker"
+    type: "enum"
+    allowed_values: ["No Information", "Active Interaction Only", "All Interactions"]
+    default: "No Information"
+    required: true
+  form_title_display:
+    name: "Form Title Display"
+    description: Level of information shown for the Form Title
+    type: "enum"
+    allowed_values: ["No Title", "Full Title"]
+    default: "Full Title"
+    required: true
+  active_background_color:
+    name: "Active Interaction Background Color"
+    description: "Primary Color"
+    type: "color"
+    required: false
+  history_background:
+    name: "History Background"
+    description: "Percentage to lighten (+) / darken (-) the user message background"
+    type: "integer"
+    min_value: -50
+    max_value: 50
+    required: false
+  ai_message_background:
+    name: "AI (Bot) Message Background Color"
+    description: "AI (Bot) Message Background Color"
+    type: "color"
+    required: false
+  ai_message_text_color:
+    name: "AI (Bot) Message Text Color"
+    description: "AI (Bot) Message Text Color"
+    type: "color"
+    required: false
+  human_message_background:
+    name: "Human Message Background Color"
+    description: "Human Message Background Color"
+    type: "color"
+    required: false
+  human_message_text_color:
+    name: "Human Message Text Color"
+    description: "Human Message Text Color"
+    type: "color"
     required: false
 metadata:
   author: "Josako"
   date_added: "2024-06-06"
-  changes: "Initial version"
+  changes: "Adaptations to make color choosing more consistent and user friendly"
   description: "Parameters allowing to customise the chat client"

config/data_capsules/traicie/TRAICIE_RQC/1.0.0.yaml

@@ -0,0 +1,8 @@
+version: "1.0.0"
+name: "RQC"
+description: "Recruitment Qualified Candidate"
+configuration: {}
+metadata:
+  author: "Josako"
+  date_added: "2025-07-24"
+  description: "Capsule storing RQC information"

config/partner_services/globals/KNOWLEDGE_SERVICE/1.0.0.yaml

@@ -0,0 +1,9 @@
+version: "1.0.0"
+name: "Knowledge Service"
+configuration: {}
+permissions: {}
+metadata:
+  author: "Josako"
+  date_added: "2025-04-02"
+  changes: "Initial version"
+  description: "Partner providing catalog content"

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

@@ -42,7 +42,7 @@ configuration:
   image_handling:
     name: "Image Handling"
     type: "enum"
-    description: "How to handle embedded images"
+    description: "How to handle embedded img"
     required: false
     default: "skip"
     allowed_values: ["skip", "extract", "placeholder"]

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/check_additional_information/1.0.0.yaml

@@ -0,0 +1,22 @@
+version: "1.0.0"
+content: >
+  Check if there are other elements available in the provided text (in between triple $) than answers to the 
+  following question (in between triple €):
+  
+  €€€
+  {question}
+  €€€
+  
+  Provided text:
+  
+  $$$
+  {answer}
+  $$$
+  
+  Answer with True or False, without additional information.
+llm_model: "mistral.mistral-medium-latest"
+metadata:
+  author: "Josako"
+  date_added: "2025-06-23"
+  description: "An assistant to check if the answer to a question is affirmative."
+  changes: "Initial version"

config/prompts/globals/check_affirmative_answer/1.0.0.yaml

@@ -0,0 +1,17 @@
+version: "1.0.0"
+content: >
+  Determine if there is an affirmative answer on the following question (in between triple backquotes):
+
+  ```{question}``` 
+  
+  in the provided answer (in between triple backquotes): 
+  
+  ```{answer}```
+  
+  Answer with True or False, without additional information.
+llm_model: "mistral.mistral-medium-latest"
+metadata:
+  author: "Josako"
+  date_added: "2025-06-23"
+  description: "An assistant to check if the answer to a question is affirmative."
+  changes: "Initial version"

config/prompts/globals/get_answer_to_question/1.0.0.yaml

@@ -0,0 +1,16 @@
+version: "1.0.0"
+content: >
+  Provide us with the answer to the following question (in between triple backquotes) from the text provided to you:
+
+  ```{question}````
+
+  Reply in exact wordings and in the same language. If no answer can be found, reply with "No answer provided"
+
+  Text provided to you:
+  ```{answer}```
+llm_model: "mistral.mistral-medium-latest"
+metadata:
+  author: "Josako"
+  date_added: "2025-06-23"
+  description: "An assistant to check if the answer to a question is affirmative."
+  changes: "Initial version"

config/prompts/globals/history/1.0.0.yaml

@@ -4,7 +4,7 @@ content: |
   question is understandable without that history. The conversation is a consequence of questions and context provided
   by the HUMAN, and the AI (you) answering back, in chronological order. The most recent (i.e. last) elements are the
   most important when detailing the question.
-  You answer by stating the detailed question in {language}.
+  You return the only the detailed question in {language}. Without any additional information.
   History:
   ```{history}```
   Question to be detailed:

config/prompts/globals/translation_with_context/1.0.0.yaml

@@ -0,0 +1,22 @@
+version: "1.0.0"
+content: >
+  You are a top translator. We need you to translate (in between triple quotes)
+  
+  '''{text_to_translate}'''
+  
+  into '{target_language}', taking 
+  into account this context:
+  
+  '{context}'
+  
+  Do not translate text in between double square brackets, as these are names or terms that need to remain intact.
+  Remove the triple quotes in your translation!
+  
+  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.mistral-medium-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,19 @@
+version: "1.0.0"
+content: >
+  You are a top translator. We need you to translate (in between triple quotes)
+
+  '''{text_to_translate}''' 
+  
+  into '{target_language}'. 
+  
+  Do not translate text in between double square brackets, as these are names or terms that need to remain intact.
+  Remove the triple quotes in your translation!
+  
+  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.mistral-medium-latest"
+metadata:
+  author: "Josako"
+  date_added: "2025-06-23"
+  description: "An assistant to translate without context."
+  changes: "Initial version"

config/retrievers/evie_partner/PARTNER_RAG/1.0.0.yaml

@@ -0,0 +1,21 @@
+version: "1.0.0"
+name: "Standard RAG Retriever"
+configuration:
+  es_k:
+    name: "es_k"
+    type: "integer"
+    description: "K-value to retrieve embeddings (max embeddings retrieved)"
+    required: true
+    default: 8
+  es_similarity_threshold:
+    name: "es_similarity_threshold"
+    type: "float"
+    description: "Similarity threshold for retrieving embeddings"
+    required: true
+    default: 0.3
+arguments: {}
+metadata:
+  author: "Josako"
+  date_added: "2025-01-24"
+  changes: "Initial version"
+  description: "Retrieving all embeddings conform the query"

config/retrievers/globals/DOSSIER_RETRIEVER/1.0.0.yaml

@@ -1,36 +0,0 @@
-version: "1.0.0"
-name: "DOSSIER Retriever"
-configuration:
-  es_k:
-    name: "es_k"
-    type: "int"
-    description: "K-value to retrieve embeddings (max embeddings retrieved)"
-    required: true
-    default: 8
-  es_similarity_threshold:
-    name: "es_similarity_threshold"
-    type: "float"
-    description: "Similarity threshold for retrieving embeddings"
-    required: true
-    default: 0.3
-  tagging_fields_filter:
-    name: "Tagging Fields Filter"
-    type: "tagging_fields_filter"
-    description: "Filter JSON to retrieve a subset of documents"
-    required: true
-  dynamic_arguments:
-    name: "Dynamic Arguments"
-    type: "dynamic_arguments"
-    description: "dynamic arguments used in the filter"
-    required: false
-arguments:
-  query:
-    name: "query"
-    type: "str"
-    description: "Query to retrieve embeddings"
-    required: True
-metadata:
-  author: "Josako"
-  date_added: "2025-03-11"
-  changes: "Initial version"
-  description: "Retrieving all embeddings conform the query and the tagging fields filter"

config/retrievers/globals/STANDARD_RAG/1.0.0.yaml

@@ -3,7 +3,7 @@ name: "Standard RAG Retriever"
 configuration:
   es_k:
     name: "es_k"
-    type: "int"
+    type: "integer"
     description: "K-value to retrieve embeddings (max embeddings retrieved)"
     required: true
     default: 8
@@ -13,12 +13,7 @@ configuration:
     description: "Similarity threshold for retrieving embeddings"
     required: true
     default: 0.3
-arguments:
-  query:
-    name: "query"
-    type: "str"
-    description: "Query to retrieve embeddings"
-    required: True
+arguments: {}
 metadata:
   author: "Josako"
   date_added: "2025-01-24"

config/retrievers/traicie/TRAICIE_ROLE_DEFINITION_BY_ROLE_IDENTIFICATION/1.0.0.yaml

@@ -0,0 +1,26 @@
+version: "1.0.0"
+name: "Retrieves role information for a specific role"
+configuration:
+  es_k:
+    name: "es_k"
+    type: "integer"
+    description: "K-value to retrieve embeddings (max embeddings retrieved)"
+    required: true
+    default: 8
+  es_similarity_threshold:
+    name: "es_similarity_threshold"
+    type: "float"
+    description: "Similarity threshold for retrieving embeddings"
+    required: true
+    default: 0.3
+arguments:
+  role_reference:
+    name: "Role Reference"
+    type: "string"
+    description: "The role information needs to be retrieved for"
+    required: true
+metadata:
+  author: "Josako"
+  date_added: "2025-07-07"
+  changes: "Initial version"
+  description: "Retrieves role information for a specific role"

config/specialist_forms/globals/CONTACT_TIME_PREFERENCES_SIMPLE/1.0.0.yaml

@@ -0,0 +1,36 @@
+type: "CONTACT_TIME_PREFERENCES_SIMPLE"
+version: "1.0.0"
+name: "Contact Time Preferences"
+icon: "calendar_month"
+fields:
+  early:
+    name: "Early in the morning"
+    description: "Contact me early in the morning"
+    type: "boolean"
+    required: false
+# It is possible to also add a field 'context'. It allows you to provide an elaborate piece of information.
+  late_morning:
+    name: "During the morning"
+    description: "Contact me during the morning"
+    type: "boolean"
+    required: false
+  afternoon:
+    name: "In the afternoon"
+    description: "Contact me in the afternoon"
+    type: "boolean"
+    required: false
+  evening:
+    name: "In the evening"
+    description: "Contact me in the evening"
+    type: "boolean"
+    required: false
+  other:
+    name: "Other"
+    description: "Specify your preferred contact moment"
+    type: "string"
+    required: false
+metadata:
+  author: "Josako"
+  date_added: "2025-07-22"
+  changes: "Initial Version"
+  description: "Simple Contact Time Preferences Form"

config/specialist_forms/globals/MINIMAL_PERSONAL_CONTACT_FORM/1.0.0.yaml

@@ -0,0 +1,31 @@
+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
+# It is possible to also add a field 'context'. It allows you to provide an elaborate piece of information.
+  email:
+    name: "Email"
+    type: "str"
+    description: "Your Name"
+    required: true
+  phone:
+    name: "Phone Number"
+    type: "str"
+    description: "Your Phone Number"
+    required: true
+  consent:
+    name: "Consent"
+    type: "boolean"
+    description: "Consent"
+    required: true
+metadata:
+  author: "Josako"
+  date_added: "2025-07-29"
+  changes: "Initial Version"
+  description: "Personal Contact Form"

config/specialist_forms/globals/PERSONAL_CONTACT_FORM/1.0.0.yaml

@@ -8,6 +8,7 @@ fields:
     description: "Your name"
     type: "str"
     required: true
+# It is possible to also add a field 'context'. It allows you to provide an elaborate piece of information.
   email:
     name: "Email"
     type: "str"
@@ -17,7 +18,6 @@ fields:
     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"
@@ -44,3 +44,8 @@ fields:
     type: "boolean"
     description: "Consent"
     required: true
+metadata:
+  author: "Josako"
+  date_added: "2025-06-18"
+  changes: "Initial Version"
+  description: "Personal Contact Form"

config/specialist_forms/globals/PROFESSIONAL_CONTACT_FORM/1.0.0.yaml

@@ -53,3 +53,8 @@ fields:
     type: "bool"
     description: "Consent"
     required: true
+metadata:
+  author: "Josako"
+  date_added: "2025-06-18"
+  changes: "Initial Version"
+  description: "Professional Contact Form"

config/specialists/evie_partner/PARTNER_RAG_SPECIALIST/1.0.0.yaml

@@ -0,0 +1,34 @@
+version: "1.0.0"
+name: "Partner RAG Specialist"
+framework: "crewai"
+chat: true
+configuration: {}
+arguments: {}
+results:
+  rag_output:
+    answer:
+      name: "answer"
+      type: "str"
+      description: "Answer to the query"
+      required: true
+    citations:
+      name: "citations"
+      type: "List[str]"
+      description: "List of citations"
+      required: false
+    insufficient_info:
+      name: "insufficient_info"
+      type: "bool"
+      description: "Whether or not the query is insufficient info"
+      required: true
+agents:
+  - type: "PARTNER_RAG_AGENT"
+    version: "1.0"
+tasks:
+  - type: "PARTNER_RAG_TASK"
+    version: "1.0"
+metadata:
+  author: "Josako"
+  date_added: "2025-07-16"
+  changes: "Initial version"
+  description: "Q&A through Partner RAG Specialist (for documentation purposes)"

config/specialists/globals/RAG_SPECIALIST/1.0.0.yaml

@@ -19,11 +19,6 @@ arguments:
     type: "str"
     description: "Language code to be used for receiving questions and giving answers"
     required: true
-  query:
-    name: "query"
-    type: "str"
-    description: "Query or response to process"
-    required: true
 results:
   rag_output:
     answer:

config/specialists/globals/RAG_SPECIALIST/1.1.0.yaml

@@ -0,0 +1,49 @@
+version: "1.1.0"
+name: "RAG Specialist"
+framework: "crewai"
+chat: true
+configuration:
+  name:
+    name: "name"
+    type: "str"
+    description: "The name the specialist is called upon."
+    required: true
+  welcome_message:
+    name: "Welcome Message"
+    type: "string"
+    description: "Welcome Message to be given to the end user"
+    required: false
+arguments:
+  language:
+    name: "Language"
+    type: "str"
+    description: "Language code to be used for receiving questions and giving answers"
+    required: true
+results:
+  rag_output:
+    answer:
+      name: "answer"
+      type: "str"
+      description: "Answer to the query"
+      required: true
+    citations:
+      name: "citations"
+      type: "List[str]"
+      description: "List of citations"
+      required: false
+    insufficient_info:
+      name: "insufficient_info"
+      type: "bool"
+      description: "Whether or not the query is insufficient info"
+      required: true
+agents:
+  - type: "RAG_AGENT"
+    version: "1.1"
+tasks:
+  - type: "RAG_TASK"
+    version: "1.1"
+metadata:
+  author: "Josako"
+  date_added: "2025-01-08"
+  changes: "Initial version"
+  description: "A Specialist that performs Q&A activities"

config/specialists/globals/STANDARD_RAG_SPECIALIST/1.0.0.yaml

@@ -1,53 +0,0 @@
-version: 1.0.0
-name: "Standard RAG Specialist"
-framework: "langchain"
-chat: true
-configuration:
-  specialist_context:
-    name: "Specialist Context"
-    type: "text"
-    description: "The context to be used by the specialist."
-    required: false
-  temperature:
-    name: "Temperature"
-    type: "number"
-    description: "The inference temperature to be used by the specialist."
-    required: false
-    default: 0.3
-arguments:
-  language:
-    name: "Language"
-    type: "str"
-    description: "Language code to be used for receiving questions and giving answers"
-    required: true
-  query:
-    name: "query"
-    type: "str"
-    description: "Query to answer"
-    required: true
-results:
-  detailed_query:
-    name: "detailed_query"
-    type: "str"
-    description: "The query detailed with the Chat Session History."
-    required: true
-  answer:
-    name: "answer"
-    type: "str"
-    description: "Answer to the query"
-    required: true
-  citations:
-    name: "citations"
-    type: "List[str]"
-    description: "List of citations"
-    required: false
-  insufficient_info:
-    name: "insufficient_info"
-    type: "bool"
-    description: "Whether or not the query is insufficient info"
-    required: true
-metadata:
-  author: "Josako"
-  date_added: "2025-01-08"
-  changes: "Initial version"
-  description: "A Specialist that performs standard Q&A"

config/specialists/traicie/TRAICIE_KO_INTERVIEW_DEFINITION_SPECIALIST/1.0.0.yaml

@@ -0,0 +1,29 @@
+version: "1.1.0"
+name: "Traicie KO Criteria Interview Definition Specialist"
+framework: "crewai"
+partner: "traicie"
+chat: false
+configuration:
+arguments:
+  specialist_id:
+    name: "specialist_id"
+    description: "ID of the specialist for which to define KO Criteria Questions and Asnwers"
+    type: "integer"
+    required: true
+results:
+  asset_id:
+    name: "asset_id"
+    description: "ID of the Asset containing questions and answers for each of the defined KO Criteria"
+    type: "integer"
+    required: true
+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-07-01"
+  changes: "Initial Version"
+  description: "Specialist assisting in questions and answers definition for KO Criteria"

config/specialists/traicie/TRAICIE_KO_INTERVIEW_DEFINITION_SPECIALIST/1.1.0.yaml

@@ -0,0 +1,29 @@
+version: "1.1.0"
+name: "Traicie KO Criteria Interview Definition Specialist"
+framework: "crewai"
+partner: "traicie"
+chat: false
+configuration:
+arguments:
+  specialist_id:
+    name: "specialist_id"
+    description: "ID of the specialist for which to define KO Criteria Questions and Asnwers"
+    type: "integer"
+    required: true
+results:
+  asset_id:
+    name: "asset_id"
+    description: "ID of the Asset containing questions and answers for each of the defined KO Criteria"
+    type: "integer"
+    required: true
+agents:
+  - type: "TRAICIE_HR_BP_AGENT"
+    version: "1.0"
+tasks:
+  - type: "TRAICIE_KO_CRITERIA_INTERVIEW_DEFINITION_TASK"
+    version: "1.0"
+metadata:
+  author: "Josako"
+  date_added: "2025-07-01"
+  changes: "Initial Version"
+  description: "Specialist assisting in questions and answers definition for KO Criteria"

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.0.0.yaml

@@ -2,7 +2,7 @@ version: "1.0.0"
 name: "Traicie Selection Specialist"
 framework: "crewai"
 partner: "traicie"
-chat: false
+chat: true
 configuration:
   name:
     name: "Name"
@@ -111,4 +111,4 @@ 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"
+  description: "Assistant to assist in candidate selection"

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.1.0.yaml

@@ -2,7 +2,7 @@ version: "1.1.0"
 name: "Traicie Selection Specialist"
 framework: "crewai"
 partner: "traicie"
-chat: false
+chat: true
 configuration:
   name:
     name: "Name"
@@ -117,4 +117,4 @@ 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"
+  description: "Assistant to assist in candidate selection"

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.2.0.yaml

@@ -2,7 +2,7 @@ version: "1.3.0"
 name: "Traicie Selection Specialist"
 framework: "crewai"
 partner: "traicie"
-chat: false
+chat: true
 configuration:
   name:
     name: "Name"
@@ -117,4 +117,4 @@ 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"
+  description: "Assistant to assist in candidate selection"

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.3.0.yaml

@@ -2,7 +2,7 @@ version: "1.3.0"
 name: "Traicie Selection Specialist"
 framework: "crewai"
 partner: "traicie"
-chat: false
+chat: true
 configuration:
   name:
     name: "Name"
@@ -117,4 +117,4 @@ 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"
+  description: "Assistant to assist in candidate selection"

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.4.0.yaml

@@ -0,0 +1,115 @@
+version: "1.4.0"
+name: "Traicie Selection Specialist"
+framework: "crewai"
+partner: "traicie"
+chat: true
+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
+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: ["orientation", "selection"]
+    default: "orientation"
+    required: true
+results:
+  competencies:
+    name: "competencies"
+    type: "List[str, str]"
+    description: "List of vacancy competencies and their descriptions"
+    required: false
+agents:
+  - type: "RAG_AGENT"
+    version: "1.1"
+tasks:
+  - type: "RAG_TASK"
+    version: "1.1"
+metadata:
+  author: "Josako"
+  date_added: "2025-07-03"
+  changes: "Update for a Full Virtual Assistant Experience"
+  description: "Assistant to assist in candidate selection"

config/specialists/traicie/TRAICIE_SELECTION_SPECIALIST/1.5.0.yaml

@@ -0,0 +1,121 @@
+version: "1.4.0"
+name: "Traicie Selection Specialist"
+framework: "crewai"
+partner: "traicie"
+chat: true
+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
+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: ["orientation", "selection"]
+    default: "orientation"
+    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"
+  - type: "RAG_AGENT"
+    version: "1.1"
+tasks:
+  - type: "TRAICIE_DETERMINE_INTERVIEW_MODE_TASK"
+    version: "1.0"
+  - type: "TRAICIE_AFFIRMATIVE_ANSWER_CHECK_TASK"
+    version: "1.0"
+  - type: "ADVANCED_RAG_TASK"
+    version: "1.0"
+metadata:
+  author: "Josako"
+  date_added: "2025-07-30"
+  changes: "Update for a Full Virtual Assistant Experience"
+  description: "Assistant to assist in candidate selection"

config/tasks/evie_partner/PARTNER_RAG_TASK/1.0.0.yaml

@@ -0,0 +1,22 @@
+version: "1.0.0"
+name: "RAG Task"
+task_description: >
+  Answer the question based on the following context, and taking into account the history of the discussion. Try not to
+  repeat answers already given in the recent history,  unless confirmation is required or repetition is essential to 
+  give a coherent answer.
+  Answer the end user in the language used in his/her question.
+  If the question cannot be answered using the given context, answer "I have insufficient information to answer this 
+  question."
+  Context (in between triple $):
+    $$${context}$$$
+  History (in between triple €):
+    €€€{history}€€€
+  Question (in between triple £):
+    £££{question}£££
+expected_output: >
+  Your answer.
+metadata:
+  author: "Josako"
+  date_added: "2025-07-16"
+  description: "A Task that gives RAG-based answers"
+  changes: "Initial version"

config/tasks/globals/ADVANCED_RAG_TASK/1.0.0.yaml

@@ -0,0 +1,43 @@
+version: "1.0.0"
+name: "Advanced RAG Task"
+task_description: >
+  Answer the following question (in between triple £):
+  
+  £££{question}£££
+  
+  Base your answer on the following context (in between triple $): 
+
+  $$${context}$$$
+
+  Take into account the following history of the conversation (in between triple €):
+
+  €€€{history}€€€
+
+  The HUMAN parts indicate the interactions by the end user, the AI parts are your interactions.
+  
+  Best Practices are:
+  
+  - Answer the provided question as precisely and directly as you can, combining elements of the provided context.
+  - Always focus your answer on the actual question.
+  - Limit repetition in your answers to an absolute minimum, unless absolutely necessary. 
+  - Always be friendly and helpful for the end user.
+  
+  Tune your answers to the following:
+  
+  - You use the following Tone of Voice for your answer: {tone_of_voice}, i.e. {tone_of_voice_context}
+  - You use the following Language Level for your answer: {language_level}, i.e. {language_level_context}
+  
+  Use the following language in your communication: {language}
+  
+  If the question cannot be answered using the given context, answer "I have insufficient information to answer this 
+  question." and give the appropriate indication.
+  
+  {custom_description}
+
+expected_output: >
+
+metadata:
+  author: "Josako"
+  date_added: "2025-07-30"
+  description: "A Task that performs RAG and checks for human answers"
+  changes: "Initial version"

config/tasks/globals/RAG_TASK/1.1.0.yaml

@@ -0,0 +1,36 @@
+version: "1.0.0"
+name: "RAG Task"
+task_description: >
+  Answer the following question (in between triple £):
+  
+  £££{question}£££
+  
+  Base your answer on the following context (in between triple $): 
+  
+  $$${context}$$$
+  
+  Take into account the following history of the conversation (in between triple €):
+  
+  €€€{history}€€€
+  
+  The HUMAN parts indicate the interactions by the end user, the AI parts are your interactions.
+  
+  Best Practices are:
+  
+  - Answer the provided question as precisely and directly as you can, combining elements of the provided context.
+  - Always focus your answer on the actual HUMAN question.
+  - Try not to repeat your answers (preceded by AI), unless absolutely necessary. 
+  - Focus your answer on the question at hand.
+  - Always be friendly and helpful for the end user.
+
+  {custom_description}
+  Use the following {language} in your communication.
+  If the question cannot be answered using the given context, answer "I have insufficient information to answer this 
+  question." and give the appropriate indication.
+expected_output: >
+  Your answer.
+metadata:
+  author: "Josako"
+  date_added: "2025-01-08"
+  description: "A Task that gives RAG-based answers"
+  changes: "Initial version"

config/tasks/traicie/TRAICIE_AFFIRMATIVE_ANSWER_CHECK_TASK/1.0.0.yaml

@@ -0,0 +1,29 @@
+version: "1.0.0"
+name: "Traicie Affirmative Answer Check"
+task_description: >
+  You are provided with the following end user answer (in between triple £):
+  
+  £££{question}£££
+  
+  This is the history of the conversation (in between triple €):
+
+  €€€{history}€€€
+  
+  (In this history, user interactions are preceded by 'HUMAN', and your interactions with 'AI'.)
+  
+  Check if the user has given an affirmative answer or not.
+  Please note that this answer can be very short:
+  - Affirmative answers: e.g. Yes, OK, Sure, Of Course
+  - Negative answers: e.g. No, not really, No, I'd rather not.
+  
+  Please consider that the answer will be given in {language}!
+  
+  {custom_description}
+
+expected_output: >
+  Your determination if the answer was affirmative (true) or negative (false)
+metadata:
+  author: "Josako"
+  date_added: "2025-07-30"
+  description: "A Task to check if the answer to a question is affirmative"
+  changes: "Initial version"

config/tasks/traicie/TRAICIE_COMPETENCIES_INTERVIEW_DEFINITION/1.0.0.yaml

@@ -1,30 +0,0 @@
-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_DETERMINE_INTERVIEW_MODE_TASK/1.0.0.yaml

@@ -0,0 +1,23 @@
+version: "1.0.0"
+name: "Traicie Determine Interview Mode"
+task_description: >
+  you are provided with the following user input (in between triple backquotes):
+  
+  ```{question}```
+
+  If this user input contains one or more questions, your answer is simply 'RAG'. In all other cases, your answer is
+  'CHECK'. 
+  
+  Best practices to be applied:
+  - A question doesn't always have an ending question mark. It can be a query for more information, such as 'I'd like 
+  to understand ...', 'I'd like to know more about...'. Or it is possible the user didn't enter a question mark. Take 
+  into account the user might be working on a mobile device like a phone, making typing not as obvious.
+  - If there is a question mark, then normally you are provided with a question of course.
+
+expected_output: >
+  Your Answer.
+metadata:
+  author: "Josako"
+  date_added: "2025-07-30"
+  description: "A Task to determine the interview mode based on the last user input"
+  changes: "Initial version"

config/tasks/traicie/TRAICIE_KO_CRITERIA_INTERVIEW_DEFINITION_TASK/1.0.1.yaml

@@ -8,8 +8,8 @@ task_description: >
   
   - 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. 
+  - A set of 2 short answers (1 small sentence of about 10 words each) to that question (positive answer / negative answer), from the 
+  candidates perspective. Do not just repeat the words already formulated in the question.
   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.
   
@@ -17,7 +17,7 @@ task_description: >
 
   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.
+  Use the language used in the competencies as language for your answer / output. We call this the original language.
   
   ```{ko_criteria}```
   
@@ -26,9 +26,9 @@ task_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}.
+  - the question in the original language
+  - a positive answer, resulting in a positive evaluation of the criterium, in the original language.
+  - a negative answer, resulting in a negative evaluation of the criterium, in the original langauge.
   {custom_expected_output}
 metadata:
   author: "Josako"

config/type_defs/asset_types.py

@@ -1,5 +1,5 @@
 # Agent Types
-AGENT_TYPES = {
+ASSET_TYPES = {
     "DOCUMENT_TEMPLATE": {
         "name": "Document Template",
         "description": "Asset that defines a template in markdown a specialist can process",
@@ -8,4 +8,9 @@ AGENT_TYPES = {
         "name": "Specialist Configuration",
         "description": "Asset that defines a specialist configuration",
     },
+    "TRAICIE_KO_CRITERIA_QUESTIONS": {
+        "name": "Traicie KO Criteria Questions",
+        "description": "Asset that defines KO Criteria Questions and Answers",
+        "partner": "traicie"
+    },
 }

config/type_defs/capsule_types.py

@@ -0,0 +1,8 @@
+# Catalog Types
+CAPSULE_TYPES = {
+    "TRAICIE_RQC": {
+        "name": "Traicie Recruitment Qualified Candidate Capsule",
+        "description": "A capsule storing RQCs",
+        "partner": "traicie"
+    },
+}

config/type_defs/catalog_types.py

@@ -4,8 +4,9 @@ CATALOG_TYPES = {
         "name": "Standard Catalog",
         "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",
+    "TRAICIE_ROLE_DEFINITION_CATALOG": {
+        "name": "Role Definition Catalog",
+        "description": "A Catalog with information about roles, to be considered as a whole",
+        "partner": "traicie"
     },
 }

config/type_defs/partner_service_types.py

@@ -1,9 +1,5 @@
 # config/type_defs/partner_service_types.py
 PARTNER_SERVICE_TYPES = {
-    "REFERRAL_SERVICE": {
-        "name": "Referral Service",
-        "description": "Partner referring new customers",
-    },
     "KNOWLEDGE_SERVICE": {
         "name": "Knowledge Service",
         "description": "Partner providing catalog content",

config/type_defs/processor_types.py

@@ -10,11 +10,6 @@ PROCESSOR_TYPES = {
         "description": "A Processor for PDF files",
         "file_types": "pdf",
     },
-    "AUDIO_PROCESSOR": {
-        "name": "AUDIO Processor",
-        "description": "A Processor for audio files",
-        "file_types": "mp3, mp4, ogg",
-    },
     "MARKDOWN_PROCESSOR": {
         "name": "Markdown Processor",
         "description": "A Processor for markdown files",
@@ -24,5 +19,10 @@ PROCESSOR_TYPES = {
         "name": "DOCX Processor",
         "description": "A processor for DOCX files",
         "file_types": "docx",
-    }
+    },
+    "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,20 @@ 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",
+    },
+    "check_affirmative_answer": {
+        "name": "check_affirmative_answer",
+        "description": "An assistant to check if the answer to a question is affirmative",
+    },
+    "check_additional_information": {
+        "name": "check_additional_information",
+        "description": "An assistant to check if the answer to a question includes additional information or questions",
+    },
 }

config/type_defs/retriever_types.py

@@ -4,8 +4,15 @@ RETRIEVER_TYPES = {
         "name": "Standard RAG Retriever",
         "description": "Retrieving all embeddings from the catalog conform the query",
     },
-    "DOSSIER_RETRIEVER": {
-        "name": "Retriever for managing DOSSIER catalogs",
-        "description": "Retrieving filtered embeddings from the catalog conform the query",
-    }
+    "PARTNER_RAG": {
+        "name": "Partner RAG Retriever",
+        "description": "RAG intended for partner documentation",
+        "partner": "evie_partner"
+    },
+    "TRAICIE_ROLE_DEFINITION_BY_ROLE_IDENTIFICATION": {
+        "name": "Traicie Role Definition Retriever by Role Identification",
+        "description": "Retrieves relevant role information for a given role",
+        "partner": "traicie",
+        "valid_catalog_types": ["TRAICIE_ROLE_DEFINITION_CATALOG"]
+    },
 }

config/type_defs/specialist_form_types.py

@@ -8,4 +8,12 @@ SPECIALIST_FORM_TYPES = {
         "name": "Professional Contact Form",
         "description": "A form for entering your professional contact details",
     },
+    "CONTACT_TIME_PREFERENCES_SIMPLE": {
+        "name": "Contact Time Preferences  Form",
+        "description": "A form for entering contact time preferences",
+    },
+    "MINIMAL_PERSONAL_CONTACT_FORM": {
+        "name": "Personal Contact Form",
+        "description": "A form for entering your personal contact details",
+    }
 }

config/type_defs/specialist_types.py

@@ -1,13 +1,14 @@
 # Specialist Types
 SPECIALIST_TYPES = {
-    "STANDARD_RAG_SPECIALIST": {
-        "name": "Q&A RAG Specialist",
-        "description": "Standard Q&A through RAG Specialist",
-    },
     "RAG_SPECIALIST": {
         "name": "RAG Specialist",
         "description": "Q&A through RAG Specialist",
     },
+    "PARTNER_RAG_SPECIALIST": {
+        "name": "Partner RAG Specialist",
+        "description": "Q&A through Partner RAG Specialist (for documentation purposes)",
+        "partner": "evie_partner"
+    },
     "SPIN_SPECIALIST": {
         "name": "Spin Sales Specialist",
         "description": "A specialist that allows to answer user queries, try to get SPIN-information and Identification",
@@ -20,5 +21,9 @@ SPECIALIST_TYPES = {
     "TRAICIE_SELECTION_SPECIALIST": {
         "name": "Traicie Selection Specialist",
         "description": "Recruitment Selection Assistant",
-    }
+    },
+    "TRAICIE_KO_INTERVIEW_DEFINITION_SPECIALIST": {
+        "name": "Traicie KO Interview Definition Specialist",
+        "description": "Specialist assisting in questions and answers definition for KO Criteria",
+    },
 }

config/type_defs/task_types.py

@@ -37,14 +37,23 @@ TASK_TYPES = {
         "description": "A Task to get Competencies from a Vacancy Text",
         "partner": "traicie"
     },
-    "TRAICIE_GET_KO_CRITERIA_TASK": {
-        "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"
+    },
+    "TRAICIE_ADVANCED_RAG_TASK": {
+        "name": "Traicie Advanced RAG",
+        "description": "A Task to perform Advanced RAG taking into account previous questions, tone of voice and language level",
+        "partner": "traicie"
+    },
+    "TRAICIE_AFFIRMATIVE_ANSWER_CHECK_TASK": {
+        "name": "Traicie Affirmative Answer Check",
+        "description": "A Task to check if the answer to a question is affirmative",
+        "partner": "traicie"
+    },
+    "TRAICIE_DETERMINE_INTERVIEW_MODE_TASK": {
+        "name": "Traicie Determine Interview Mode",
+        "description": "A Task to determine the interview mode based on the last user input",
     }
 }

content/changelog/1.0/1.0.0.md

@@ -5,6 +5,103 @@ 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).
 
+## [3.0.0-beta]
+
+### Added
+- Mobile Support for the chat client.
+- Additional visual clues for chatbot and human messages in the chat client
+
+### Changed
+- Additional visual clues for chatbot and human messages in the chat client
+- Adaptation (new version) of TRAICIE_SELECTION_SPECIALIST to further humanise interactions with end users. (Introduction of an additional interview phase to allow divergence from the interview scenario for normal questions, and convergence to the interview scenario.
+- Humanisation of cached interaction messages (random choice)
+- Adding specialist configuration information to be added as arguments for retrievers
+
+## [2.3.12-alfa]
+
+### Added
+- Modal display of privacy statement and terms & conditions documents in eveai_Chat_client
+- Consent-flag ==> Consent on privacy & terms...
+- Customisation option added to show or hide DynamicForm Title (and icon)
+- Session Header defaults clickable, opening selection views for Partner, Tenant and Catalog
+- 
+
+### Changed
+- Document Processing View - show 'Finished Processing' iso 'Processing' to have more logical visual indicators
+- TRAICIE_SELECTION_SPECIALIST now no longer shows question to start selection procedure at initialisation.
+
+### Fixed
+- Error Messages for adding documents in 'alert'
+- Correction of error in Template variable replacement, resulting in missing template variable value
+
+## [2.3.11-alfa]
+
+### Added
+- RQC (Recruitment Qualified Candidate) export to EveAIDataCapsule
+
+### Changed
+- Adapt configuration possibilities for Chat Client
+- Progress Tracker (client) level of information configuration
+- Definition of an Active Region in the client to ensure proper understanding
+- Adapting TRAICIE_SELECTION_SPECIALIST to retrieve preferred contact times using a form iso free text
+- Improvement of DynamicForm en FormField to handle boolean values.
+
+## [2.3.10-alfa]
+
+### Added
+- introduction of eveai-listview that is sortable and filterable (using tabulator), with client-side pagination
+- Introduction of PARTNER_RAG retriever, PARTNER_RAG_SPECIALIST and linked Agents and Tasks, to support for documentation RAG
+- Domain model diagrams added
+- Addition of LicensePeriod views and form
+
+### Changed
+- npm build now includes building of css files
+- npm build takes information from sourcefiles, defined in the correct component locations
+- eveai.css is now split into more maintainable, separate css files
+- adaptation of all list views in the application
+- Chat-client converted to vue components and composables
+
+
+## [2.3.9-alfa]
+
+### Added
+- Translation functionality for Front-End, configs (e.g. Forms) and free text
+- Introduction of TRACIE_KO_INTERVIEW_DEFINITION_SPECIALIST
+- Introduction of intelligent Q&A analysis - HumanAnswerServices
+- Full VA-versioin of TRAICIE_SELECTION_SPECIALIST
+- EveAICrewAI implementation guide
+
+### Changed
+- Allowed Languages and default_language part of Tenant Make
+- Refinement of EveAI Assets to define Partner Assets and allow storage of json
+- Improvements of Base & EveAICrewAI Specialists
+- Catalogs & Retrievers now fully type-based, removing need for end-user definition of Tagging Fields
+- RAG_SPECIALIST to support new possibilities
+
+## [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
+
+### 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

content/privacy/1.0/1.0.0.md

@@ -1,37 +1,726 @@
-# Privacy Policy
+# Data Protection Agreement Ask Eve AI
 
-## Version 1.0.0
+Ask Eve AI respects the privacy of their Customers, Partners, Users and End
+Users, and is strongly committed to keeping secure any information
+obtained from, for or about each of them. This Data Protection Agreement
+describes the practices with respect to Personal Data that Ask Eve AI
+collects from or about Customers, Partners, Users and End Users when
+they use the applications and services of Ask Eve AI (collectively,
+"Services").
 
-*Effective Date: 2025-06-03*
+## Definitions
 
-### 1. Introduction
+**Data Controller and Data Processor**: have each the meanings set out in
+the Data Protection Legislation;
 
-This Privacy Policy describes how EveAI collects, uses, and discloses your information when you use our services.
+*Data Protection Legislation:* means the European Union's General Data
+Protection Regulation 2016/679 on the protection of natural persons with
+regard to the processing of personal data and on the free movement of
+such data ("GDPR") and all applicable laws and regulations relating to
+the processing of personal data and privacy and any amendment or
+re-enactment of any of them;
 
-### 2. Information We Collect
+*Data Subject:* has the meaning set out in the Data Protection
+Legislation and shall refer, in this Data Processing Agreement to the
+identified or identifiable individual(s) whose Personal Data is/are
+under control of the Data Controller and is/are the subject of the
+Processing by the Data Processor in the context of the Services;
 
-We collect information you provide directly to us, such as account information, content you process through our services, and communication data.
+*Personal Data*: has the meaning set out in the Data Protection
+Legislation and shall refer, in this Data Processing Agreement to any
+information relating to the Data Subject that is subject to the
+Processing in the context of the Services;
 
-### 3. How We Use Your Information
+*Processing*: has the meaning given to that term in the Data Protection
+Legislation and "process" and "processed" shall have a corresponding
+meaning;
 
-We use your information to provide, maintain, and improve our services, process transactions, send communications, and comply with legal obligations.
+*Purposes*: shall mean the limited, specific and legitimate purposes of
+the Processing as described in the Agreement;
 
-### 4. Data Security
+*Regulators:* means those government departments and regulatory,
+statutory and other bodies, entities and committees which, whether under
+statute, rule, regulation, code of practice or otherwise, are entitled
+to regulate, investigate or influence the privacy matters dealt with in
+agreements and/or by the parties to the agreements (as the case may be);
 
-We implement appropriate security measures to protect your personal information against unauthorized access, alteration, disclosure, or destruction.
+*Sub-Processor:* shall mean the subcontractor(s) listed in Annex 1,
+engaged by the Data Processor to Process Personal Data on behalf of the
+Data Controller and in accordance with its instructions, the terms of
+this Data Processing Agreement and the terms of the written subcontract
+to be entered into with the Sub-Processor;
 
-### 5. International Data Transfers
+*Third Country:* means a country outside the European Economic Area that
+is not considered by the European Commission as offering an adequate
+level of protection in accordance with Article 44 of the European
+Union's General Data Protection Regulation 679/2016.
 
-Your information may be transferred to and processed in countries other than the country you reside in, where data protection laws may differ.
+*Tenant / Customer*: A tenant is the organisation, enterprise or company
+subscribing to the services of Ask Eve AI. Same as Customer, but more in
+context of a SAAS product like Ask Eve AI.
 
-### 6. Your Rights
+*Partner*: Any organisation, enterprise or company that offers services
+or knowledge on top of the Ask Eve AI platform.
 
-Depending on your location, you may have certain rights regarding your personal information, such as access, correction, deletion, or restriction of processing.
+*Account / User*: A user is a natural person performing activities like
+configuration or testing in Ask Eve AI, working within the context of a
+Tenant. A user is explicitly registered within the system as a member of
+the tenant.
 
-### 7. Changes to This Policy
+*End User*: An end user is every person making use of Ask Eve AI's services,
+in the context of Ask Eve AI services exposed by the tenant
+(e.g. a chatbot). This user is not explicitly registered within the
+system.
 
-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.
+*Ask Eve AI Platform*: The Ask Eve AI Platform (also referred to as
+"Evie" or "platform") is the combination of software components and
+products, code, configuration and prompts that allow Ask Eve AI to
+perform its activities.
 
-### 8. Contact Us
+*Ask Eve AI Services*: Is the collection of all services on top of the
+Ask Eve AI Platform offered to all users of the platform (Tenants,
+Partners, Users and End Users), including all services exposed by
+Partners on the Ask Eve AI platform.
 
-If you have any questions about this Privacy Policy, please contact us at privacy@askeveai.be.
+*Partner Services:* Is the collection of all services and applications built on top of
+the Ask Eve AI Platform offered by Partners. This excludes services
+connected through API's to the Ask Eve AI platform or services connected
+to the platform by any other means.
+
+## Qualification of Parties
+
+2.1 As part of the provision of the Services, Partner and Customer may
+engage Ask Eve AI to collect, process and/or use Personal Data on its
+behalf and/or Ask Eve AI may be able to access Personal Data and
+accordingly, in relation to the Agreement, the Parties agree that Partner
+or Customer is the Data Controller and Ask Eve AI is the Data Processor.
+
+2.2 From time to time, Partner or Customer may request Ask Eve AI to
+collect, process and/or use Personal Data on behalf of a third party for
+which Ask Eve AI may be able to access Personal Data and accordingly, in
+relation to the Agreement, the Parties agree that Customer is the Data
+Processor and Ask Eve AI is the Data Sub-Processor.
+
+# Data Classification
+
+Ask Eve AI classifies data as follows:
+
+# Data Protection {#data-protection-1}
+
+The Data Processor warrants, represents and undertakes to the Data
+Controller that it shall only process the Personal Data as limited in de
+following paragraphs.
+
+**System Data:**
+
+Ask Eve AI System Data is the data required to enable Ask Eve AI to:
+
+- authenticate and authorise accounts / users
+- authenticate and authorise automated interfaces (APIs, sockets,
+  integrations)
+- to invoice according to subscription and effective usage of Ask Eve
+  AI's services
+
+The following personal information is gathered:
+
+1.  *Account / User Information*: This information enables a user to log
+    into the Ask Eve AI systems, or to subscribe to the system's
+    services. It includes name, e-mail address, a secured password and
+    roles in the system.
+2.  *Tenant / Customer Information*: Although not personal data in the
+    strict sense, in order to subscribe to the services provided by Ask
+    Eve AI, payment information such as financial details, VAT numbers,
+    valid addresses and email information is required.
+
+**Tenant Data:**
+
+Tenant data is all information that is added to Ask Eve AI by
+
+- one of the tenant's registered accounts
+- one of the automated interfaces (APIs, sockets, integrations)
+  authorised by the tenant
+- interaction by one of the end users that has access to Ask Eve AI's
+  services exposed by the tenant
+
+This data is required to enable Ask Eve AI to perform the
+tenant-specific functions requested or defined by the Tenant, such as
+enabling AI chatbots or AI specialists to work on tenant specific
+information.
+
+There's no personal data collected explicitly, however, the following
+personal information is gathered:
+
+1.  *End User Content*: Ask Eve AI collects Personal Data that the End
+    User provides in the input to our Services ("Content") as is.
+2.  *Communication Information*: If the Customer communicates with Ask
+    Eve AI, such as via email, our pages on social media sites or the
+    chatbots or other interfaces we provide to our services, Ask Eve AI
+    may collect Personal Data like name, contact information, and the
+    contents of the messages the Customer sends ("Communication
+    Information"). End User personal information may be provided by End
+    User in interactions with Ask Eve AI's services, and as such will be
+    stored in Ask Eve AI's services as is.
+
+> 
+
+> **User Data:**
+
+> Ask Eve AI collects information the User may provide to Ask Eve AI,
+> such as when you participate in our events, surveys, ask us to get in
+> contact or provide us with information to establish your identity or
+> age.
+
+> 
+
+> 
+
+> \
+
+**Technical Data:**\
+When you visit, use, or interact with the Services, we receive the
+following information about your visit, use, or interactions ("Technical
+Information"):
+
+1.  *Log Data:* Ask Eve AI collects information that your browser or
+    device automatically sends when the Customer uses the Services. Log
+    data includes the Internet Protocol address, browser type and
+    settings, the date and time of your request, and how the Customer
+    interacts with the Services.
+2.  *Usage Data:* Ask Eve AI collects information about the use of the
+    Services, such as the types of content that the Customer views or
+    engages with, the features the Customer uses and the actions the
+    Customer takes, as well as the Customer's time zone, country, the
+    dates and times of access, user agent and version, type of computer
+    or mobile device, and the Customer's computer connection.
+3.  *Interaction Data*: Ask Eve AI collects the data you provide when
+    interacting with it's services, such as interacting with a chatbot
+    or similar advanced means.
+4.  *Device Information:* Ask Eve AI collects information about the
+    device the Customer uses to access the Services, such as the name of
+    the device, operating system, device identifiers, and browser you
+    are using. Information collected may depend on the type of device
+    the Customer uses and its settings.
+5.  *Location Information:* Ask Eve AI may determine the general area
+    from which your device accesses our Services based on information
+    like its IP address for security reasons and to make your product
+    experience better, for example to protect the Customer's account by
+    detecting unusual login activity or to provide more accurate
+    responses. In addition, some of our Services allow the Customer to
+    choose to provide more precise location information from the
+    Customer's device, such as location information from your device's
+    GPS.
+6.  *Cookies and Similar Technologies:* Ask Eve AI uses cookies and
+    similar technologies to operate and administer our Services, and
+    improve your experience. If the Customer uses the Services without
+    creating an account, Ask Eve AI may store some of the information
+    described in this Agreement with cookies, for example to help
+    maintain the Customer's preferences across browsing sessions. For
+    details about our use of cookies, please read our Cookie Policy.
+
+**External Data:**
+
+Information Ask Eve AI receives from other sources:
+
+Ask Eve AI receives information from trusted partners, such as security
+partners, to protect against fraud, abuse, and other security threats to
+the Services, and from marketing vendors who provide us with information
+about potential customers of our business services.
+
+Ask Eve AI also collects information from other sources, like
+information that is publicly available on the internet, to develop the
+models that power the Services.
+
+Ask Eve AI may use Personal Data for the following purposes:
+
+- To provide, analyse, and maintain the Services, for example to respond
+  to the Customer's questions for Ask Eve AI;
+- To improve and develop the Services and conduct research, for example
+  to develop new product features;
+- To communicate with the Customer, including to send the Customer
+  information about our Services and events, for example about changes
+  or improvements to the Services;
+- To prevent fraud, illegal activity, or misuses of our Services, and to
+  protect the security of our systems and Services;
+- To comply with legal obligations and to protect the rights, privacy,
+  safety, or property of our users or third parties.
+
+Ask Eve AI may also aggregate or de-identify Personal Data so that it no
+longer identifies the Customer and use this information for the purposes
+described above, such as to analyse the way our Services are being used,
+to improve and add features to them, and to conduct research. Ask Eve AI
+will maintain and use de-identified information in de-identified form
+and not attempt to reidentify the information, unless required by law.
+
+As noted above, Ask Eve AI may use content the Customer provides Ask Eve
+AI to improve the Services, for example to train the models that power
+Ask Eve AI. Read [**our instructions*⁠*(opens in a new
+window)**](https://help.openai.com/en/articles/5722486-how-your-data-is-used-to-improve-model-performance) on
+how you can opt out of our use of your Content to train our models.\
+
+1.  1.  ## Instructions {#instructions-3}
+
+Data Processor shall only Process Personal Data of Data Controller on
+behalf of the Data Controller and in accordance with this Data
+Processing Agreement, solely for the Purposes and the eventual
+instructions of the Data Controller, and to the extent, and in such a
+manner, as is reasonably necessary to provide the Services in accordance
+with the Agreement. Data Controller shall only give instructions that
+comply with the Data Protection legislation.
+
+2.  1.  ## Applicable mandatory laws  {#applicable-mandatory-laws-3}
+
+Data Processor shall only Process as required by applicable mandatory
+laws and always in compliance with Data Protection Legislation.\
+
+3.  1.  ## Transfer to a third party  {#transfer-to-a-third-party-3}
+
+Data Processor uses functionality of third party services to realise
+it's functionality. For the purpose of realising Ask Eve AI's
+functionality, and only for this purpose, information is sent to it's
+sub-processors.
+
+Data Processor shall not transfer or disclose any Personal Data to any
+other third party and/or appoint any third party as a sub-processor of
+Personal Data unless it is legally required or in case of a notification
+to the Data Controller by which he gives his consent.
+
+4.  1.  ## Transfer to a Third Country  {#transfer-to-a-third-country-3}
+
+Data Processor shall not transfer Personal Data (including any transfer
+via electronic media) to any Third Country without the prior written
+consent of the Data Controller by exception of the following.
+
+The Parties agree that Personal Data can only be transferred to and/or
+kept with the recipient outside the European Economic Area (EEA) in a
+country that not falls under an adequacy decision issued by the European
+Commission by exception and only if necessary to comply with the
+obligations of this Agreement or when legally required. Such transfer
+shall be governed by the terms of a data transfer agreement containing
+standard contractual clauses as published in the Decision of the
+European Commission of June 4, 2021 (Decision (EU) 2021/914), or by
+other mechanisms foreseen by the applicable data protection law.
+
+The Data Processor shall prior to the international transfer inform the
+Data Controller about the particular measures taken to guarantee the
+protection of the Personal Data of the Data Subject in accordance with
+the Regulation.
+
+\
+
+5.  1.  ## Data secrecy {#data-secrecy-3}
+
+The Data Processor shall maintain data secrecy in accordance with
+applicable Data Protection Legislation and shall take all reasonable
+steps to ensure that:
+
+> \(1\) only those Data Processor personnel and the Sub-Processor
+> personnel that need to have access to Personal Data are given access
+> and only to the extent necessary to provide the Services; and
+
+> \(2\) the Data Processor and the Sub-Processor personnel entrusted
+> with the processing of, or who may have access to, Personal Data are
+> reliable, familiar with the requirements of data protection and
+> subject to appropriate obligations of confidentiality and data secrecy
+> in accordance with applicable Data Protection Legislation and at all
+> times act in compliance with the Data Protection Obligations.
+
+6.  1.  ## Appropriate technical and organizational measures {#appropriate-technical-and-organizational-measures-3}
+
+Data Processor has implemented (and shall comply with) all appropriate
+technical and organizational measures to ensure the security of the
+Personal Data, to ensure that processing of the Personal Data is
+performed in compliance with the applicable Data Protection Legislation
+and to ensure the protection of the Personal Data against accidental or
+unauthorized access, alteration, destruction, damage, corruption or loss
+as well as against any other unauthorized or unlawful processing or
+disclosure ("Data Breach"). Such measures shall ensure best practice
+security, be compliant with Data Protection Legislation at all times and
+comply with the Data Controller's applicable IT security policies.
+
+Data Controller has also introduced technical and organizational
+measures, and will continue to introduce them to protect its Personal
+Data from accidental or unlawful destruction or accidental loss,
+alteration, unauthorized disclosure or access. For the sake of clarity,
+the Data Controller is responsible for the access control policy,
+registration, de-registration and withdrawal of the access rights of the
+Users or Consultant(s) to its systems, for the access control,
+registration, de-registration and withdrawal of automation access codes
+(API Keys), and is also responsible for the complete physical security
+of its environment.
+
+7.  1.  ## Assistance and co-operation {#assistance-and-co-operation-3}
+
+The Data Processor shall provide the Data Controller with such
+assistance and co-operation as the Data Controller may reasonably
+request to enable the Data Controller to comply with any obligations
+imposed on it by Data Protection Legislation in relation to Personal
+Data processed by the Data Processor, including but not limited to:
+
+> \(1\) on request of the Data Controller, promptly providing written
+> information regarding the technical and organizational measures which
+> the Data Processor has implemented to safeguard Personal Data;\
+
+> \(2\) disclosing full and relevant details in respect of any and all
+> government, law enforcement or other access protocols or controls
+> which it has implemented, but only in so far this information is
+> available to the Data Processor;
+
+> \(3\) notifying the Data Controller as soon as possible and as far as
+> it is legally permitted to do so, of any access request for disclosure
+> of data which concerns Personal Data (or any part thereof) by any
+> Regulator, or by a court or other authority of competent jurisdiction.
+> For the avoidance of doubt and as far as it is legally permitted to do
+> so, the Data Processor shall not disclose or release any Personal Data
+> in response to such request served on the Data Processor without first
+> consulting with and obtaining the written consent of the Data
+> Controller; and
+
+> \(4\) notifying the Data Controller as soon as possible of any legal
+> or factual circumstances preventing the Data Processor from executing
+> any of the instructions of the Data Controller.
+
+> \(5\) notifying the Data Controller as soon as possible of any request
+> received directly from a Data Subject regarding the Processing of
+> Personal Data, without responding to such request. For the avoidance
+> of doubt, the Data Controller is solely responsible for handling and
+> responding to such requests.
+
+> \(6\) notifying the Data Controller immediately in writing if it
+> becomes aware of any Data Breach and provide the Data Controller, as
+> soon as possible, with information relating to a Data Breach,
+> including, without limitation, but only insofar this information is
+> readily available to the Data Processor: the nature of the Data Breach
+> and the Personal Data affected, the categories and number of Data
+> Subjects concerned, the number of Personal Data records concerned,
+> measures taken to address the Data Breach, the possible consequences
+> and adverse effect of the Data Breach .
+
+> \(7\) Where the Data Controller is legally required to provide
+> information regarding the Personal Data Processed by Data Processor
+> and its Processing to any Data Subject or third party, the Data
+> Processor shall support the Data Controller in the provision of such
+> information when explicitly requested by the Data Controller.
+
+4.  # Audit {#audit-1}
+
+At the Data Controller's request the Data Processor shall provide the
+Data Controller with all information needed to demonstrate that it
+complies with this Data Processing Agreement The Data Processor shall
+permit the Data Controller, or a third-party auditor acting under the
+Data Controller's direction, (but only to the extent this third-party
+auditor cannot be considered a competitor of the Data Processor), to
+conduct, at the Data Controller's cost (for internal and external
+costs), a data privacy and security audit, concerning the Data
+Processor's data security and privacy procedures relating to the
+processing of Personal Data, and its compliance with the Data Protection
+Obligations, but not more than once per contract year. The Data
+Controller shall provide the Data Processor with at least thirty (30)
+days prior written notice of its intention to perform an audit. The
+notification must include the name of the auditor, a description of the
+purpose and the scope of the audit. The audit has to be carried out in
+such a way that the inconvenience for the Data Processor is kept to a
+minimum, and the Data Controller shall impose sufficient confidentiality
+obligations on its auditors. Every auditor who does an inspection will
+be at all times accompanied by a dedicated employee of the Processor.
+
+4.  # Liability {#liability-1}
+
+Each Party shall be liable for any suffered foreseeable, direct and
+personal damages ("Direct Damages") resulting from any attributable
+breach of its obligations under this Data Processing Agreement. If one
+Party is held liable for a violation of its obligations hereunder, it
+undertakes to indemnify the non-defaulting Party for any Direct Damages
+resulting from any attributable breach of the defaulting Party's
+obligations under this Data Processing Agreement or any fault or
+negligence to the performance of this Data Processing Agreement. Under
+no circumstances shall the Data Processor be liable for indirect,
+incidental or consequential damages, including but not limited to
+financial and commercial losses, loss of profit, increase of general
+expenses, lost savings, diminished goodwill, damages resulting from
+business interruption or interruption of operation, damages resulting
+from claims of customers of the Data Controller, disruptions of
+planning, loss of anticipated profit, loss of capital, loss of
+customers, missed opportunities, loss of advantages or corruption and/or
+loss of files resulting from the performance of the Agreement.
+
+[]{#anchor}[]{#anchor-1}[]{#anchor-2}[]{#anchor-3}If it appears that
+both the Data Controller and the Data Processor are responsible for the
+damage caused by the processing of Personal Data, both Parties shall be
+liable and pay damages, in accordance with their individual share in the
+responsibility for the damage caused by the processing.
+
+[]{#anchor-4}[]{#anchor-5}[]{#anchor-6}In any event the total liability
+of the Data Processor under this Agreement shall be limited to the cause
+of damage and to the amount that equals the total amount of fees paid by
+the Data Controller to the Data Processor for the delivery and
+performance of the Services for a period not more than twelve months
+immediately prior to the cause of damages. In no event shall the Data
+Processor be held liable if the Data Processor can prove he is not
+responsible for the event or cause giving rise to the damage.
+
+4.  # Term {#term-1}
+
+This Data Processing Agreement shall be valid for as long as the
+Customer uses the Services.
+
+After the termination of the Processing of the Personal Data or earlier
+upon request of the Data Controller, the Data Processor shall cease all
+use of Personal Data and delete all Personal Data and copies thereof in
+its possession unless otherwise agreed or when deletion of the Personal
+Data should be technically impossible.
+
+4.  # Governing law -- jurisdiction {#governing-law-jurisdiction-1}
+
+This Data Processing Agreement and any non-contractual obligations
+arising out of or in connection with it shall be governed by and
+construed in accordance with Belgian Law.
+
+Any litigation relating to the conclusion, validity, interpretation
+and/or performance of this Data Processing Agreement or of subsequent
+contracts or operations derived therefrom, as well as any other
+litigation concerning or related to this Data Processing Agreement,
+without any exception, shall be submitted to the exclusive jurisdiction
+of the courts of Gent, Belgium.
+
+# Annex1 
+
+# Sub-Processors 
+
+The Data Controller hereby agrees to the following list of
+Sub-Processors, engaged by the Data Processor for the Processing of
+Personal Data under the Agreement:
+
++-------------+--------------------------------------------------------+
+|             |                                                        |
++=============+========================================================+
+| **‍Open AI** |                                                        |
++-------------+--------------------------------------------------------+
+| ‍Address     | OpenAI, L.L.C.,                                        |
+|             |                                                        |
+|             | 3180 18th St, San Francisco,                           |
+|             |                                                        |
+|             | CA 94110,                                              |
+|             |                                                        |
+|             | United States of America.                              |
++-------------+--------------------------------------------------------+
+| ‍Contact     | OpenAI's Data Protection team                          |
+|             |                                                        |
+|             | dsar@openai.com                                        |
++-------------+--------------------------------------------------------+
+| ‍Description | Ask Eve AI accesses Open AI's models through Open AI's |
+|             | API to realise it's functionality.                     |
+|             |                                                        |
+|             | Services are GDPR compliant.                           |
++-------------+--------------------------------------------------------+
+|             |                                                        |
++-------------+--------------------------------------------------------+
+
++---------------+------------------------------------------------------+
+|               |                                                      |
++===============+======================================================+
+| **StackHero** |                                                      |
++---------------+------------------------------------------------------+
+| ‍‍Address       | Stackhero                                            |
+|               |                                                      |
+|               | 1 rue de Stockholm                                   |
+|               |                                                      |
+|               | 75008 Paris                                          |
+|               |                                                      |
+|               | France                                               |
++---------------+------------------------------------------------------+
+| ‍‍Contact       | support@stackhero.io                                 |
++---------------+------------------------------------------------------+
+| ‍‍Description   | StackHero is Ask Eve AI's cloud provider, and hosts  |
+|               | the services for PostgreSQL, Redis, Docker, Minio    |
+|               | and Greylog.                                         |
+|               |                                                      |
+|               | Services are GDPR compliant.                         |
++---------------+------------------------------------------------------+
+| **‍**           |                                                      |
++---------------+------------------------------------------------------+
+
++----------------+-----------------------------------------------------+
+|                |                                                     |
++================+=====================================================+
+| **A2 Hosting** |                                                     |
++----------------+-----------------------------------------------------+
+| ‍‍‍Address        | A2 Hosting, Inc.                                    |
+|                |                                                     |
+|                | PO Box 2998                                         |
+|                |                                                     |
+|                | Ann Arbor, MI 48106                                 |
+|                |                                                     |
+|                | United States                                       |
++----------------+-----------------------------------------------------+
+| ‍‍‍Contact        | [*+1 734-222-4678*](tel:+1(734)222-4678)            |
++----------------+-----------------------------------------------------+
+| ‍‍‍Description    | A2 hosting is hosting our main webserver and        |
+|                | mailserver. They are all hosted on European servers |
+|                | (Iceland). It does not handle data of our business  |
+|                | applications.                                       |
+|                |                                                     |
+|                | Services are GDPR compliant.                        |
++----------------+-----------------------------------------------------+
+| **‍**            |                                                     |
++----------------+-----------------------------------------------------+
+
+# Annex 2 
+
+# []{#anchor-7}Technical and organizational measures 
+
+# 1. Purpose of this document
+
+This document contains an overview of the technical and operational
+measures which are applicable by default within Ask Eve AI. The actual
+measures taken depend on the services provided and the specific customer
+context. Ask Eve AI guarantees it has for all its services and sites the
+necessary adequate technical and operational measures included in the
+list below following a Data Protection Impact Assessment (DPIA).
+
+These measures are designed to:
+
+1.  ensure the security and confidentiality of Ask Eve AI managed data,
+    information, applications and infrastructure;
+2.  protect against any anticipated threats or hazards to the security
+    and integrity of Personal Data, Ask Eve AI Intellectual Property,
+    Infrastructure or other business-critical assets;
+3.  protect against any actual unauthorized processing, loss, use,
+    disclosure or acquisition of or access to any Personal Data or other
+    business-critical information or data managed by Ask Eve AI.
+
+Ask Eve AI ensures that all its Sub-Processors have provided the
+necessary and required guarantees on the protection of personal data
+they process on Ask Eve AI's behalf.
+
+Ask Eve AI continuously monitors the effectiveness of its information
+safeguards and organizes a yearly compliance audit by a Third Party to
+provide assurance on the measures and controls in place.
+
+# 2. Technical & Organizational Measures
+
+Ask Eve AI has designed, invested and implemented a dynamic
+multi-layered security architecture protecting its endpoints, locations,
+cloud services and custom-developed business applications against
+today's variety of cyberattacks ranging from spear phishing, malware,
+viruses to intrusion, ransomware and data loss / data breach incidents
+by external and internal bad actors.
+
+This architecture, internationally recognized and awarded, is a
+combination of automated proactive, reactive and forensic quarantine
+measures and Ask Eve AI internal awareness and training initiatives that
+creates and end-to-end chain of protection to identify, classify and
+stop any potential malicious action on Ask Eve AI's digital
+infrastructure. Ask Eve AI uses an intent-based approach where
+activities are constantly monitored, analysed and benchmarked instead of
+relying solely on a simple authentication/authorization trust model.
+
+4.  1.  ## General Governance & Awareness {#general-governance-awareness-3}
+
+As a product company, Ask Eve AI is committed to maintain and preserve
+an IT infrastructure that has a robust security architecture, complies
+with data regulation policies and provides a platform to its employees
+for flexible and effective work and collaboration activities with each
+other and our customers.
+
+Ask Eve AI IT has a cloud-first and cloud-native strategy and as such
+works with several third-party vendors that store and process our
+company data. Ask Eve AI IT aims to work exclusively with vendors that
+are compliant with the national and European Data Protection
+Regulations. Transfers of Personal Data to third-countries are subject
+to compliance by the third-country Processor/Sub-Processor with the
+Standard Contractual Clauses as launched by virtue of the EU Commission
+Decision 2010/87/EU of 5 February 2010 as updated by the EU Comission
+Decision (EU) 2021/914 of 4 June 2021, unless the third country of the
+Processor/Sub-Processor has been qualified as providing an adequate
+level of protection for Personal Data by the European Commission, (a.o.
+EU-U.S. Data Privacy Framework).
+
+Ask Eve AI has an extensive IT policy applicable to any employee or
+service provider that uses Ask Eve AI platforms or infrastructure. This
+policy informs the user of his or her rights & duties and informs the
+user of existing monitoring mechanisms to enforce security and data
+compliance. The policy is updated regularly and an integrated part of
+new employee onboarding and continuous training and development
+initiatives on internal tooling and cyber security;
+
+Ask Eve AI IT has several internal policies on minimal requirements
+before an application, platform or tool can enter our application
+landscape. These include encryption requirements, DLP requirements,
+transparent governance & licensing requirements and certified support
+contract procedures & certifications;
+
+These policies are actively enforced through our endpoint security, CASB
+and cloud firewall solutions. Any infraction on these policies is met
+with appropriate action and countermeasures and may result in a complete
+ban from using and accessing Ask Eve AI's infrastructure and platforms
+or even additional legal action against employees, clients or other
+actors;
+
+## 9.2. Physical Security & Infrastructure
+
+Ask Eve AI has deployed industry-standard physical access controls to
+its location for employee presence and visitor management.
+
+Restricted environments including network infrastructure, data center
+and server rooms are safeguarded by additional access controls and
+access to these rooms is audited. CCTV surveillance is present in all
+restricted and critical areas.
+
+Fire alarm and firefighting systems are implemented for employee and
+visitor safety. Regular fire simulations and evacuation drills are
+performed.
+
+Clean desk policies are enforced, employees regularly in contact with
+sensitive information have private offices and follow-me printing
+enabled.
+
+Key management governance is implemented and handled by Facilities.
+
+1.  1.  ## Endpoint Security & User Accounts {#endpoint-security-user-accounts-3}
+
+All endpoints and any information stored are encrypted using
+enterprise-grade encryption on all operating systems supported by Ask
+Eve AI.
+
+Ask Eve AI has implemented a centrally managed anti-virus and malware
+protection system for endpoints, email and document stores.
+
+Multifactor Authentication is enforced on all user accounts where
+possible.
+
+Conditional Access is implemented across the entire infrastructure
+limiting access to specific regions and setting minimum requirements for
+the OS version, network security level, endpoint protection level and
+user behavior.
+
+Only vendor supplied updates are installed.
+
+Ask Eve AI has deployed a comprehensive device management strategy to
+ensure endpoint integrity and policy compliance.
+
+Access is managed according to role-based access control principles and
+all user behavior on Ask Eve AI platforms is audited.
+
+1.  1.  ## Data Storage, Recovery & Securing Personal Data {#data-storage-recovery-securing-personal-data-3}
+
+> Ask Eve AI has deployed:
+
+- An automated multi-site encrypted back-up process with daily integrity
+  reviews.
+- The possibility for the anonymization, pseudonymization and encryption
+  of Personal Data.
+- The ability to monitor and ensure the ongoing confidentiality,
+  integrity, availability and resilience of processing systems and
+  services.
+- The ability to restore the availability and access to Personal Data in
+  a timely manner in the event of a physical or technical incident.
+- A logical separation between its own data, the data of its customers
+  and suppliers.
+- A process to keep processed data accurate, reliable and up-to-date.
+- Records of the processing activities.
+- Data Retention Policies
+
+1.  1.  ## Protection & Insurance {#protection-insurance-3}
+
+Ask Eve AI has a cyber-crime insurance policy. Details on the policy can
+be requested through the legal department.

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='
@@ -144,40 +144,6 @@ services:
     networks:
       - eveai-network
 
-#  eveai_chat:
-#    image: josakola/eveai_chat:latest
-#    build:
-#      context: ..
-#      dockerfile: ./docker/eveai_chat/Dockerfile
-#      platforms:
-#        - linux/amd64
-#        - linux/arm64
-#    ports:
-#      - 5002:5002
-#    environment:
-#      <<: *common-variables
-#      COMPONENT_NAME: eveai_chat
-#    volumes:
-#      - ../eveai_chat:/app/eveai_chat
-#      - ../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
-#    healthcheck:
-#      test: [ "CMD", "curl", "-f", "http://localhost:5002/healthz/ready" ]  # Adjust based on your health endpoint
-#      interval: 30s
-#      timeout: 1s
-#      retries: 3
-#      start_period: 30s
-#    networks:
-#      - eveai-network
-
   eveai_chat_client:
     image: josakola/eveai_chat_client:latest
     build:

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

docker/eveai_chat/Dockerfile

@@ -1,70 +0,0 @@
-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 requirements.txt
-
-# Copy the source code into the container.
-COPY eveai_chat /app/eveai_chat
-COPY common /app/common
-COPY config /app/config
-COPY scripts /app/scripts
-COPY patched_packages /app/patched_packages
-
-# Set permissions for entrypoint script
-RUN chmod 777 /app/scripts/entrypoint.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 5002
-
-# Set entrypoint and command
-ENTRYPOINT ["/app/scripts/entrypoint.sh"]
-CMD ["/app/scripts/start_eveai_chat.sh"]

docker/rebuild_chat_client.sh

@@ -1,9 +1,20 @@
 #!/bin/bash
 
+cd /Volumes/OWC4M2_1/Development/Josako/EveAI/TBD/docker
 source ./docker_env_switch.sh dev
-source .env
+
+echo "Copying client images"
+cp -fv ../eveai_chat_client/static/assets/img/* ../nginx/static/assets/img
+
 
 dcdown eveai_chat_client nginx
-./update_chat_client_statics.sh
+
+cd ../nginx
+
+npm run clean
+npm run build
+
+cd ../docker
 ./build_and_push_eveai.sh -b nginx
+
 dcup eveai_chat_client nginx

docker/release_and_tag_eveai.sh

@@ -31,10 +31,10 @@ fi
 # Path to your docker-compose file
 DOCKER_COMPOSE_FILE="compose_dev.yaml"
 
-# Get all the images defined in docker-compose
+# Get all the img defined in docker-compose
 IMAGES=$(docker compose -f $DOCKER_COMPOSE_FILE config | grep 'image:' | awk '{ print $2 }')
 
-# Start tagging only relevant images
+# Start tagging only relevant img
 for DOCKER_IMAGE in $IMAGES; do
     # Check if the image belongs to your Docker account and ends with :latest
     if [[ $DOCKER_IMAGE == $DOCKER_ACCOUNT* && $DOCKER_IMAGE == *:latest ]]; then

documentation/CrewAI Specialist Implementation Guide.md

@@ -0,0 +1,92 @@
+# CrewAI Specialist Implementation Guide
+
+## Name Sensitivity
+A lot of the required functionality to implement specialists has been automated. This automation is based on naming
+conventions. So ... names of variables, attributes, ... needs to be precise, or you'll get into problems.
+
+## Base Class: CrewAIBaseSpecialistExecutor
+
+The base class for defining new CrewAI based Specialists is CrewAIBaseSpecialistExecutor. This class implements a lot of
+functionality out of the box, making the full development process easier to manage:
+
+- Before the specialist execution
+  - Retrieval of context (RAG Retrieval)
+  - Build up of historic context (memory)
+  - Initialisation of Agents, Tasks and tools (defined in the specialist configuration)
+  - Initialisation of specialist state, based on historic context
+- During specialist execution
+  - Updates to the history (ChatSession and Interaction)
+  - Formatting of the results
+
+It enables the following functionality:
+
+- Logging when requested (_log_tuning)
+- Sending progress updates (ept)
+- ...
+
+### Naming Conventions
+- tasks are referenced by using the lower case name of the configured task. Their names should always end on "_task"
+- agents idem dito, but their names should end on "_agent"
+- tools idem dito, but their names will end on "_tools"
+
+## Implementation
+
+### Step 1 - Code location
+
+The implementation of a specialist should be placed in the specialists folder. If the specialist is a global specialist
+(i.e. it can be used by all tenants), it will be in the globals folder. If it is created for a specific partner, we will
+place it in the folder for that partner (lower_case)
+
+The naming of the implementation is dependent on the version of the specialist we are creating. If we implement a
+version 1.0, the implementation will be called "1_0.py". This implementation is also used for specialists with different
+patch versions (e.g. 1.0.1, 1.0.4, ...)
+
+### Step 2: type and type_version properties
+
+- Adapt the type and type_version properties to define the correct specialist. This refers to the actual specialist configuration!
+
+### Step 3: Specialist Setup 
+
+#### Specialising init
+
+Use specialisisation of the init method to define the crews you require, and if needed, additional initialisation code.
+
+#### configuring the specialist
+
+- _config_task_agents
+  - Link each task to the agent that will perform the task
+  - use _add_task_agent for each of the tasks
+- _config_pytdantic_outputs
+  - Link each task to a specific output (Pydantic)
+  - use _add_pydantic_output for each of the tasks
+- _config_state_result_relations
+  - Zorg dat er een automatische overdracht kan zijn van state naar result
+  - use _add_state_result_relation om zo'n relatie toe te voegen
+  - when you give the attributes in the state and result the same names, this becomes quite obvious and easy to maintain
+
+### Step 4: Implement specialist execution
+
+This is the entry method invoked to actually implement specialist logic.
+
+#### Available data
+
+- arguments: the arguments passed in the specialist invocation
+- formatted_context: the documents retrieved for the specialist
+- citations: the citations found in the retrieval process
+- self._formatted_history: a build-up of the history of the conversation
+- self._cached_session: the complete cached session
+- self.flow.state: the current flow state
+
+#### Implementation guidelines
+
+- allways use self.flow.state to update elements required to have available in consecutive calls, or elements you want to persist in the results
+- use the phase (defined in the state) to distinguish between phases in the specialist execution
+- Use "SelectionResult.create_for_type(self.type, self.type_version)" to return results. 
+
+### Step 5: Define Implementation Classes
+
+- Define the Pydantic Output Classes to ensure structured outputs
+- Define an Input class, containing all potential inputs required for flows and crews to perform their activities
+- Define a FlowState (derived from EveAIFlowState) to maintain state throughout specialist execution
+- Define a Result (derived from SpecialistResult) to define all information that needs to be stored in the session
+- Define the Flow (derived from EveAICrewAIFlow) with the FlowState class

documentation/ICON_MANAGEMENT_GUIDE.md

@@ -0,0 +1,294 @@
+# Icon Management System Guide
+
+## 🎯 Overview
+
+The icon management system has been **100% MODERNIZED** to Vue 3 composables. We now have:
+
+1. **✅ Fully Self-Contained Composables** - No legacy dependencies
+2. **✅ Pure Vue 3 Architecture** - Modern Composition API throughout
+3. **✅ Zero Legacy Code** - All window.iconManager dependencies removed
+4. **✅ Optimal Performance** - Direct icon loading without external systems
+
+## 📁 File Structure
+
+```
+eveai_chat_client/static/assets/js/
+└── composables/
+    ├── index.js                     # Barrel export for composables
+    └── useIconManager.js            # Self-contained Vue 3 composables
+```
+
+## 🔧 Available Methods
+
+### Vue 3 Composables (Self-Contained)
+
+#### 1. useIconManager() - Full Featured
+
+```vue
+<script setup>
+import { useIconManager } from '@/composables/useIconManager.js';
+
+const { 
+    loadIcon, 
+    loadIcons, 
+    ensureIconsLoaded,
+    watchIcon,
+    watchFormDataIcon,
+    preloadCommonIcons,
+    isIconManagerReady 
+} = useIconManager();
+
+// Load single icon
+loadIcon('send');
+
+// Load multiple icons
+loadIcons(['send', 'attach_file']);
+
+// Preload common icons
+preloadCommonIcons();
+</script>
+```
+
+#### 2. useIcon() - Simple Icon Loading
+
+```vue
+<script setup>
+import { useIcon } from '@/composables/useIconManager.js';
+
+// Automatically loads icon on mount
+const { loadIcon, isIconManagerReady } = useIcon('send');
+</script>
+```
+
+#### 3. useFormIcon() - Form Data Integration
+
+```vue
+<script setup>
+import { ref } from 'vue';
+import { useFormIcon } from '@/composables/useIconManager.js';
+
+const formData = ref({ icon: 'send' });
+
+// Automatically watches formData.icon and loads icons
+const { loadIcon, isIconManagerReady } = useFormIcon(formData);
+</script>
+```
+
+## 🔄 Migration Guide
+
+### From IconManagerMixin (Old)
+
+```vue
+<!-- OLD: Using mixin -->
+<script>
+import { IconManagerMixin } from '@/iconManager.js';
+
+export default {
+    mixins: [IconManagerMixin],
+    // Component automatically loads formData.icon
+}
+</script>
+```
+
+### To Vue 3 Composable (New)
+
+```vue
+<!-- NEW: Using composable -->
+<script setup>
+import { useFormIcon } from '@/composables/useIconManager.js';
+
+const props = defineProps(['formData']);
+const { loadIcon } = useFormIcon(() => props.formData);
+</script>
+```
+
+## 📋 Current Usage in Vue Components
+
+### All Components Now Use Modern Composables ✅
+
+1. **ChatInput.vue** - Uses `useIconManager()` composable
+2. **ChatMessage.vue** - Uses `useIconManager()` composable  
+3. **DynamicForm.vue** - Uses `useIconManager()` composable with boolean icon support
+
+## 🔘 Boolean Value Display
+
+### Overview
+
+Boolean values in read-only DynamicForm components are automatically displayed using Material Icons instead of text for improved user experience.
+
+### Icon Mapping
+
+```javascript
+const booleanIconMapping = {
+  true: 'check_circle',    // Green checkmark icon
+  false: 'cancel'          // Red cancel/cross icon
+};
+```
+
+### Visual Styling
+
+- **True values**: Green `check_circle` icon (#4caf50)
+- **False values**: Red `cancel` icon (#f44336)
+- **Size**: 20px font size with middle vertical alignment
+- **Accessibility**: Includes `aria-label` and `title` attributes
+
+### Usage Example
+
+```vue
+<!-- Form definition with boolean fields -->
+<script>
+export default {
+  data() {
+    return {
+      formData: {
+        title: 'User Settings',
+        fields: [
+          { id: 'active', name: 'Actief', type: 'boolean' },
+          { id: 'verified', name: 'Geverifieerd', type: 'boolean' }
+        ]
+      },
+      formValues: {
+        active: true,    // Will show green check_circle
+        verified: false  // Will show red cancel
+      }
+    };
+  }
+};
+</script>
+
+<!-- Read-only display -->
+<dynamic-form 
+  :form-data="formData" 
+  :form-values="formValues" 
+  :read-only="true"
+  api-prefix="/api"
+/>
+```
+
+### Implementation Details
+
+- **Automatic icon loading**: Boolean icons (`check_circle`, `cancel`) are preloaded when DynamicForm mounts
+- **Read-only only**: Edit mode continues to use standard HTML checkboxes
+- **Accessibility**: Each icon includes Dutch labels ('Ja'/'Nee') for screen readers
+- **Responsive**: Icons scale appropriately with form styling
+
+### CSS Classes
+
+```css
+.boolean-icon {
+    font-size: 20px;
+    vertical-align: middle;
+}
+
+.boolean-true {
+    color: #4caf50; /* Green for true */
+}
+
+.boolean-false {
+    color: #f44336; /* Red for false */
+}
+
+.field-value.boolean-value {
+    display: flex;
+    align-items: center;
+}
+```
+
+### Zero Legacy Code Remaining ✅
+
+- ❌ No IconManagerMixin references
+- ❌ No window.iconManager calls
+- ❌ No legacy iconManager.js file
+- ✅ 100% Vue 3 composables
+
+## ✅ Complete Modernization Achieved
+
+### 1. Legacy System Eliminated
+- **Before**: Hybrid system with window.iconManager + composables
+- **After**: Pure Vue 3 composables, zero legacy dependencies
+
+### 2. Self-Contained Architecture
+- **Before**: Composables depended on external iconManager.js
+- **After**: Fully self-contained composables with direct icon loading
+
+### 3. Optimal Performance
+- **Before**: Multiple layers (composable → window.iconManager → DOM)
+- **After**: Direct composable → DOM, no intermediate layers
+
+## 🚀 Modern Usage Patterns (100% Vue 3)
+
+### For Form Components
+```vue
+<script setup>
+import { useFormIcon } from '@/composables';
+
+const props = defineProps(['formData']);
+const { loadIcon } = useFormIcon(() => props.formData);
+</script>
+```
+
+### For Direct Icon Loading
+```vue
+<script setup>
+import { useIcon } from '@/composables';
+
+// Load specific icon on mount
+const { loadIcon } = useIcon('send');
+
+// Or load dynamically
+const loadDynamicIcon = (iconName) => {
+    loadIcon(iconName);
+};
+</script>
+```
+
+### For Advanced Icon Management
+```vue
+<script setup>
+import { useIconManager } from '@/composables';
+
+const { loadIcon, loadIcons, watchIcon, preloadCommonIcons } = useIconManager();
+
+// Preload common icons
+preloadCommonIcons(['send', 'close', 'check']);
+
+// Watch reactive icon source
+watchIcon(() => someReactiveIcon.value);
+</script>
+```
+
+## 🔍 Verification
+
+### Build Status: ✅ SUCCESS
+- Chat-client bundle: 263.74 kB
+- No build errors
+- All Vue SFCs compile correctly
+- Zero legacy dependencies
+
+### Modern Architecture: ✅ VERIFIED
+- `useIconManager()` composable ✅ Self-contained
+- `useIcon()` composable ✅ Simple loading
+- `useFormIcon()` composable ✅ Form integration
+- Zero window.iconManager references ✅
+
+### Component Integration: ✅ 100% MODERNIZED
+- All Vue components use modern composables
+- No legacy code remaining
+- Pure Vue 3 Composition API throughout
+
+## 📈 Benefits Achieved
+
+1. **✅ Pure Vue 3 Architecture** - Zero legacy dependencies
+2. **✅ Self-Contained System** - No external file dependencies
+3. **✅ Optimal Performance** - Direct DOM manipulation, no layers
+4. **✅ Modern Developer Experience** - Composition API patterns
+5. **✅ Maintainable Codebase** - Single responsibility composables
+6. **✅ Future-Proof** - Built on Vue 3 best practices
+
+## 🎉 MISSION ACCOMPLISHED!
+
+The icon management system is now **100% MODERNIZED** with:
+- ✅ Zero legacy code
+- ✅ Pure Vue 3 composables
+- ✅ Self-contained architecture
+- ✅ Optimal performance

documentation/TRANSLATION_MANAGEMENT_GUIDE.md

@@ -0,0 +1,446 @@
+# Translation Management System Guide
+
+## 🎯 Overview
+
+The translation management system has been successfully modernized from legacy `window.TranslationClient` to modern Vue 3 composables. This provides:
+
+1. **✅ Modern Vue 3 Composables** - Reactive translation state management
+2. **✅ Better Error Handling** - Comprehensive error states and fallbacks
+3. **✅ Loading States** - Built-in loading indicators for translations
+4. **✅ Batch Translation** - Efficient multiple text translation
+5. **✅ Backward Compatibility** - Existing code continues to work during migration
+
+## 📁 File Structure
+
+```
+eveai_chat_client/static/assets/js/
+├── translation.js.old                   # Legacy TranslationClient (being phased out)
+└── composables/
+    ├── index.js                     # Barrel export for composables
+    └── useTranslation.js            # Vue 3 translation composables
+```
+
+## 🔧 Available Composables
+
+### 1. useTranslation() - Full Featured
+
+The main composable providing complete translation functionality with reactive state management.
+
+```vue
+<script setup>
+import { useTranslation } from '@/composables/useTranslation.js';
+
+const { 
+    translate,
+    translateSafe,
+    translateBatch,
+    isTranslationReady,
+    isTranslating,
+    currentLanguage,
+    lastError
+} = useTranslation();
+
+// Translate with full control
+const result = await translate('Hello world', 'nl', 'en', 'greeting');
+
+// Safe translation with fallback
+const translated = await translateSafe('Hello world', 'nl', {
+    fallbackText: 'Hello world',
+    context: 'greeting'
+});
+
+// Batch translate multiple texts
+const texts = ['Hello', 'World', 'Vue'];
+const translated = await translateBatch(texts, 'nl');
+</script>
+```
+
+### 2. useTranslationClient() - Simplified
+
+Simplified composable for basic translation needs without reactive state management.
+
+```vue
+<script setup>
+import { useTranslationClient } from '@/composables/useTranslation.js';
+
+const { 
+    translate,
+    translateSafe,
+    isTranslationReady,
+    isTranslating,
+    lastError
+} = useTranslationClient();
+
+// Simple translation
+const result = await translateSafe('Hello world', 'nl');
+</script>
+```
+
+### 3. useReactiveTranslation() - Automatic Translation
+
+Composable for reactive text translation that automatically updates when language changes.
+
+```vue
+<script setup>
+import { useReactiveTranslation } from '@/composables/useTranslation.js';
+
+const originalText = 'Hello world';
+const { 
+    translatedText, 
+    isLoading, 
+    updateTranslation 
+} = useReactiveTranslation(originalText, {
+    context: 'greeting',
+    autoTranslate: true
+});
+
+// Manual translation update
+await updateTranslation('nl');
+</script>
+
+<template>
+    <div>
+        <span v-if="isLoading">Translating...</span>
+        <span v-else>{{ translatedText }}</span>
+    </div>
+</template>
+```
+
+## 🔄 Migration Guide
+
+### From window.TranslationClient (Old)
+
+```vue
+<!-- OLD: Using window.TranslationClient -->
+<script>
+export default {
+    async methods: {
+        async translatePlaceholder(language) {
+            if (!window.TranslationClient || typeof window.TranslationClient.translate !== 'function') {
+                console.error('TranslationClient.translate is niet beschikbaar');
+                return;
+            }
+
+            const apiPrefix = window.chatConfig?.apiPrefix || '';
+            const response = await window.TranslationClient.translate(
+                this.originalText,
+                language,
+                null,
+                'chat_input_placeholder',
+                apiPrefix
+            );
+
+            if (response.success) {
+                this.translatedText = response.translated_text;
+            }
+        }
+    }
+}
+</script>
+```
+
+### To Vue 3 Composable (New)
+
+```vue
+<!-- NEW: Using composable -->
+<script setup>
+import { useTranslationClient } from '@/composables';
+
+const { translateSafe, isTranslating } = useTranslationClient();
+
+const translatePlaceholder = async (language) => {
+    const apiPrefix = window.chatConfig?.apiPrefix || '';
+    
+    const translated = await translateSafe(originalText, language, {
+        context: 'chat_input_placeholder',
+        apiPrefix,
+        fallbackText: originalText
+    });
+    
+    translatedText.value = translated;
+};
+</script>
+```
+
+## 📋 Current Usage in Vue Components
+
+### Components Using window.TranslationClient
+
+1. **ChatInput.vue** - Lines 235-243: Placeholder translation
+2. **MessageHistory.vue** - Lines 144-151: Message translation
+
+## ✅ Migration Examples
+
+### ChatInput.vue Migration
+
+**Before (Problematic):**
+```vue
+<script>
+export default {
+    methods: {
+        async translatePlaceholder(language) {
+            if (!window.TranslationClient || typeof window.TranslationClient.translate !== 'function') {
+                console.error('TranslationClient.translate is niet beschikbaar voor placeholder');
+                return;
+            }
+
+            const apiPrefix = window.chatConfig?.apiPrefix || '';
+            const response = await window.TranslationClient.translate(
+                originalText,
+                language,
+                null,
+                'chat_input_placeholder',
+                apiPrefix
+            );
+
+            if (response.success) {
+                this.translatedPlaceholder = response.translated_text;
+            } else {
+                console.error('Vertaling placeholder mislukt:', response.error);
+            }
+        }
+    }
+}
+</script>
+```
+
+**After (Modern Vue 3):**
+```vue
+<script setup>
+import { ref } from 'vue';
+import { useTranslationClient } from '@/composables';
+
+const { translateSafe, isTranslating } = useTranslationClient();
+const translatedPlaceholder = ref('');
+
+const translatePlaceholder = async (language) => {
+    const apiPrefix = window.chatConfig?.apiPrefix || '';
+    
+    const result = await translateSafe(originalText, language, {
+        context: 'chat_input_placeholder',
+        apiPrefix,
+        fallbackText: originalText
+    });
+    
+    translatedPlaceholder.value = result;
+};
+</script>
+```
+
+### MessageHistory.vue Migration
+
+**Before (Problematic):**
+```vue
+<script>
+export default {
+    methods: {
+        async handleLanguageChange(event) {
+            if (!window.TranslationClient || typeof window.TranslationClient.translate !== 'function') {
+                console.error('TranslationClient.translate is niet beschikbaar');
+                return;
+            }
+
+            const response = await window.TranslationClient.translate(
+                firstMessage.originalContent,
+                event.detail.language,
+                null,
+                'chat_message',
+                this.apiPrefix
+            );
+
+            if (response.success) {
+                firstMessage.content = response.translated_text;
+            }
+        }
+    }
+}
+</script>
+```
+
+**After (Modern Vue 3):**
+```vue
+<script setup>
+import { useTranslationClient } from '@/composables';
+
+const { translateSafe } = useTranslationClient();
+
+const handleLanguageChange = async (event) => {
+    const translated = await translateSafe(
+        firstMessage.originalContent,
+        event.detail.language,
+        {
+            context: 'chat_message',
+            apiPrefix: props.apiPrefix,
+            fallbackText: firstMessage.originalContent
+        }
+    );
+    
+    firstMessage.content = translated;
+};
+</script>
+```
+
+## 🚀 Recommended Usage Patterns
+
+### For New Components
+```vue
+<script setup>
+import { useTranslationClient } from '@/composables';
+
+const { translateSafe, isTranslating } = useTranslationClient();
+
+const handleTranslation = async (text, targetLang) => {
+    return await translateSafe(text, targetLang, {
+        context: 'component_specific_context',
+        apiPrefix: window.chatConfig?.apiPrefix || ''
+    });
+};
+</script>
+```
+
+### For Reactive Translation
+```vue
+<script setup>
+import { useReactiveTranslation } from '@/composables';
+
+const originalText = 'Welcome to EveAI';
+const { translatedText, isLoading, updateTranslation } = useReactiveTranslation(originalText);
+
+// Automatically update when language changes
+document.addEventListener('language-changed', (event) => {
+    updateTranslation(event.detail.language);
+});
+</script>
+
+<template>
+    <div>
+        <span v-if="isLoading">🔄 Translating...</span>
+        <span v-else>{{ translatedText }}</span>
+    </div>
+</template>
+```
+
+### For Batch Translation
+```vue
+<script setup>
+import { useTranslation } from '@/composables';
+
+const { translateBatch } = useTranslation();
+
+const translateMultipleTexts = async (texts, targetLang) => {
+    const results = await translateBatch(texts, targetLang, {
+        context: 'batch_translation',
+        apiPrefix: window.chatConfig?.apiPrefix || ''
+    });
+    
+    return results;
+};
+</script>
+```
+
+## 🔍 API Reference
+
+### useTranslation()
+
+**Returns:**
+- `isTranslationReady: Ref<boolean>` - Translation system availability
+- `currentLanguage: ComputedRef<string>` - Current language from chatConfig
+- `isTranslating: Ref<boolean>` - Loading state for translations
+- `lastError: Ref<Error|null>` - Last translation error
+- `translate(text, targetLang, sourceLang?, context?, apiPrefix?)` - Full translation method
+- `translateSafe(text, targetLang, options?)` - Safe translation with fallback
+- `translateBatch(texts, targetLang, options?)` - Batch translation
+- `getCurrentLanguage()` - Get current language
+- `getApiPrefix()` - Get API prefix
+
+### useTranslationClient()
+
+**Returns:**
+- `translate` - Full translation method
+- `translateSafe` - Safe translation with fallback
+- `isTranslationReady` - Translation system availability
+- `isTranslating` - Loading state
+- `lastError` - Last error
+
+### useReactiveTranslation(text, options?)
+
+**Parameters:**
+- `text: string` - Text to translate
+- `options.context?: string` - Translation context
+- `options.sourceLang?: string` - Source language
+- `options.autoTranslate?: boolean` - Auto-translate on language change
+
+**Returns:**
+- `translatedText: Ref<string>` - Translated text
+- `isLoading: Ref<boolean>` - Loading state
+- `updateTranslation(newLanguage?)` - Manual translation update
+
+## 🔧 Configuration
+
+### Translation Options
+
+```javascript
+const options = {
+    sourceLang: 'en',           // Source language (optional)
+    context: 'chat_message',    // Translation context
+    apiPrefix: '/chat-client',  // API prefix for tenant routing
+    fallbackText: 'Fallback'   // Fallback text on error
+};
+```
+
+### Error Handling
+
+```vue
+<script setup>
+import { useTranslation } from '@/composables';
+
+const { translate, lastError, isTranslating } = useTranslation();
+
+const handleTranslation = async () => {
+    try {
+        const result = await translate('Hello', 'nl');
+        console.log('Translation successful:', result);
+    } catch (error) {
+        console.error('Translation failed:', error);
+        // lastError.value will also contain the error
+    }
+};
+</script>
+```
+
+## 📈 Benefits Achieved
+
+1. **✅ Modern Vue 3 Patterns** - Composition API and reactive state
+2. **✅ Better Error Handling** - Comprehensive error states and fallbacks
+3. **✅ Loading States** - Built-in loading indicators
+4. **✅ Type Safety Ready** - Prepared for TypeScript integration
+5. **✅ Batch Operations** - Efficient multiple text translation
+6. **✅ Reactive Translation** - Automatic updates on language changes
+7. **✅ Backward Compatibility** - Gradual migration support
+
+## 🎉 Migration Status
+
+### ✅ Completed
+- Modern Vue 3 composables created
+- Barrel export updated
+- Documentation completed
+- Migration patterns established
+
+### 🔄 In Progress
+- ChatInput.vue migration
+- MessageHistory.vue migration
+
+### 📋 Next Steps
+- Complete component migrations
+- Remove legacy window.TranslationClient
+- Verify all translations work correctly
+
+## 🚀 Future Enhancements
+
+1. **TypeScript Support** - Add proper type definitions
+2. **Caching System** - Cache translated texts for performance
+3. **Offline Support** - Fallback for offline scenarios
+4. **Translation Memory** - Remember previous translations
+5. **Language Detection** - Automatic source language detection
+
+This modern translation system provides a solid foundation for scalable, maintainable translation management in the Vue 3 application!

documentation/document_domain.mermaid

@@ -0,0 +1,138 @@
+erDiagram
+    CATALOG {
+        int id PK
+        string name
+        text description
+        string type
+        string type_version
+        int min_chunk_size
+        int max_chunk_size
+        jsonb user_metadata
+        jsonb system_metadata
+        jsonb configuration
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    PROCESSOR {
+        int id PK
+        string name
+        text description
+        int catalog_id FK
+        string type
+        string sub_file_type
+        boolean active
+        boolean tuning
+        jsonb user_metadata
+        jsonb system_metadata
+        jsonb configuration
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    RETRIEVER {
+        int id PK
+        string name
+        text description
+        int catalog_id FK
+        string type
+        string type_version
+        boolean tuning
+        jsonb user_metadata
+        jsonb system_metadata
+        jsonb configuration
+        jsonb arguments
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    DOCUMENT {
+        int id PK
+        int catalog_id FK
+        string name
+        datetime valid_from
+        datetime valid_to
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    DOCUMENT_VERSION {
+        int id PK
+        int doc_id FK
+        string url
+        string bucket_name
+        string object_name
+        string file_type
+        string sub_file_type
+        float file_size
+        string language
+        text user_context
+        text system_context
+        jsonb user_metadata
+        jsonb system_metadata
+        jsonb catalog_properties
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+        boolean processing
+        datetime processing_started_at
+        datetime processing_finished_at
+        string processing_error
+    }
+
+    EMBEDDING {
+        int id PK
+        string type
+        int doc_vers_id FK
+        boolean active
+        text chunk
+    }
+
+    EMBEDDING_MISTRAL {
+        int id PK,FK
+        vector_1024 embedding
+    }
+
+    EMBEDDING_SMALL_OPENAI {
+        int id PK,FK
+        vector_1536 embedding
+    }
+
+    EMBEDDING_LARGE_OPENAI {
+        int id PK,FK
+        vector_3072 embedding
+    }
+
+    USER {
+        int id PK
+        string user_name
+        string email
+    }
+
+    %% Relationships
+    CATALOG ||--o{ PROCESSOR : "has many"
+    CATALOG ||--o{ RETRIEVER : "has many"
+    CATALOG ||--o{ DOCUMENT : "has many"
+    
+    DOCUMENT ||--o{ DOCUMENT_VERSION : "has many"
+    
+    DOCUMENT_VERSION ||--o{ EMBEDDING : "has many"
+    
+    EMBEDDING ||--o| EMBEDDING_MISTRAL : "inheritance"
+    EMBEDDING ||--o| EMBEDDING_SMALL_OPENAI : "inheritance"
+    EMBEDDING ||--o| EMBEDDING_LARGE_OPENAI : "inheritance"
+    
+    USER ||--o{ CATALOG : "creates/updates"
+    USER ||--o{ PROCESSOR : "creates/updates"
+    USER ||--o{ RETRIEVER : "creates/updates"
+    USER ||--o{ DOCUMENT : "creates/updates"
+    USER ||--o{ DOCUMENT_VERSION : "creates/updates"

documentation/entitlements_domain.mermaid

@@ -0,0 +1,244 @@
+erDiagram
+    BUSINESS_EVENT_LOG {
+        int id PK
+        datetime timestamp
+        string event_type
+        int tenant_id
+        string trace_id
+        string span_id
+        string span_name
+        string parent_span_id
+        int document_version_id
+        float document_version_file_size
+        int specialist_id
+        string specialist_type
+        string specialist_type_version
+        string chat_session_id
+        int interaction_id
+        string environment
+        int llm_metrics_total_tokens
+        int llm_metrics_prompt_tokens
+        int llm_metrics_completion_tokens
+        float llm_metrics_total_time
+        int llm_metrics_nr_of_pages
+        int llm_metrics_call_count
+        string llm_interaction_type
+        text message
+        int license_usage_id FK
+    }
+
+    LICENSE {
+        int id PK
+        int tenant_id FK
+        int tier_id FK
+        date start_date
+        date end_date
+        int nr_of_periods
+        string currency
+        boolean yearly_payment
+        float basic_fee
+        int max_storage_mb
+        float additional_storage_price
+        int additional_storage_bucket
+        int included_embedding_mb
+        decimal additional_embedding_price
+        int additional_embedding_bucket
+        int included_interaction_tokens
+        decimal additional_interaction_token_price
+        int additional_interaction_bucket
+        float overage_embedding
+        float overage_interaction
+        boolean additional_storage_allowed
+        boolean additional_embedding_allowed
+        boolean additional_interaction_allowed
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    LICENSE_TIER {
+        int id PK
+        string name
+        string version
+        date start_date
+        date end_date
+        float basic_fee_d
+        float basic_fee_e
+        int max_storage_mb
+        decimal additional_storage_price_d
+        decimal additional_storage_price_e
+        int additional_storage_bucket
+        int included_embedding_mb
+        decimal additional_embedding_price_d
+        decimal additional_embedding_price_e
+        int additional_embedding_bucket
+        int included_interaction_tokens
+        decimal additional_interaction_token_price_d
+        decimal additional_interaction_token_price_e
+        int additional_interaction_bucket
+        float standard_overage_embedding
+        float standard_overage_interaction
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    PARTNER_SERVICE_LICENSE_TIER {
+        int partner_service_id PK,FK
+        int license_tier_id PK,FK
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    LICENSE_PERIOD {
+        int id PK
+        int license_id FK
+        int tenant_id FK
+        int period_number
+        date period_start
+        date period_end
+        string currency
+        float basic_fee
+        int max_storage_mb
+        float additional_storage_price
+        int additional_storage_bucket
+        int included_embedding_mb
+        decimal additional_embedding_price
+        int additional_embedding_bucket
+        int included_interaction_tokens
+        decimal additional_interaction_token_price
+        int additional_interaction_bucket
+        boolean additional_storage_allowed
+        boolean additional_embedding_allowed
+        boolean additional_interaction_allowed
+        enum status
+        datetime upcoming_at
+        datetime pending_at
+        datetime active_at
+        datetime completed_at
+        datetime invoiced_at
+        datetime closed_at
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    LICENSE_USAGE {
+        int id PK
+        int tenant_id FK
+        float storage_mb_used
+        float embedding_mb_used
+        int embedding_prompt_tokens_used
+        int embedding_completion_tokens_used
+        int embedding_total_tokens_used
+        int interaction_prompt_tokens_used
+        int interaction_completion_tokens_used
+        int interaction_total_tokens_used
+        int license_period_id FK
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    PAYMENT {
+        int id PK
+        int license_period_id FK
+        int tenant_id FK
+        enum payment_type
+        decimal amount
+        string currency
+        text description
+        enum status
+        string external_payment_id
+        string payment_method
+        jsonb provider_data
+        datetime paid_at
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    INVOICE {
+        int id PK
+        int license_period_id FK
+        int payment_id FK
+        int tenant_id FK
+        enum invoice_type
+        string invoice_number
+        date invoice_date
+        date due_date
+        decimal amount
+        string currency
+        decimal tax_amount
+        text description
+        enum status
+        datetime sent_at
+        datetime paid_at
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    LICENSE_CHANGE_LOG {
+        int id PK
+        int license_id FK
+        datetime changed_at
+        string field_name
+        string old_value
+        string new_value
+        text reason
+        int created_by FK
+    }
+
+    TENANT {
+        int id PK
+        string name
+        string currency
+    }
+
+    USER {
+        int id PK
+        string user_name
+        string email
+    }
+
+    PARTNER_SERVICE {
+        int id PK
+        string name
+        string type
+    }
+
+    %% Main business relationships
+    TENANT ||--o{ LICENSE : "has many"
+    LICENSE_TIER ||--o{ LICENSE : "has many"
+    LICENSE ||--o{ LICENSE_PERIOD : "has many"
+    LICENSE_PERIOD ||--|| LICENSE_USAGE : "has one"
+    LICENSE_PERIOD ||--o{ PAYMENT : "has many"
+    LICENSE_PERIOD ||--o{ INVOICE : "has many"
+    
+    %% License management
+    LICENSE ||--o{ LICENSE_CHANGE_LOG : "has many"
+    
+    %% Payment-Invoice relationship
+    PAYMENT ||--o| INVOICE : "can have"
+    
+    %% Partner service licensing
+    PARTNER_SERVICE ||--o{ PARTNER_SERVICE_LICENSE_TIER : "has many"
+    LICENSE_TIER ||--o{ PARTNER_SERVICE_LICENSE_TIER : "has many"
+    
+    %% Event logging
+    LICENSE_USAGE ||--o{ BUSINESS_EVENT_LOG : "has many"
+    
+    %% Tenant relationships
+    TENANT ||--o{ LICENSE_PERIOD : "has many"
+    TENANT ||--o{ LICENSE_USAGE : "has many"
+    TENANT ||--o{ PAYMENT : "has many"
+    TENANT ||--o{ INVOICE : "has many"

documentation/interaction_domain.mermaid

@@ -0,0 +1,211 @@
+erDiagram
+    CHAT_SESSION {
+        int id PK
+        int user_id FK
+        string session_id
+        datetime session_start
+        datetime session_end
+        string timezone
+    }
+
+    SPECIALIST {
+        int id PK
+        string name
+        text description
+        string type
+        string type_version
+        boolean tuning
+        jsonb configuration
+        jsonb arguments
+        boolean active
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    EVE_AI_ASSET {
+        int id PK
+        string name
+        text description
+        string type
+        string type_version
+        string bucket_name
+        string object_name
+        string file_type
+        float file_size
+        jsonb user_metadata
+        jsonb system_metadata
+        jsonb configuration
+        int prompt_tokens
+        int completion_tokens
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+        datetime last_used_at
+    }
+
+    EVE_AI_AGENT {
+        int id PK
+        int specialist_id FK
+        string name
+        text description
+        string type
+        string type_version
+        text role
+        text goal
+        text backstory
+        boolean tuning
+        jsonb configuration
+        jsonb arguments
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    EVE_AI_TASK {
+        int id PK
+        int specialist_id FK
+        string name
+        text description
+        string type
+        string type_version
+        text task_description
+        text expected_output
+        boolean tuning
+        jsonb configuration
+        jsonb arguments
+        jsonb context
+        boolean asynchronous
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    EVE_AI_TOOL {
+        int id PK
+        int specialist_id FK
+        string name
+        text description
+        string type
+        string type_version
+        boolean tuning
+        jsonb configuration
+        jsonb arguments
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    DISPATCHER {
+        int id PK
+        string name
+        text description
+        string type
+        string type_version
+        boolean tuning
+        jsonb configuration
+        jsonb arguments
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    INTERACTION {
+        int id PK
+        int chat_session_id FK
+        int specialist_id FK
+        jsonb specialist_arguments
+        jsonb specialist_results
+        string timezone
+        int appreciation
+        datetime question_at
+        datetime detailed_question_at
+        datetime answer_at
+        string processing_error
+    }
+
+    INTERACTION_EMBEDDING {
+        int interaction_id PK,FK
+        int embedding_id PK,FK
+    }
+
+    SPECIALIST_RETRIEVER {
+        int specialist_id PK,FK
+        int retriever_id PK,FK
+    }
+
+    SPECIALIST_DISPATCHER {
+        int specialist_id PK,FK
+        int dispatcher_id PK,FK
+    }
+
+    SPECIALIST_MAGIC_LINK {
+        int id PK
+        string name
+        text description
+        int specialist_id FK
+        int tenant_make_id FK
+        string magic_link_code
+        datetime valid_from
+        datetime valid_to
+        jsonb specialist_args
+        datetime created_at
+        int created_by FK
+        datetime updated_at
+        int updated_by FK
+    }
+
+    USER {
+        int id PK
+        string user_name
+        string email
+    }
+
+    TENANT_MAKE {
+        int id PK
+        string name
+        text description
+    }
+
+    RETRIEVER {
+        int id PK
+        string name
+        text description
+    }
+
+    EMBEDDING {
+        int id PK
+        string type
+        text chunk
+    }
+
+    %% Main conversation flow
+    USER ||--o{ CHAT_SESSION : "has many"
+    CHAT_SESSION ||--o{ INTERACTION : "has many"
+    SPECIALIST ||--o{ INTERACTION : "processes"
+    
+    %% Specialist composition (EveAI components)
+    SPECIALIST ||--o{ EVE_AI_AGENT : "has many"
+    SPECIALIST ||--o{ EVE_AI_TASK : "has many"
+    SPECIALIST ||--o{ EVE_AI_TOOL : "has many"
+    
+    %% Specialist connections
+    SPECIALIST ||--o{ SPECIALIST_RETRIEVER : "uses retrievers"
+    RETRIEVER ||--o{ SPECIALIST_RETRIEVER : "used by specialists"
+    
+    SPECIALIST ||--o{ SPECIALIST_DISPATCHER : "uses dispatchers"
+    DISPATCHER ||--o{ SPECIALIST_DISPATCHER : "used by specialists"
+    
+    %% Interaction results
+    INTERACTION ||--o{ INTERACTION_EMBEDDING : "references embeddings"
+    EMBEDDING ||--o{ INTERACTION_EMBEDDING : "used in interactions"
+    
+    %% Magic links for specialist access
+    SPECIALIST ||--o{ SPECIALIST_MAGIC_LINK : "has magic links"
+    TENANT_MAKE ||--o{ SPECIALIST_MAGIC_LINK : "branded links"