iatoolkit 0.11.0__py3-none-any.whl → 0.71.2__py3-none-any.whl

iatoolkit/services/dispatcher_service.py

@@ -5,12 +5,12 @@
 
 from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.services.prompt_manager_service import PromptService
+from iatoolkit.services.sql_service import SqlService
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-
+from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.repositories.models import Company, Function
 from iatoolkit.services.excel_service import ExcelService
 from iatoolkit.services.mail_service import MailService
-from iatoolkit.common.session_manager import SessionManager
 from iatoolkit.common.util import Utility
 from injector import inject
 import logging
@@ -20,14 +20,18 @@ import os
 class Dispatcher:
     @inject
     def __init__(self,
+                 config_service: ConfigurationService,
                  prompt_service: PromptService,
                  llmquery_repo: LLMQueryRepo,
                  util: Utility,
+                 sql_service: SqlService,
                  excel_service: ExcelService,
                  mail_service: MailService):
+        self.config_service = config_service
         self.prompt_service = prompt_service
         self.llmquery_repo = llmquery_repo
         self.util = util
+        self.sql_service = sql_service
         self.excel_service = excel_service
         self.mail_service = mail_service
         self.system_functions = _FUNCTION_LIST
@@ -39,6 +43,7 @@ class Dispatcher:
         self.tool_handlers = {
             "iat_generate_excel": self.excel_service.excel_generator,
             "iat_send_email": self.mail_service.send_mail,
+            "iat_sql_query": self.sql_service.exec_sql
         }
 
     @property
@@ -56,17 +61,49 @@ class Dispatcher:
             self._company_instances = self.company_registry.get_all_company_instances()
         return self._company_instances
 
-    def start_execution(self):
+    def load_company_configs(self):
         # initialize the system functions and prompts
         self.setup_iatoolkit_system()
 
-        """Runs the startup logic for all registered companies."""
-        for company in self.company_instances.values():
-            company.register_company()
-            company.start_execution()
+        """Loads the configuration of every company"""
+        for company_name, company_instance in self.company_instances.items():
+            try:
+                # read company configuration from company.yaml
+                self.config_service.load_configuration(company_name, company_instance)
+
+                # register the company databases
+                self._register_company_databases(company_name)
+
+            except Exception as e:
+                logging.error(f"❌ Failed to register configuration for '{company_name}': {e}")
+                continue
 
         return True
 
+    def _register_company_databases(self, company_name: str):
+        """
+        Reads the data_sources config for a company and registers each
+        database with the central SqlService.
+        """
+        logging.info(f"  -> Registering databases for '{company_name}'...")
+        data_sources_config = self.config_service.get_configuration(company_name, 'data_sources')
+
+        if not data_sources_config or not data_sources_config.get('sql'):
+            return
+
+        for db_config in data_sources_config['sql']:
+            db_name = db_config.get('database')
+            db_env_var = db_config.get('connection_string_env')
+
+            # resolve the URI connection string from the environment variable
+            db_uri = os.getenv(db_env_var) if db_env_var else None
+            if not db_uri:
+                logging.error(
+                    f"-> Skipping database registration for '{company_name}' due to missing 'database' name or invalid connection URI.")
+                return
+
+            self.sql_service.register_database(db_name, db_uri)
+
     def setup_iatoolkit_system(self):
         # create system functions
         for function in self.system_functions:
@@ -91,25 +128,22 @@ class Dispatcher:
             )
             i += 1
 
-        # register in the database  every company class
-        for company in self.company_instances.values():
-            company.register_company()
 
-    def dispatch(self, company_name: str, action: str, **kwargs) -> dict:
-        company_key = company_name.lower()
+    def dispatch(self, company_short_name: str, action: str, **kwargs) -> dict:
+        company_key = company_short_name.lower()
 
         if company_key not in self.company_instances:
             available_companies = list(self.company_instances.keys())
             raise IAToolkitException(
                 IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                f"Empresa '{company_name}' no configurada. Empresas disponibles: {available_companies}"
+                f"Empresa '{company_short_name}' no configurada. Empresas disponibles: {available_companies}"
             )
 
         # check if action is a system function
         if action in self.tool_handlers:
             return  self.tool_handlers[action](**kwargs)
 
