iatoolkit 2.4.0__tar.gz → 2.4.1__tar.gz

{iatoolkit-2.4.0/src/iatoolkit.egg-info → iatoolkit-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.4.0
+Version: 2.4.1
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT

{iatoolkit-2.4.0 → iatoolkit-2.4.1}/src/iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "2.4.0"
+__version__ = "2.4.1"
 
 # Expose main classes and functions at the top level of the package
 

{iatoolkit-2.4.0 → iatoolkit-2.4.1}/src/iatoolkit/config/system_prompts_pack.yaml

@@ -71,7 +71,6 @@ prompts:
     include:
       execution_modes:
         - chat
-        - agent
   - key: file_download_output
     filename: file_download_output.prompt
     section: output_contract

{iatoolkit-2.4.0 → iatoolkit-2.4.1}/src/iatoolkit/infra/llm_proxy.py

@@ -86,6 +86,7 @@ class LLMProxy:
             company_short_name=company_short_name,
             model=model,
         )
+        model_config = self.configuration_service.get_llm_model_config(company_short_name, model) or {}
         provider_config = self.configuration_service.get_llm_provider_config(company_short_name, provider) or {}
 
         adapter = self._get_or_create_adapter(
@@ -98,6 +99,11 @@ class LLMProxy:
             provider_config=provider_config,
             request_kwargs=kwargs,
         )
+        request_kwargs = self._apply_model_request_overrides(
+            provider=provider,
+            model_config=model_config,
+            request_kwargs=request_kwargs,
+        )
 
         # Delegate to the adapter (OpenAI, Gemini, DeepSeek, xAI, Anthropic, etc.)
         return adapter.create_response(model=model, input=input, **request_kwargs)
@@ -218,6 +224,35 @@ class LLMProxy:
 
         return effective_kwargs
 
