iatoolkit 0.91.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

iatoolkit/infra/llm_proxy.py

@@ -3,165 +3,266 @@
 #
 # IAToolkit is open source software.
 
-from typing import Dict, List, Any
-from abc import ABC, abstractmethod
-from iatoolkit.common.util import Utility
-from iatoolkit.infra.llm_response import LLMResponse
+
 from iatoolkit.services.configuration_service import ConfigurationService
-from iatoolkit.infra.openai_adapter import OpenAIAdapter
-from iatoolkit.infra.gemini_adapter import GeminiAdapter
+from iatoolkit.infra.llm_providers.openai_adapter import OpenAIAdapter
+from iatoolkit.infra.llm_providers.gemini_adapter import GeminiAdapter
+from iatoolkit.infra.llm_providers.deepseek_adapter import DeepseekAdapter
+# from iatoolkit.infra.llm_providers.anthropic_adapter import AnthropicAdapter
 from iatoolkit.common.exceptions import IAToolkitException
-from iatoolkit.repositories.models import Company
-from openai import OpenAI
-import google.generativeai as genai
+from iatoolkit.common.util import Utility
+from iatoolkit.infra.llm_response import LLMResponse
+from iatoolkit.common.model_registry import ModelRegistry
+
+from openai import OpenAI         # For OpenAI and xAI (OpenAI-compatible)
+# from anthropic import Anthropic  # For Claude (Anthropic)
+
+from typing import Dict, List, Any, Tuple
 import os
 import threading
-from enum import Enum
 from injector import inject
 
 
-class LLMProvider(Enum):
-    OPENAI = "openai"
-    GEMINI = "gemini"
-
-
-class LLMAdapter(ABC):
-    """common interface for LLM adapters"""
-
-    @abstractmethod
-    def create_response(self, *args, **kwargs) -> LLMResponse:
-        pass
-
-
 class LLMProxy:
     """
-    Proxy que enruta las llamadas al adaptador correcto y gestiona la creación
-    de los clientes de los proveedores de LLM.
+    Proxy for routing calls to the correct LLM adapter and managing the creation of LLM clients.
     """
-    _clients_cache = {}
+
+    # Class-level cache for low-level clients (per provider + API key)
+    _clients_cache: Dict[Tuple[str, str], Any] = {}
     _clients_cache_lock = threading.Lock()
 
+    # Provider identifiers
+    PROVIDER_OPENAI = "openai"
+    PROVIDER_GEMINI = "gemini"
+    PROVIDER_DEEPSEEK = "deepseek"
+    PROVIDER_XAI = "xai"
+    PROVIDER_ANTHROPIC = "anthropic"
+
     @inject
-    def __init__(self, util: Utility,
-                 configuration_service: ConfigurationService,
-                 openai_client = None,
-                 gemini_client = None):
+    def __init__(
+        self,
+        util: Utility,
+        configuration_service: ConfigurationService,
+        model_registry: ModelRegistry,
+    ):
         """
-        Inicializa una instancia del proxy. Puede ser una instancia "base" (fábrica)
-        o una instancia de "trabajo" con clientes configurados.
+        Init a new instance of the proxy. It can be a base factory or a working instance with configured clients.
+        Pre-built clients can be injected for tests or special environments.
         """
         self.util = util
         self.configuration_service = configuration_service
-        self.openai_adapter = OpenAIAdapter(openai_client) if openai_client else None
-        self.gemini_adapter = GeminiAdapter(gemini_client) if gemini_client else None
+        self.model_registry = model_registry
+
+        # adapter cache por provider
+        self.adapters: Dict[str, Any] = {}
+
+    # -------------------------------------------------------------------------
+    # Public API
+    # -------------------------------------------------------------------------
+
+    def create_response(self, company_short_name: str, model: str, input: List[Dict], **kwargs) -> LLMResponse:
+        """
+        Route the call to the correct adapter based on the model name.
+        This method is the single entry point used by the rest of the application.
+        """
+        if not company_short_name:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                "company_short_name is required in kwargs to resolve LLM credentials."
+            )
+
+        # Determine the provider based on the model name
+        provider = self._resolve_provider_from_model(model)
+
+        adapter = self._get_or_create_adapter(
+            provider=provider,
+            company_short_name=company_short_name,
+        )
+
+        # Delegate to the adapter (OpenAI, Gemini, DeepSeek, xAI, Anthropic, etc.)
+        return adapter.create_response(model=model, input=input, **kwargs)
+
+    # -------------------------------------------------------------------------
+    # Provider resolution
+    # -------------------------------------------------------------------------
+
+    def _resolve_provider_from_model(self, model: str) -> str:
+        """
+        Determine which provider must be used for a given model name.
+        This uses Utility helper methods, so you can keep all naming logic in one place.
+        """
+        provider_key = self.model_registry.get_provider(model)
+
+        if provider_key == "openai":
+            return self.PROVIDER_OPENAI
+        if provider_key == "gemini":
+            return self.PROVIDER_GEMINI
+        if provider_key == "deepseek":
+            return self.PROVIDER_DEEPSEEK
+        if provider_key == "xai":
+            return self.PROVIDER_XAI
+        if provider_key == "anthropic":
+            return self.PROVIDER_ANTHROPIC
+
+        raise IAToolkitException(
+            IAToolkitException.ErrorType.MODEL,
+            f"Unknown or unsupported model: {model}"
+        )
+
+    # -------------------------------------------------------------------------
+    # Adapter management
+    # -------------------------------------------------------------------------
+
+    def _get_or_create_adapter(self, provider: str, company_short_name: str) -> Any:
+        """
+        Return an adapter instance for the given provider.
+        If none exists yet, create it using a cached or new low-level client.
+        """
+        # If already created, just return it
+        if provider in self.adapters and self.adapters[provider] is not None:
+            return self.adapters[provider]
+
+        # Otherwise, create a low-level client from configuration
+        api_key = self._get_api_key_from_config(company_short_name, provider)
+        client = self._get_or_create_client(provider, api_key)
+
+        # Wrap client with the correct adapter
+        if provider == self.PROVIDER_OPENAI:
+            adapter = OpenAIAdapter(client)
+        elif provider == self.PROVIDER_GEMINI:
+            adapter = GeminiAdapter(client)
+        elif provider == self.PROVIDER_DEEPSEEK:
+            adapter = DeepseekAdapter(client)
+        else:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.MODEL,
+                f"Provider not supported in _get_or_create_adapter: {provider}"
+            )
+
+        '''
+        elif provider == self.PROVIDER_XAI:
+            adapter = XAIAdapter(client)
+        elif provider == self.PROVIDER_ANTHROPIC:
+            adapter = AnthropicAdapter(client)
+        '''
+        self.adapters[provider] = adapter
+        return adapter
+
+    # -------------------------------------------------------------------------
+    # Client cache
+    # -------------------------------------------------------------------------
 
-    def create_for_company(self, company: Company) -> 'LLMProxy':
+    def _get_or_create_client(self, provider: str, api_key: str) -> Any:
         """
-        Crea y configura una nueva instancia de LLMProxy para una empresa específica.
+        Return a low-level client for the given provider and API key.
+        Uses a class-level cache to avoid recreating clients.
         """
-        try:
-            openai_client = self._get_llm_connection(company, LLMProvider.OPENAI)
-        except IAToolkitException:
-            openai_client = None
+        cache_key = (provider, api_key or "")
 
-        try:
-            gemini_client = self._get_llm_connection(company, LLMProvider.GEMINI)
-        except IAToolkitException:
-            gemini_client = None
+        with self._clients_cache_lock:
+            if cache_key in self._clients_cache:
+                return self._clients_cache[cache_key]
 
-        if not openai_client and not gemini_client:
+            client = self._create_client_for_provider(provider, api_key)
+            self._clients_cache[cache_key] = client
+            return client
+
+    def _create_client_for_provider(self, provider: str, api_key: str) -> Any:
+        """
+        Actually create the low-level client for a provider.
+        This is the only place where provider-specific client construction lives.
+        """
+        if provider == self.PROVIDER_OPENAI:
+            # Standard OpenAI client for GPT models
+            return OpenAI(api_key=api_key)
+
+        if provider == self.PROVIDER_XAI:
+            # xAI Grok is OpenAI-compatible; we can use the OpenAI client with a different base_url.
+            return OpenAI(
+                api_key=api_key,
+                base_url="https://api.x.ai/v1",
+            )
+
+        if provider == self.PROVIDER_DEEPSEEK:
+            # Example: if you use the official deepseek client or OpenAI-compatible wrapper
+            # return DeepSeekAPI(api_key=api_key)
+
+            # We use OpenAI client with a DeepSeek base_url:
+            return OpenAI(
+                api_key=api_key,
+                base_url="https://api.deepseek.com",
+            )
+
+        if provider == self.PROVIDER_GEMINI:
+            # Example placeholder: you may already have a Gemini client factory elsewhere.
+            # Here you could create and configure the Gemini client (e.g. google.generativeai).
+            #
+            import google.generativeai as genai
+
+            genai.configure(api_key=api_key)
+            return genai
+        if provider == self.PROVIDER_ANTHROPIC:
+            # Example using Anthropic official client:
+            #
+            # from anthropic import Anthropic
+            # return Anthropic(api_key=api_key)
             raise IAToolkitException(
                 IAToolkitException.ErrorType.API_KEY,
-                f"La empresa '{company.name}' no tiene configuradas API keys para ningún proveedor LLM."
+                "Anthropic client creation must be implemented in _create_client_for_provider."
             )
 
-        # Devuelve una NUEVA instancia con los clientes configurados
-        return LLMProxy(
-                    util=self.util,
-                    configuration_service=self.configuration_service,
-                    openai_client=openai_client,
-                    gemini_client=gemini_client)
-
-    def create_response(self, model: str, input: List[Dict], **kwargs) -> LLMResponse:
-        """Enruta la llamada al adaptador correcto basado en el modelo."""
-        # Se asume que esta instancia ya tiene los clientes configurados por `create_for_company`
-        if self.util.is_openai_model(model):
-            if not self.openai_adapter:
-                raise IAToolkitException(IAToolkitException.ErrorType.API_KEY,
-                                   f"No se configuró cliente OpenAI, pero se solicitó modelo OpenAI: {model}")
-            return self.openai_adapter.create_response(model=model, input=input, **kwargs)
-        elif self.util.is_gemini_model(model):
-            if not self.gemini_adapter:
-                raise IAToolkitException(IAToolkitException.ErrorType.API_KEY,
-                                   f"No se configuró cliente Gemini, pero se solicitó modelo Gemini: {model}")
-            return self.gemini_adapter.create_response(model=model, input=input, **kwargs)
-        else:
-            raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, f"Modelo no soportado: {model}")
-
-    def _get_llm_connection(self, company: Company, provider: LLMProvider) -> Any:
-        """Obtiene una conexión de cliente para un proveedor, usando un caché para reutilizarla."""
-        cache_key = f"{company.short_name}_{provider.value}"
-        client = LLMProxy._clients_cache.get(cache_key)
-
-        if not client:
-            with LLMProxy._clients_cache_lock:
-                client = LLMProxy._clients_cache.get(cache_key)
-                if not client:
-                    if provider == LLMProvider.OPENAI:
-                        client = self._create_openai_client(company)
-                    elif provider == LLMProvider.GEMINI:
-                        client = self._create_gemini_client(company)
-                    else:
-                        raise IAToolkitException(f"provider not supported: {provider.value}")
-
-                    if client:
-                        LLMProxy._clients_cache[cache_key] = client
-
-        if not client:
-            raise IAToolkitException(IAToolkitException.ErrorType.API_KEY, f"No se pudo crear el cliente para {provider.value}")
-
-        return client
-
-    def _create_openai_client(self, company: Company) -> OpenAI:
-        """Crea un cliente de OpenAI con la API key."""
-        decrypted_api_key = ''
-        llm_config = self.configuration_service.get_configuration(company.short_name, 'llm')
-
-        # Try to get API key name from config first
-        if llm_config and llm_config.get('api-key'):
-            api_key_env_var = llm_config['api-key']
-            decrypted_api_key = os.getenv(api_key_env_var, '')
-        else:
-            # Fallback to old logic
-            if company.openai_api_key:
-                decrypted_api_key = self.util.decrypt_key(company.openai_api_key)
-            else:
-                decrypted_api_key = os.getenv("OPENAI_API_KEY", '')
-
-        if not decrypted_api_key:
-            raise IAToolkitException(IAToolkitException.ErrorType.API_KEY,
-                                     f"La empresa '{company.name}' no tiene API key de OpenAI.")
-        return OpenAI(api_key=decrypted_api_key)
-
-    def _create_gemini_client(self, company: Company) -> Any:
-        """Configura y devuelve el cliente de Gemini."""
-
-        decrypted_api_key = ''
-        llm_config = self.configuration_service.get_configuration(company.short_name, 'llm')
-
-        # Try to get API key name from config first
-        if llm_config and llm_config.get('api-key'):
-            api_key_env_var = llm_config['api-key']
-            decrypted_api_key = os.getenv(api_key_env_var, '')
-        else:
-            # Fallback to old logic
-            if company.gemini_api_key:
-                decrypted_api_key = self.util.decrypt_key(company.gemini_api_key)
-            else:
-                decrypted_api_key = os.getenv("GEMINI_API_KEY", '')
+        raise IAToolkitException(
+            IAToolkitException.ErrorType.MODEL,
+            f"Provider not supported in _create_client_for_provider: {provider}"
+        )
 
-        if not decrypted_api_key:
-            return None
-        genai.configure(api_key=decrypted_api_key)
-        return genai
+    # -------------------------------------------------------------------------
+    # Configuration helpers
+    # -------------------------------------------------------------------------
+    def _get_api_key_from_config(self, company_short_name: str, provider: str) -> str:
+        """
+        Read the LLM API key from company configuration and environment variables.
+
+        Resolución de prioridad:
+        1. llm.provider_api_keys[provider] -> env var específica por proveedor.
+        2. llm.api-key                      -> env var global (compatibilidad hacia atrás).
+        """
+        llm_config = self.configuration_service.get_configuration(company_short_name, "llm")
+
+        if not llm_config:
+            # Mantener compatibilidad con los tests: el mensaje debe indicar
+            # que no hay API key configurada.
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                f"Company '{company_short_name}' doesn't have an API key configured."
+            )
+
+        provider_keys = llm_config.get("provider_api_keys") or {}
+        env_var_name = None
+
+        # 1) Intentar api-key específica por proveedor (si existe el bloque provider_api_keys)
+        if provider_keys and isinstance(provider_keys, dict):
+            env_var_name = provider_keys.get(provider)
+
+        # 2) Fallback: usar api-key global si no hay específica
+        if not env_var_name and llm_config.get("api-key"):
+            env_var_name = llm_config["api-key"]
+
+        if not env_var_name:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                f"Company '{company_short_name}' doesn't have an API key configured "
+                f"for provider '{provider}'."
+            )
+
+        api_key_value = os.getenv(env_var_name, "")
+
+        if not api_key_value:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                f"Environment variable '{env_var_name}' for company '{company_short_name}' "
+                f"and provider '{provider}' is not set or is empty."
+            )
 
+        return api_key_value

iatoolkit/infra/llm_response.py

@@ -32,9 +32,14 @@ class LLMResponse:
     output_text: str
     output: List[ToolCall]  # lista de tool calls
     usage: Usage
+    reasoning_content: str = None # campo opcional para Chain of Thought
+
 
     def __post_init__(self):
         """Asegura que output sea una lista"""
         if self.output is None:
             self.output = []
 
+        if self.reasoning_content is None:
+            self.reasoning_content = ""
+

iatoolkit/locales/en.yaml

@@ -46,6 +46,112 @@ ui:
     prompts_available: "Available prompts"
     init_context: "Initializing the context ..."
 
+  admin:
+    workspace: "Workspace"
+    configuration: "Configuration"
+    company_config: "Company Configuration (company.yaml)"
+    prompts: "Prompts"
+    prompts_description: "System Prompts"
+    knowledge: "Knowledge Base"
+    knowledge_rag: "RAG (Vector)"
+    knowledge_static: "Static Context"
+    schemas: "Schemas"
+    schemas_description: "Data Definitions (YAML)"
+    context_description: "Static Markdown"
+    administration: "Administration"
+    monitoring: "Monitoring"
+    teams: "Team"
+    billing: "Billing"
+    company: "Company"
+    context: "Context"
+    files: "Files"
+    select_file: "Select a file for editing"
+    select_category: "Select a category"
+    editing: "Editing"
+    no_file_selected: "No file selected"
+    new: "New"
+    confirm: "Confirm"
+    cancel: "Cancel"
+    new_file: "New file"
+    delete_file: "Delete file"
+    rename_file: "Rename file"
+    saved_ok: "File saved successfully"
+    save_file: "Save"
+    credentials: "Email and password required for login."
+    deleted_ok: "Deleted successfully"
+    user_manager: "User management"
+    admin_page_title: "Admin access"
+    load_configuration: "Save configuration"
+    goto_chat: "Go to chat"
+    logout: "Close session"
+    error_loading: "Error loading file content"
+    loading: "Loading..."
+
+  db_explorer:
+    data_explorer: "Data Explorer"
+    database_connection: "Database Connection"
+    tables: "Tables"
+    data_explorer_description: "Explore your database tables ."
+    select_database: "Please select a database above to view its tables."
+    not_table_selected: "No table selected"
+    view_yaml: "View YAML"
+    save_schema: "Save schema"
+    select_table: "Select a table from the left panel"
+    table_semantics: "Table Semantics"
+    table_description: "Description (AI Context)"
+    table_placeholder: "Describe what data this table contains (e.g., 'Active and inactive customer records including billing addresses')..."
+    column_metadata: "Column Metadata"
+    auto_detect: "Auto-detected from DB"
+    meta_column: "Column"
+    meta_type: "Type"
+    meta_description: "Description"
+    meta_synonyms: "Synonyms"
+    pii_sesitive: "PII Sensitive"
+
+  config:
+    editor_description: "IAToolkit configuration file"
+    title: "Configuration Editor"
+    sections: "Sections"
+    refresh: "Refresh"
+    validate: "Validate"
+    select_section: "Select a section from the left panel"
+    no_section_selected: "No section selected"
+    view_yaml: "View YAML"
+
+
+  rag:
+    ingestion: "Ingestion"
+    ingestion_description: "Ingest documents into the knowledge base."
+    workbench: "Workbench"
+    documents: "Documents"
+    retrieval_lab: "Retrieval Lab."
+    retrieval_description: "Test semantic search and context retrieval."
+    query_placeholder: "Enter a question to query the knowledge base..."
+    search_button: "Search"
+    filter: "Filter"
+    search_results_title: "Ready to test"
+    search_results_description: "Results will appear here"
+    filename: "Filename"
+    filename_placeholder: "Contains..."
+    user: "User"
+    status: "Status"
+    all_status: "All statuses"
+    status_active: "Active"
+    status_pending: "Pending"
+    status_processing: "Processing"
+    status_failed: "Failed"
+    created_at: "Created"
+    date_range: "Date range"
+    delete_confirmation: "Delete File?"
+    delete_message: "This action cannot be undone. The file will be permanently removed."
+    delete_button: "Delete"
+    delete_cancel: "Cancel"
+    target_collection: "Target collection"
+    select_collection_placeholder: "Select a collection"
+    collection_required: "Collection is required"
+    collection: "Collection"
+    all_collections: "All collections"
+
   tooltips:
     history: "History of my queries"
     reload_context: "Force Context Reload"
@@ -53,6 +159,7 @@ ui:
     usage_guide: "Usage Guide"
     onboarding: "How to ask better questions"
     logout: "Log out"
+    preferences: "Preferences"
     use_prompt_assistant: "Use Prompt Assistant"
     attach_files: "Attach files"
     view_attached_files: "View attached files"
@@ -87,12 +194,14 @@ errors:
     session_creation_failed: "Could not create user session."
     authentication_required: "Authentication required. No session cookie or API Key provided."
     invalid_api_key: "Invalid or inactive API Key."
+    api_key_name_required: "api_key_name parameter is required."
+
     no_user_identifier_api: "No user_identifier provided for API call."
+    no_company_permissions: "Do not have permissions to admin this company."
   templates:
     company_not_found: "Company not found."
     home_template_not_found: "The home page template for the company '{company_short_name}' is not configured."
     template_not_found: "Template not found: '{template_name}'."
-
     processing_error: "An error occurred while processing the custom home page template: {error}"
   general:
     unexpected_error: "An unexpected error has occurred. Please contact support."
@@ -135,7 +244,6 @@ errors:
     cannot_read_excel: "Cannot read Excel file"
     cannot_read_csv: "Cannot read CSV file"
 
-
 api_responses:
   context_reloaded_success: "The context has been successfully reloaded."
 
@@ -144,6 +252,19 @@ services:
   start_query: "Hello, what can I help you with today?"
   mail_change_password: "mail sent for password change"
 
+rag:
+  ingestion:
+    duplicate: "Document '{filename}' already exists for company '{company_short_name}'. Skipping ingestion."
+    failed: "Failed to ingest document: {error}"
+    processing_failed: "Processing failed: {error}"
+    empty_text: "Extracted text is empty."
+  search:
+    query_required: "Query is required."
+    company_not_found: "Company '{company_short_name}' not found."
+  management:
+    delete_success: "Document deleted."
+    not_found: "Document not found."
+    action_not_found: "Action '{action}' not found."
 
 flash_messages:
   password_changed_success: "Your password has been successfully reset. You can now log in."
@@ -172,4 +293,39 @@ js_messages:
   reload_init: "init reloading context in background..."
   no_history_found: "No query history found."
   example: "Example:"
+  show_reasoning: "Show reasoning"
+  unsaved: "Modified (unsaved)"
+  select_file: "Select a file from the list"
+  no_file_selected: "No file selected"
+  select_company: "Select company"
+  delete_ok: "File deleted successfully"
+  delete_failed: "File deletion failed"
+  rename_ok: "File rename successfully"
+  file_created: "File created successfully"
+  not_saved: 'Could not save'
+  saved_ok: "Saved successfully"
+  error_saving: "Error saving file"
+  invalid_file_name: "Invalid filename. Use only letters, numbers, underscores, hyphens, and dots."
+  config_loaded: "Configuration loaded successfully."
+  config_load_error: "Error loading configuration."
+  search_placeholder: "Search users..."
+  showing: "Showing"
+  records: "Records"
+  db_user: "User"
+  db_role: "Role"
+  db_verified: "Verified"
+  db_created: "Created"
+  db_last_access: "Last access"
+  db_filename: "Filename"
+  db_user: "User"
+  db_status: "Status"
+  db_collection: "Collection"
+  editor_no_file_selected: "No file selected"
+  error_loading: "Error loading file content"
+  cant_load_company: "Could not load company.yaml"
+  config_saved: "Configuration saved successfully."
+  config_error: "Error saving configuration."
+
+
+