-        company_instance = self.company_instances[company_name]
+        company_instance = self.company_instances[company_short_name]
         try:
             return company_instance.handle_request(action, **kwargs)
         except IAToolkitException as e:
@@ -121,37 +155,6 @@ class Dispatcher:
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
                                f"Error en function call '{action}': {str(e)}") from e
 
-    def get_company_context(self, company_name: str, **kwargs) -> str:
-        if company_name not in self.company_instances:
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Empresa no configurada: {company_name}")
-
-        company_context = ''
-
-        # read the company context from this list of markdown files,
-        # company brief, credits, operation description, etc.
-        context_dir = os.path.join(os.getcwd(), f'companies/{company_name}/context')
-        context_files = self.util.get_files_by_extension(context_dir, '.md', return_extension=True)
-        for file in context_files:
-            filepath = os.path.join(context_dir, file)
-            company_context += self.util.load_markdown_context(filepath)
-
-        # add the schemas for every table or function call responses
-        schema_dir = os.path.join(os.getcwd(), f'companies/{company_name}/schema')
-        schema_files = self.util.get_files_by_extension(schema_dir, '.yaml', return_extension=True)
-        for file in schema_files:
-            schema_name = file.split('_')[0]
-            filepath = os.path.join(schema_dir, file)
-            company_context += self.util.generate_context_for_schema(schema_name, filepath)
-
-        company_instance = self.company_instances[company_name]
-        try:
-            return company_context + company_instance.get_company_context(**kwargs)
-        except Exception as e:
-            logging.exception(e)
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Error en get_company_context de {company_name}: {str(e)}") from e
-
     def get_company_services(self, company: Company) -> list[dict]:
         # create the syntax with openai response syntax, for the company function list
         tools = []
@@ -171,89 +174,62 @@ class Dispatcher:
             tools.append(ai_tool)
         return tools
 
-    def get_user_info(self, company_name: str, user_identifier: str, is_local_user: bool) -> dict:
-        if company_name not in self.company_instances:
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                                     f"Empresa no configurada: {company_name}")
-
-        raw_user_data = {}
-        if is_local_user:
-            # source 1: local user login into IAToolkit
-            raw_user_data = SessionManager.get('user', {})
-        else:
-            # source 2: external company user
-            company_instance = self.company_instances[company_name]
-            try:
-                raw_user_data = company_instance.get_user_info(user_identifier)
-            except Exception as e:
-                logging.exception(e)
-                raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                                         f"Error en get_user_info de {company_name}: {str(e)}") from e
-
-        # always normalize the data for consistent structure
-        return self._normalize_user_data(raw_user_data, is_local_user)
-
-    def _normalize_user_data(self, raw_data: dict, is_local: bool) -> dict:
-        """
-        Asegura que los datos del usuario siempre tengan una estructura consistente.
-        """
-        # default values
-        normalized_user = {
-            "id": raw_data.get("id", 0),
-            "user_email": raw_data.get("email", ""),
-            "user_fullname": raw_data.get("user_fullname", ""),
-            "company_id": raw_data.get("company_id", 0),
-            "company_name": raw_data.get("company", ""),
-            "company_short_name": raw_data.get("company_short_name", ""),
-            "is_local": is_local,
-            "extras": raw_data.get("extras", {})
-        }
-
-        # get the extras from the raw data, if any
-        extras = raw_data.get("extras", {})
-        if isinstance(extras, dict):
-            normalized_user.update(extras)
-
-        return normalized_user
-
-    def get_metadata_from_filename(self, company_name: str, filename: str) -> dict:
+    def get_user_info(self, company_name: str, user_identifier: str) -> dict:
         if company_name not in self.company_instances:
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Empresa no configurada: {company_name}")
+                                     f"company not configured: {company_name}")
 
+        # source 2: external company user
         company_instance = self.company_instances[company_name]
         try:
-            return company_instance.get_metadata_from_filename(filename)
+            external_user_profile = company_instance.get_user_info(user_identifier)
         except Exception as e:
             logging.exception(e)
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Error en get_metadata_from_filename de {company_name}: {str(e)}") from e
+                                     f"Error in get_user_info: {company_name}: {str(e)}") from e
+
+        return external_user_profile
 
     def get_company_instance(self, company_name: str):
         """Returns the instance for a given company name."""
         return self.company_instances.get(company_name)
 
 
-
 # iatoolkit system prompts
 _SYSTEM_PROMPT = [
-    {'name': 'query_main', 'description':'main prompt de iatoolkit'},
-    {'name': 'format_styles', 'description':'formatos y estilos de salida'},
-    {'name': 'sql_rules', 'description':'instrucciones para generar sql'}
+    {'name': 'query_main', 'description':'iatoolkit main prompt'},
+    {'name': 'format_styles', 'description':'output format styles'},
+    {'name': 'sql_rules', 'description':'instructions  for SQL queries'}
 ]
 
-
-# iatoolkit  function calls
+# iatoolkit  built-in functions (Tools)
 _FUNCTION_LIST = [
     {
-        "name": "iat_generate_excel",
+        "function_name": "iat_sql_query",
+        "description": "Servicio SQL de IAToolkit: debes utilizar este servicio para todas las consultas a base de datos.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "database": {
+                    "type": "string",
+                    "description": "nombre de la base de datos a consultar: `database_name`"
+                },
+                "query": {
+                    "type": "string",
+                    "description": "string con la consulta en sql"
+                },
+            },
+            "required": ["database", "query"]
+            }
+    },
+    {
+        "function_name": "iat_generate_excel",
         "description": "Generador de Excel."
                     "Genera un archivo Excel (.xlsx) a partir de una lista de diccionarios. "
                     "Cada diccionario representa una fila del archivo. "
                     "el archivo se guarda en directorio de descargas."
                     "retorna diccionario con filename, attachment_token (para enviar archivo por mail)"
                     "content_type y download_link",
-        "function_name": "iat_generate_excel",
         "parameters": {
             "type": "object",
             "properties": {
@@ -293,11 +269,10 @@ _FUNCTION_LIST = [
         }
     },
     {
-        'name': 'Envio de mails',
-         'description':  "iatoolkit mail system. "        
+        'function_name': "iat_send_email",
+        'description':  "iatoolkit mail system. "        
             "envia mails cuando un usuario lo solicita."
             "Si no te indican quien envia el correo utiliza la dirección iatoolkit@iatoolkit.com",
-         'function_name': "iat_send_email",
          'parameters': {
             "type": "object",
             "properties": {

iatoolkit/services/document_service.py

@@ -11,10 +11,13 @@ import os
 import pytesseract
 from injector import inject
 from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.services.i18n_service import I18nService
 
 class DocumentService:
     @inject
-    def __init__(self):
+    def __init__(self, i18n_service: I18nService):
+        self.i18n_service = i18n_service
+
         # max number of pages to load
         self.max_doc_pages = int(os.getenv("MAX_DOC_PAGES", "200"))
 
@@ -29,7 +32,7 @@ class DocumentService:
                         file_content = file_content.decode('utf-8')
                     except UnicodeDecodeError:
                         raise IAToolkitException(IAToolkitException.ErrorType.FILE_FORMAT_ERROR,
-                                           "El archivo no es texto o la codificación no es UTF-8")
+                                           self.i18n_service.t('errors.services.no_text_file'))
 
                 return file_content
             elif filename.lower().endswith('.pdf'):

iatoolkit/services/embedding_service.py

@@ -0,0 +1,146 @@
+# iatoolkit/services/embedding_service.py
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+
+import os
+import base64
+import numpy as np
+from threading import Lock
+from huggingface_hub import InferenceClient
+from openai import OpenAI
+from injector import inject
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.repositories.profile_repo import ProfileRepo
+import logging
+
+# Wrapper classes to create a common interface for embedding clients
+class EmbeddingClientWrapper:
+    """Abstract base class for embedding client wrappers."""
+    def __init__(self, client, model: str):
+        self.client = client
+        self.model = model
+
+    def get_embedding(self, text: str) -> list[float]:
+        """Generates and returns an embedding for the given text."""
+        raise NotImplementedError
+
+class HuggingFaceClientWrapper(EmbeddingClientWrapper):
+    def get_embedding(self, text: str) -> list[float]:
+        embedding = self.client.feature_extraction(text)
+        # Ensure the output is a flat list of floats
+        if isinstance(embedding, list) and len(embedding) > 0 and isinstance(embedding[0], list):
+            return embedding[0]
+        return embedding
+
+class OpenAIClientWrapper(EmbeddingClientWrapper):
+    def get_embedding(self, text: str) -> list[float]:
+        # The OpenAI API expects the input text to be clean
+        text = text.replace("\n", " ")
+        response = self.client.embeddings.create(input=[text], model=self.model)
+        return response.data[0].embedding
+
+# Factory and Service classes
+class EmbeddingClientFactory:
+    """
+    Manages the lifecycle of embedding client wrappers for different companies.
+    It ensures that only one client wrapper is created per company, and it is thread-safe.
+    """
+    @inject
+    def __init__(self, config_service: ConfigurationService):
+        self.config_service = config_service
+        self._clients = {}  # Cache for storing initialized client wrappers
+        self._lock = Lock()
+
+    def get_client(self, company_short_name: str) -> EmbeddingClientWrapper:
+        """
+        Retrieves a configured embedding client wrapper for a specific company.
+        If the client is not in the cache, it creates and stores it.
+        """
+        if company_short_name in self._clients:
+            return self._clients[company_short_name]
+
+        with self._lock:
+            if company_short_name in self._clients:
+                return self._clients[company_short_name]
+
+            embedding_config = self.config_service.get_configuration(company_short_name, 'embedding_provider')
+            if not embedding_config:
+                raise ValueError(f"Embedding provider not configured for company '{company_short_name}'.")
+
+            provider = embedding_config.get('provider')
+            if not provider:
+                raise ValueError(f"Embedding provider not configured for company '{company_short_name}'.")
+            model = embedding_config.get('model')
+
+            api_key_name = embedding_config.get('api_key_name')
+            api_key = os.getenv(api_key_name)
+            if not api_key:
+                raise ValueError(f"Environment variable '{api_key_name}' is not set.")
+
+            # Logic to handle multiple providers
+            wrapper = None
+            if provider == 'huggingface':
+                if not model:
+                    model='sentence-transformers/all-MiniLM-L6-v2'
+                client = InferenceClient(model=model, token=api_key)
+                wrapper = HuggingFaceClientWrapper(client, model)
+            elif provider == 'openai':
+                client = OpenAI(api_key=api_key)
+                if not model:
+                    model='text-embedding-ada-002'
+                wrapper = OpenAIClientWrapper(client, model)
+            else:
+                raise NotImplementedError(f"Embedding provider '{provider}' is not implemented.")
+
+            logging.info(f"Embedding client for '{company_short_name}' created with model: {model} via {provider}")
+            self._clients[company_short_name] = wrapper
+            return wrapper
+
+class EmbeddingService:
+    """
+    A stateless service for generating text embeddings.
+    It relies on the EmbeddingClientFactory to get the correct,
+    company-specific embedding client on demand.
+    """
+    @inject
+    def __init__(self,
+                 client_factory: EmbeddingClientFactory,
+                 profile_repo: ProfileRepo,
+                 i18n_service: I18nService):
+        self.client_factory = client_factory
+        self.i18n_service = i18n_service
+        self.profile_repo = profile_repo
+
+
+    def embed_text(self, company_short_name: str, text: str, to_base64: bool = False) -> list[float] | str:
+        """
+        Generates the embedding for a given text using the appropriate company model.
+        """
+        try:
+            company = self.profile_repo.get_company_by_short_name(company_short_name)
+            if not company:
+                raise ValueError(self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name))
+
+            # 1. Get the correct client wrapper from the factory
+            client_wrapper = self.client_factory.get_client(company_short_name)
+
+            # 2. Use the wrapper's common interface to get the embedding
+            embedding = client_wrapper.get_embedding(text)
+
+            # 3. Process the result
+            if to_base64:
+                return base64.b64encode(np.array(embedding, dtype=np.float32).tobytes()).decode('utf-8')
+
+            return embedding
+        except Exception as e:
+            logging.error(f"Error generating embedding for text: {text[:80]}... - {e}")
+            raise
+
+    def get_model_name(self, company_short_name: str) -> str:
+        """
+        Helper method to get the model name for a specific company.
+        """
+        # Get the wrapper and return the model name from it
+        client_wrapper = self.client_factory.get_client(company_short_name)
+        return client_wrapper.model

iatoolkit/services/excel_service.py

@@ -8,6 +8,7 @@ import pandas as pd
 from uuid import uuid4
 from pathlib import Path
 from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.services.i18n_service import I18nService
 from injector import inject
 import os
 import logging
@@ -18,35 +19,38 @@ EXCEL_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 
 class ExcelService:
     @inject
-    def __init__(self,util: Utility):
+    def __init__(self,
+                 util: Utility,
+                 i18n_service: I18nService):
         self.util = util
+        self.i18n_service = i18n_service
 
     def excel_generator(self, **kwargs) -> str:
         """
-                Genera un Excel a partir de una lista de diccionarios.
-
-                Parámetros esperados en kwargs:
-                  - filename: str (nombre lógico a mostrar, ej. "reporte_clientes.xlsx") [obligatorio]
-                  - data: list[dict] (filas del excel) [obligatorio]
-                  - sheet_name: str = "hoja 1"
-
-                Retorna:
-                     {
-                        "filename": "reporte.xlsx",
-                        "attachment_token": "8b7f8a66-...-c1c3.xlsx",
-                        "content_type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                        "download_link": "/download/8b7f8a66-...-c1c3.xlsx"
-                        }
-                """
+        Genera un Excel a partir de una lista de diccionarios.
+
+        Parámetros esperados en kwargs:
+          - filename: str (nombre lógico a mostrar, ej. "reporte_clientes.xlsx") [obligatorio]
+          - data: list[dict] (filas del excel) [obligatorio]
+          - sheet_name: str = "hoja 1"
+
+        Retorna:
+             {
+                "filename": "reporte.xlsx",
+                "attachment_token": "8b7f8a66-...-c1c3.xlsx",
+                "content_type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                "download_link": "/download/8b7f8a66-...-c1c3.xlsx"
+                }
+        """
         try:
             # get the parameters
             fname = kwargs.get('filename')
             if not fname:
-                return 'falta el nombre del archivo de salida'
+                return self.i18n_service.t('errors.services.no_output_file')
 
             data = kwargs.get('data')
             if not data or not isinstance(data, list):
-                return 'faltan los datos  o no es una lista de diccionarios'
+                return self.i18n_service.t('errors.services.no_data_for_excel')
 
             sheet_name = kwargs.get('sheet_name', 'hoja 1')
 
@@ -58,7 +62,7 @@ class ExcelService:
 
             # 4. check that download directory is configured
             if 'IATOOLKIT_DOWNLOAD_DIR' not in current_app.config:
-                return 'no esta configurado el directorio temporal para guardar excels'
+                return self.i18n_service.t('errors.services.no_download_directory')
 
             download_dir = current_app.config['IATOOLKIT_DOWNLOAD_DIR']
             filepath = Path(download_dir) / token
@@ -77,28 +81,28 @@ class ExcelService:
 
         except Exception as e:
             raise IAToolkitException(IAToolkitException.ErrorType.CALL_ERROR,
-                               'error generating excel file') from e
+                               self.i18n_service.t('errors.services.cannot_create_excel')) from e
 
     def validate_file_access(self, filename):
         try:
             if not filename:
-                return jsonify({"error": "Nombre de archivo inválido"})
+                return jsonify({"error": self.i18n_service.t('errors.services.invalid_filename')})
             # Prevent path traversal attacks
             if '..' in filename or filename.startswith('/') or '\\' in filename:
-                return jsonify({"error": "Nombre de archivo inválido"})
+                return jsonify({"error": self.i18n_service.t('errors.services.invalid_filename')})
 
             temp_dir = os.path.join(current_app.root_path, 'static', 'temp')
             file_path = os.path.join(temp_dir, filename)
 
             if not os.path.exists(file_path):
-                return jsonify({"error": "Archivo no encontrado"})
+                return jsonify({"error": self.i18n_service.t('errors.services.file_not_exist')})
 
             if not os.path.isfile(file_path):
-                return jsonify({"error": "La ruta no corresponde a un archivo"})
+                return jsonify({"error": self.i18n_service.t('errors.services.path_is_not_a_file')})
 
             return None
 
         except Exception as e:
-            error_msg = f"Error validando acceso al archivo {filename}: {str(e)}"
+            error_msg = f"File validation error {filename}: {str(e)}"
             logging.error(error_msg)
-            return jsonify({"error": "Error validando archivo"})
+            return jsonify({"error": self.i18n_service.t('errors.services.file_validation_error')})

iatoolkit/services/file_processor_service.py

@@ -52,27 +52,19 @@ class FileProcessor:
                  logger: Optional[logging.Logger] = None):
         self.connector = connector
         self.config = config
-        self.logger = logger or self._setup_logger()
         self.processed_files = 0
 
-    def _setup_logger(self):
-        logging.basicConfig(
-            filename=self.config.log_file,
-            level=logging.INFO,
-            format='%(asctime)s - %(levelname)s - %(message)s'
-        )
-        return logging.getLogger(__name__)
 
     def process_files(self):
         # Fetches files from the connector, filters them, and processes them.
         try:
             files = self.connector.list_files()
         except Exception as e:
-            self.logger.error(f"Error fetching files: {e}")
+            logging.error(f"Error fetching files: {e}")
             return False
 
         if self.config.echo:
-            print(f'cargando un total de {len(files)} archivos')
+            print(f'loading {len(files)} files')
 
         for file_info in files:
             file_path = file_info['path']
@@ -95,10 +87,10 @@ class FileProcessor:
                                      context=self.config.context)
                 self.processed_files += 1
 
-                self.logger.info(f"Successfully processed file: {file_path}")
+                logging.info(f"Successfully processed file: {file_path}")
 
             except Exception as e:
-                self.logger.error(f"Error processing {file_path}: {e}")
+                logging.error(f"Error processing {file_path}: {e}")
                 if not self.config.continue_on_error:
                     raise e
 

iatoolkit/services/history_service.py

@@ -5,42 +5,33 @@
 
 from injector import inject
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-
 from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.common.util import Utility
+from iatoolkit.services.i18n_service import I18nService
 
 
 class HistoryService:
     @inject
     def __init__(self, llm_query_repo: LLMQueryRepo,
                  profile_repo: ProfileRepo,
-                 util: Utility):
+                 i18n_service: I18nService):
         self.llm_query_repo = llm_query_repo
         self.profile_repo = profile_repo
-        self.util = util
+        self.i18n_service = i18n_service
 
     def get_history(self,
                      company_short_name: str,
-                     external_user_id: str = None,
-                     local_user_id: int = 0) -> dict:
+                     user_identifier: str) -> dict:
         try:
-            user_identifier, _ = self.util.resolve_user_identifier(external_user_id, local_user_id)
-            if not user_identifier:
-                return {'error': "No se pudo resolver el identificador del usuario"}
-
-            # validate company
             company = self.profile_repo.get_company_by_short_name(company_short_name)
             if not company:
-                return {'error': f'No existe la empresa: {company_short_name}'}
+                return {"error": self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
             history = self.llm_query_repo.get_history(company, user_identifier)
-
             if not history:
-                return {'message': 'Historial vacio actualmente', 'history': []}
+                return {'message': 'empty history', 'history': []}
 
             history_list = [query.to_dict() for query in history]
-
-            return {'message': 'Historial obtenido correctamente', 'history': history_list}
+            return {'message': 'history loaded ok', 'history': history_list}
 
         except Exception as e:
             return {'error': str(e)}