+    def _apply_model_request_overrides(
+        self,
+        provider: str,
+        model_config: Dict[str, Any],
+        request_kwargs: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        effective_kwargs = dict(request_kwargs or {})
+
+        if provider != self.PROVIDER_OPENROUTER or not isinstance(model_config, dict):
+            return effective_kwargs
+
+        model_runtime_config = model_config.get("config")
+        if not isinstance(model_runtime_config, dict):
+            return effective_kwargs
+
+        openrouter_provider = model_runtime_config.get("routing")
+        if not isinstance(openrouter_provider, dict) or not openrouter_provider:
+            return effective_kwargs
+
+        existing_provider = effective_kwargs.get("provider")
+        if isinstance(existing_provider, dict):
+            merged_provider = dict(openrouter_provider)
+            merged_provider.update(existing_provider)
+            effective_kwargs["provider"] = merged_provider
+        elif existing_provider is None:
+            effective_kwargs["provider"] = dict(openrouter_provider)
+
+        return effective_kwargs
+
     # -------------------------------------------------------------------------
     # Client cache
     # -------------------------------------------------------------------------

{iatoolkit-2.4.0 → iatoolkit-2.4.1}/src/iatoolkit/locales/en.yaml

@@ -1286,6 +1286,9 @@ ui:
     status_failed: "Failed"
     created_at: "Created"
     date_range: "Date range"
+    metadata_field: "Metadata field"
+    metadata_value: "Metadata value"
+    select_metadata_field: "Select a field"
     delete_confirmation: "Delete File?"
     delete_message: "This action cannot be undone. The file will be permanently removed."
     delete_button: "Delete"

{iatoolkit-2.4.0 → iatoolkit-2.4.1}/src/iatoolkit/locales/es.yaml

@@ -1290,6 +1290,9 @@ ui:
     status_failed: "Fallido"
     created_at: "Creado"
     date_range: "Rango de fechas"
+    metadata_field: "Campo metadata"
+    metadata_value: "Valor metadata"
+    select_metadata_field: "Selecciona un campo"
     delete_confirmation: "¿Eliminar archivo?"
     delete_message: "Esta acción no se puede deshacer. El archivo se eliminará permanentemente."
     delete_button: "Eliminar"

{iatoolkit-2.4.0 → iatoolkit-2.4.1}/src/iatoolkit/services/configuration_service.py

@@ -52,6 +52,49 @@ class ConfigurationService:
             return {}
         return {"id": model_id}
 
+    @staticmethod
+    def _validate_openrouter_provider_preferences(add_error, section: str, provider_cfg) -> None:
+        if not isinstance(provider_cfg, dict):
+            add_error(section, "Must be a dictionary.")
+            return
+
+        for list_key in ("order", "only", "ignore"):
+            if list_key not in provider_cfg:
+                continue
+            raw_value = provider_cfg.get(list_key)
+            if not isinstance(raw_value, list) or any(not isinstance(item, str) or not item.strip() for item in raw_value):
+                add_error(f"{section}.{list_key}", "Must be a list of non-empty strings.")
+
+        for bool_key in ("allow_fallbacks", "require_parameters", "zdr"):
+            if bool_key in provider_cfg and not isinstance(provider_cfg.get(bool_key), bool):
+                add_error(f"{section}.{bool_key}", "Must be a boolean.")
+
+        if "data_collection" in provider_cfg:
+            data_collection = str(provider_cfg.get("data_collection") or "").strip().lower()
+            if data_collection not in {"allow", "deny"}:
+                add_error(f"{section}.data_collection", "Must be 'allow' or 'deny'.")
+
+        if "sort" in provider_cfg:
+            sort_value = provider_cfg.get("sort")
+            if isinstance(sort_value, str):
+                if sort_value.strip().lower() not in {"price", "throughput", "latency"}:
+                    add_error(
+                        f"{section}.sort",
+                        "Must be one of: ['latency', 'price', 'throughput'], or a dictionary."
+                    )
+            elif isinstance(sort_value, dict):
+                sort_by = str(sort_value.get("by") or "").strip().lower()
+                if sort_by and sort_by not in {"price", "throughput", "latency"}:
+                    add_error(f"{section}.sort.by", "Must be one of: ['latency', 'price', 'throughput'].")
+                partition = sort_value.get("partition")
+                if partition is not None and str(partition).strip().lower() not in {"provider", "model", "none"}:
+                    add_error(f"{section}.sort.partition", "Must be one of: ['model', 'none', 'provider'].")
+            else:
+                add_error(
+                    f"{section}.sort",
+                    "Must be one of: ['latency', 'price', 'throughput'], or a dictionary."
+                )
+
     def load_configuration(self, company_short_name: str):
         """
         Main entry point for configuring a company instance.
@@ -365,15 +408,43 @@ class ConfigurationService:
             for index, model_entry in enumerate(llm_available_models):
                 normalized_model = self._normalize_model_entry(model_entry)
                 provider = str(normalized_model.get("provider") or "").strip().lower()
+                model_specific_config = normalized_model.get("config")
                 if provider and provider not in supported_llm_providers:
                     add_error(
                         f"llm.available_models[{index}].provider",
                         f"Unsupported provider '{provider}'. Must be one of: {sorted(supported_llm_providers)}."
                     )
+                if model_specific_config is not None and not isinstance(model_specific_config, dict):
+                    add_error(f"llm.available_models[{index}].config", "Must be a dictionary.")
                 if provider == "openai_compatible":
                     openai_compatible_in_use = True
                 if provider == "openrouter":
                     openrouter_in_use = True
+                    if isinstance(model_specific_config, dict):
+                        if "routing" in model_specific_config:
+                            self._validate_openrouter_provider_preferences(
+                                add_error,
+                                f"llm.available_models[{index}].config.routing",
+                                model_specific_config.get("routing"),
+                            )
+                        if "openrouter_provider" in model_specific_config:
+                            add_error(
+                                f"llm.available_models[{index}].config.openrouter_provider",
+                                "Unsupported key. Use 'config.routing' instead.",
+                            )
+                elif isinstance(model_specific_config, dict) and (
+                    "routing" in model_specific_config or "openrouter_provider" in model_specific_config
+                ):
+                    if "routing" in model_specific_config:
+                        add_error(
+                            f"llm.available_models[{index}].config.routing",
+                            "Only supported when the model provider is 'openrouter'.",
+                        )
+                    if "openrouter_provider" in model_specific_config:
+                        add_error(
+                            f"llm.available_models[{index}].config.openrouter_provider",
+                            "Unsupported key. Use 'config.routing' instead.",
+                        )
 
             providers_cfg = config.get("llm", {}).get("providers")
             if providers_cfg is not None and not isinstance(providers_cfg, dict):
@@ -752,6 +823,49 @@ class ConfigurationService:
                 if not isinstance(docling_config, dict):
                     add_error("knowledge_base.docling", "Must be a dictionary.")
 
+            metadata_search_fields = kb_config.get("metadata_search_fields")
+            if metadata_search_fields is not None:
+                if not isinstance(metadata_search_fields, list):
+                    add_error("knowledge_base.metadata_search_fields", "Must be a list.")
+                else:
+                    for i, item in enumerate(metadata_search_fields):
+                        if isinstance(item, str):
+                            if not item.strip():
+                                add_error(
+                                    f"knowledge_base.metadata_search_fields[{i}]",
+                                    "Metadata field name cannot be empty."
+                                )
+                        elif isinstance(item, dict):
+                            key = item.get("key")
+                            if not isinstance(key, str) or not key.strip():
+                                add_error(
+                                    f"knowledge_base.metadata_search_fields[{i}].key",
+                                    "Missing required key: 'key' (non-empty string)."
+                                )
+                            label = item.get("label")
+                            if label is not None and (not isinstance(label, str) or not label.strip()):
+                                add_error(
+                                    f"knowledge_base.metadata_search_fields[{i}].label",
+                                    "Must be a non-empty string if provided."
+                                )
+                            match = item.get("match")
+                            if match is not None:
+                                if not isinstance(match, str):
+                                    add_error(
+                                        f"knowledge_base.metadata_search_fields[{i}].match",
+                                        "Must be a string if provided."
+                                    )
+                                elif match.strip().lower() not in {"exact", "contains"}:
+                                    add_error(
+                                        f"knowledge_base.metadata_search_fields[{i}].match",
+                                        "Must be one of: ['contains', 'exact']."
+                                    )
+                        else:
+                            add_error(
+                                f"knowledge_base.metadata_search_fields[{i}]",
+                                "Each metadata search field must be a string or an object with keys like {key, label, match}."
+                            )
+
             prod_connector = kb_config.get("connectors", {}).get("production", {})
             if prod_connector.get("type") == "s3":
                 for key in ["bucket", "prefix"]:

{iatoolkit-2.4.0 → iatoolkit-2.4.1}/src/iatoolkit/services/knowledge_base_service.py

@@ -14,7 +14,7 @@ from iatoolkit.services.storage_service import StorageService
 from iatoolkit.services.parsers.parsing_service import ParsingService
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from iatoolkit.services.visual_kb_service import VisualKnowledgeBaseService
-from sqlalchemy import desc
+from sqlalchemy import desc, func
 from typing import Any
 import json
 from iatoolkit.common.exceptions import IAToolkitException
@@ -564,6 +564,9 @@ class KnowledgeBaseService:
                        filename_keyword: Optional[str] = None,
                        from_date: Optional[datetime] = None,
                        to_date: Optional[datetime] = None,
+                       metadata_key: Optional[str] = None,
+                       metadata_value: Optional[str] = None,
+                       metadata_match_mode: Optional[str] = None,
                        limit: int = 100,
                        offset: int = 0) -> List[Document]:
         """
@@ -577,6 +580,9 @@ class KnowledgeBaseService:
             filename_keyword: Optional substring to search in filename.
             from_date: Optional start date filter (created_at).
             to_date: Optional end date filter (created_at).
+            metadata_key: Optional top-level metadata field name inside Document.meta.
+            metadata_value: Optional metadata field value to filter by.
+            metadata_match_mode: Optional metadata match mode: 'exact' or 'contains'.
             limit: Pagination limit.
             offset: Pagination offset.
 
@@ -613,6 +619,16 @@ class KnowledgeBaseService:
         if to_date:
             query = query.filter(Document.created_at <= to_date)
 
+        normalized_metadata_key = str(metadata_key or "").strip()
+        normalized_metadata_value = str(metadata_value or "").strip().lower()
+        normalized_match_mode = str(metadata_match_mode or "contains").strip().lower()
+        if normalized_metadata_key and normalized_metadata_value:
+            meta_value_expr = func.lower(func.coalesce(Document.meta[normalized_metadata_key].as_string(), ""))
+            if normalized_match_mode == "exact":
+                query = query.filter(meta_value_expr == normalized_metadata_value)
+            else:
+                query = query.filter(meta_value_expr.like(f"%{normalized_metadata_value}%"))
+
         # Apply sorting (newest first) and pagination
         query = query.order_by(desc(Document.created_at))
         query = query.limit(limit).offset(offset)

{iatoolkit-2.4.0 → iatoolkit-2.4.1}/src/iatoolkit/system_prompts/html_structures.prompt

@@ -1,7 +1,7 @@
 ### HTML estructurado
 
 #### Tablas
-- Usa como base `table table-striped table-hover`.
+- Usa como base `table table-striped table-hover` de Bootstrap como mínimo.
 - Si una columna contiene RUT, fecha, id certificado o valores similares, usa
   clase `nowrap` en el `<th>` y en el `<td>` correspondiente cuando aplique.
 - Si una columna debe ir centrada o alineada a la derecha, agrega

{iatoolkit-2.4.0 → iatoolkit-2.4.1}/src/iatoolkit/views/rag_api_view.py

@@ -8,6 +8,7 @@ from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.services.knowledge_base_service import KnowledgeBaseService
 from iatoolkit.services.visual_kb_service import VisualKnowledgeBaseService
 from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.common.util import Utility
 from iatoolkit.services.i18n_service import I18nService
 from flask import request, jsonify, send_file
@@ -27,11 +28,13 @@ class RagApiView(MethodView):
     def __init__(self,
                  knowledge_base_service: KnowledgeBaseService,
                  visual_kb_service: VisualKnowledgeBaseService,
+                 configuration_service: ConfigurationService,
                  auth_service: AuthService,
                  i18n_service: I18nService,
                  utility: Utility):
         self.knowledge_base_service = knowledge_base_service
         self.visual_kb_service = visual_kb_service
+        self.configuration_service = configuration_service
         self.auth_service = auth_service
         self.utility = utility
         self.i18n_service = i18n_service
@@ -65,18 +68,38 @@ class RagApiView(MethodView):
             # 2. Parse Input
             data = request.get_json() or {}
 
+            metadata_search_fields = self._get_metadata_search_fields(company_short_name)
+            metadata_field_map = {field["key"]: field for field in metadata_search_fields}
+
             status = data.get('status', [])
             user_identifier = data.get('user_identifier')
             keyword = data.get('filename_keyword')
             from_date_str = data.get('from_date')
             to_date_str = data.get('to_date')
             collection = data.get('collection', '')
+            metadata_key = str(data.get('metadata_key') or '').strip()
+            metadata_value = str(data.get('metadata_value') or '').strip()
+            metadata_match_mode = str(data.get('metadata_match_mode') or '').strip().lower()
             limit = int(data.get('limit', 100))
             offset = int(data.get('offset', 0))
 
             from_date = datetime.fromisoformat(from_date_str) if from_date_str else None
             to_date = datetime.fromisoformat(to_date_str) if to_date_str else None
 
+            if metadata_value and not metadata_key and len(metadata_search_fields) == 1:
+                metadata_key = metadata_search_fields[0]["key"]
+
+            if metadata_key:
+                selected_metadata_field = metadata_field_map.get(metadata_key)
+                if not selected_metadata_field:
+                    return jsonify({
+                        'result': 'error',
+                        'message': f"Invalid metadata search field: {metadata_key}"
+                    }), 400
+                metadata_match_mode = selected_metadata_field.get("match") or metadata_match_mode or "contains"
+            else:
+                metadata_match_mode = None
+
             # 3. Call Service
             documents = self.knowledge_base_service.list_documents(
                 company_short_name=company_short_name,
@@ -86,6 +109,9 @@ class RagApiView(MethodView):
                 user_identifier=user_identifier,
                 from_date=from_date,
                 to_date=to_date,
+                metadata_key=metadata_key or None,
+                metadata_value=metadata_value or None,
+                metadata_match_mode=metadata_match_mode,
                 limit=limit,
                 offset=offset
             )
@@ -107,7 +133,8 @@ class RagApiView(MethodView):
             return jsonify({
                 'result': 'success',
                 'count': len(response_list),
-                'documents': response_list
+                'documents': response_list,
+                'metadata_search_fields': metadata_search_fields
             }), 200
 
         except IAToolkitException as e:
@@ -115,6 +142,51 @@ class RagApiView(MethodView):
         except Exception as e:
             return jsonify({'result': 'error', 'message': str(e)}), 500
 
+    def _get_metadata_search_fields(self, company_short_name: str) -> list[dict]:
+        kb_config = self.configuration_service.get_configuration(company_short_name, "knowledge_base") or {}
+        raw_fields = kb_config.get("metadata_search_fields") or []
+        normalized_fields = []
+
+        if not isinstance(raw_fields, list):
+            return normalized_fields
+
+        for item in raw_fields:
+            normalized = self._normalize_metadata_search_field(item)
+            if normalized:
+                normalized_fields.append(normalized)
+
+        return normalized_fields
+
+    @staticmethod
+    def _normalize_metadata_search_field(item) -> dict | None:
+        if isinstance(item, str):
+            key = item.strip()
+            if not key:
+                return None
+            return {
+                "key": key,
+                "label": key,
+                "match": "contains"
+            }
+
+        if not isinstance(item, dict):
+            return None
+
+        key = str(item.get("key") or "").strip()
+        if not key:
+            return None
+
+        label = str(item.get("label") or key).strip() or key
+        match = str(item.get("match") or "contains").strip().lower()
+        if match not in {"exact", "contains"}:
+            match = "contains"
+
+        return {
+            "key": key,
+            "label": label,
+            "match": match
+        }
+
     def get_file_content(self, company_short_name, document_id):
         """
         GET /api/rag/<company_short_name>/files/<document_id>/content

{iatoolkit-2.4.0 → iatoolkit-2.4.1/src/iatoolkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.4.0
+Version: 2.4.1
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT