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

iatoolkit/locales/es.yaml

@@ -45,6 +45,110 @@ ui:
     prompts_available: "Prompts disponibles"
     init_context: "Inicializando el contexto de la IA ..."
 
+  admin:
+    workspace: "Recursos"
+    configuration: "Configuración"
+    company_config: "Configuración Empresa (company.yaml)"
+    knowledge: "Conocimiento"
+    knowledge_rag: "RAG (Vectorial)"
+    knowledge_static: "Contenido Estático"
+    prompts: "Prompts"
+    prompts_description: "Prompts de sistema"
+    schemas: "Schemas"
+    schemas_description: "Definiciones de entidades"
+    context: "Contexto"
+    context_description: "Contenido estatico (Markdown)"
+    administration: "Administración"
+    monitoring: "Monitoreo"
+    teams: "Usuarios"
+    billing: "Facturación"
+    files: "Archivos"
+    select_file: "Seleccione un archivo a editar"
+    select_category: "Seleccione una categoría"
+    editing: "Editando"
+    no_file_selected: "Seleccione un archivo"
+    new: "Nuevo"
+    confirm: "Confirmar"
+    cancel: "Cancelar"
+    new_file: "Nuevo archivo"
+    delete_file: "Borrar archivo"
+    rename_file: "Renombrar archivo"
+    save_file: "Guardar"
+    credentials: "Email y password son requeridos."
+    saved_ok: "Guardado correctamente"
+    deleted_ok: "Eliminado correctamente"
+    company: "Empresa"
+    admin_page_title: "Acceso de administración"
+    user_manager: "Administración de usuarios"
+    load_configuration: "Guardar configuración"
+    goto_chat: "Ir al chat"
+    logout: "Cerrar sesión"
+
+  db_explorer:
+    data_explorer: "Explorador de datos"
+    database_connection: "Bases de datos"
+    tables: "Tablas"
+    data_explorer_description: "Explora tus tablas de base de datos."
+    select_database: "Seleccione una base de datos para ver sus tablas."
+    not_table_selected: "No hay tabla seleccionada."
+    view_yaml: "Ver YAML"
+    save_schema: "Guardar esquema"
+    select_table: "Seleccionar una tabla del panel izquierdo"
+    table_semantics: "Significado de la tabla"
+    table_description: "Descripción de la tabla (Contexto IA)"
+    table_placeholder: "Describe el significado de la tabla, ejemplo: tabla de usuarios."
+    column_metadata: "Metadatos de columna"
+    auto_detect: "Auto-detectar desde la BD"
+    meta_column: "Columna"
+    meta_type: "Tipo"
+    meta_description: "Descripción"
+    meta_synonyms: "Sinonimos"
+    pii_sesitive: "IP Sensible"
+
+  config:
+    editor_description: "Editor de configuración"
+    title: "Editor de configuraciones"
+    sections: "Secciones"
+    refresh: "Refrescar"
+    validate: "Validar"
+    select_section: "Seleccione una sección del panel izquierdo"
+    no_section_selected: "No hay sección seleccionada."
+    view_yaml: "Ver YAML"
+
+
+  rag:
+    ingestion: "Ingesta"
+    ingestion_description: "Ingestar documentos en la base de conocimiento."
+    workbench: "Area de trabajo"
+    documents: "Documentos"
+    retrieval_lab: "Laboratorio de recuperación"
+    retrieval_description: "Probar la búsqueda semántica y la recuperación de contexto."
+    query_placeholder: "Introduce una pregunta para consultar la base de conocimiento..."
+    search_button: "Buscar"
+    filter: "Filtrar"
+    search_results_title: "Listo para probar"
+    search_results_description: "Los resultados aparecerán aquí"
+    filename: "Nombre de archivo"
+    filename_placeholder: "Contiene..."
+    user: "Usuario"
+    status: "Estado"
+    all_status: "Estados"
+    status_active: "Activo"
+    status_pending: "Pendiente"
+    status_processing: "Procesando"
+    status_failed: "Fallido"
+    created_at: "Creado"
+    date_range: "Rango de fechas"
+    delete_confirmation: "¿Eliminar archivo?"
+    delete_message: "Esta acción no se puede deshacer. El archivo se eliminará permanentemente."
+    delete_button: "Eliminar"
+    delete_cancel: "Cancelar"
+    target_collection: "Categoría seleccionada"
+    select_collection_placeholder: "Selecciona una categoría"
+    collection_required: "Debe seleccionar una categoría"
+    all_collections: "Todas las categorías"
+    collection: "Categoría"
+
 
   tooltips:
     history: "Historial con mis consultas"
@@ -52,6 +156,7 @@ ui:
     feedback: "Tu feedback es muy importante"
     usage_guide: "Guía de Uso"
     onboarding: "Cómo preguntar mejor"
+    preferences: "Preferencias"
     logout: "Cerrar sesión"
     use_prompt_assistant: "Usar Asistente de Prompts"
     attach_files: "Adjuntar archivos"
@@ -87,6 +192,9 @@ errors:
     authentication_required: "Autenticación requerida. No se proporcionó cookie de sesión o clave de API."
     invalid_api_key: "Clave de API inválida o inactiva."
     no_user_identifier_api: "No se proporcionó user_identifier para la llamada a la API."
+    no_company_permissions: "No tiene permisos para administrar esta empresa."
+    api_key_name_required: "el parametro api_key_name es requerido."
+
   templates:
     company_not_found: "Empresa no encontrada."
     home_template_not_found: "La plantilla de la página de inicio para la empresa '{company_short_name}' no está configurada."
@@ -143,6 +251,20 @@ services:
   start_query: "Hola, cual es tu pregunta?"
   mail_change_password: "se envio mail para cambio de clave"
 
+rag:
+  ingestion:
+    duplicate: "El documento '{filename}' ya existe para la empresa '{company_short_name}'. Omitiendo ingesta."
+    failed: "Error al ingerir el documento: {error}"
+    processing_failed: "El procesamiento falló: {error}"
+    empty_text: "El texto extraído está vacío."
+  search:
+    query_required: "La consulta (query) es obligatoria."
+    company_not_found: "Empresa '{company_short_name}' no encontrada."
+  management:
+    delete_success: "Documento eliminado."
+    not_found: "Documento no encontrado."
+    action_not_found: "Acción '{action}' no encontrada."
+
 flash_messages:
   password_changed_success: "Tu contraseña ha sido restablecida exitosamente. Ahora puedes iniciar sesión."
   signup_success: "Registro exitoso. Por favor, revisa tu correo para verificar tu cuenta."
@@ -169,4 +291,40 @@ js_messages:
   reload_init: "Iniciando recarga de contexto en segundo plano..."
   no_history_found: "No existe historial de consultas."
   example: "Ejemplo:"
+  show_reasoning: "Ver razonamiento"
+  unsaved: "Modificado (no guardado)"
+  saved_ok: "Archivo guadado correctamente"
+  error_saving: "Error al guardar archivo"
+  select_file: "Seleccione un archivo de la lista"
+  no_file_selected: "No hay archivo seleccionado"
+  select_company: "Seleccione empresa"
+  file_created: "Archivo creado correctamente"
+  delete_ok: "Archivo eliminado correctamente"
+  delete_failed: "Error al eliminar archivo"
+  rename_ok: "Archivo renombrado correctamente"
+  not_saved: 'No puede guardar'
+  invalid_file_name: "Nombre de archivo no válido. Usa solo letras, números, guiones bajos, guiones y puntos."
+  config_loaded: "Configuración cargada correctamente."
+  config_load_error: "Error cargando confguración."
+  search_placeholder: "Buscar usuarios..."
+  showing: "Mostrando"
+  records: "Registros"
+  db_user: "Usuario"
+  db_role: "Rol"
+  db_verified: "Verificado"
+  db_collection: "Colección"
+  db_last_access: "ultimo acceso"
+  db_filename: "Nombre de archivo"
+  db_user: "Usuario"
+  db_status: "Estado"
+  db_created: "Creado"
+  editor_no_file_selected: "No hay archivo seleccionado"
+  error_loading: "Error cargando el contenido del archivo"
+  cant_load_company: "No puede cargarcompany.yaml"
+  config_saved: "Configuración guardada correctamente."
+  config_error: "Error guardando configuración"
+
+
+
+
 

iatoolkit/repositories/database_manager.py

@@ -10,13 +10,15 @@ from sqlalchemy.engine.url import make_url
 from iatoolkit.repositories.models import Base
 from injector import inject
 from pgvector.psycopg2 import register_vector
+from iatoolkit.common.interfaces.database_provider import DatabaseProvider
+import logging
 
 
-class DatabaseManager:
+class DatabaseManager(DatabaseProvider):
     @inject
     def __init__(self,
                  database_url: str,
-                 schema: str | None = None,
+                 schema: str = 'public',
                  register_pgvector: bool = True):
         """
         Inicializa el gestor de la base de datos.
@@ -91,9 +93,6 @@ class DatabaseManager:
     def get_connection(self):
         return self._engine.connect()
 
-    def get_engine(self):
-        return self._engine
-
     def create_all(self):
         # if there is a schema defined, make sure it exists before creating tables
         backend = self.url.get_backend_name()
@@ -109,52 +108,58 @@ class DatabaseManager:
     def remove_session(self):
         self.scoped_session.remove()
 
-    def get_all_table_names(self) -> list[str]:
-        # Returns a list of all table names in the database
-        inspector = inspect(self._engine)
-        return inspector.get_table_names(schema=self.schema)
-
-    def get_table_schema(self,
-                         table_name: str,
-                         db_schema: str,
-                         schema_object_name: str | None = None,
-                         exclude_columns: list[str] | None = None) -> str:
-        inspector = inspect(self._engine)
-
-        # search the table in the specified schema
-        if table_name not in inspector.get_table_names(schema=db_schema):
-            raise RuntimeError(f"Table '{table_name}' does not exist in database schema '{db_schema}'.")
+    # -- execution methods ----
 
-        if exclude_columns is None:
-            exclude_columns = []
-
-        # get all the table columns
-        columns = inspector.get_columns(table_name, schema=db_schema)
+    def execute_query(self, query: str, commit: bool = False) -> list[dict] | dict:
+        """
+        Implementation for Direct SQLAlchemy connection.
+        """
+        session = self.get_session()
+        if self.schema:
+            session.execute(text(f"SET search_path TO {self.schema}"))
 
-        # construct a json dictionary with the table definition
-        json_dict = {
-            "table": table_name,
-            "description": f"Definición de la tabla {table_name}.",
-            "fields": []
-        }
-        if schema_object_name:
-            json_dict["description"] += f"Los detalles de cada campo están en el objeto **`{schema_object_name}`**."
+        result = session.execute(text(query))
+        if commit:
+            session.commit()
 
-        if db_schema:
-            json_dict["schema"] = db_schema
-            json_dict["description"] += f"Pertenece al esquema **`{db_schema}`**."
+        if result.returns_rows:
+            # Convert SQLAlchemy rows to list of dicts immediately
+            cols = result.keys()
+            return [dict(zip(cols, row)) for row in result.fetchall()]
 
-        # now add every column to the json dictionary
-        for col in columns:
-            name = col["name"]
+        return {'rowcount': result.rowcount}
 
-            # omit the excluded columns.
-            if name in exclude_columns:
-                continue
+    def commit(self):
+        self.get_session().commit()
 
-            json_dict["fields"].append({
-                "name": name,
-                "type": str(col["type"]),
-            })
+    def rollback(self):
+        self.get_session().rollback()
 
-        return "\n\n" + str(json_dict)
+    # -- schema methods ----
+    def get_database_structure(self) -> dict:
+        inspector = inspect(self._engine)
+        structure = {}
+        for table in inspector.get_table_names(schema=self.schema):
+            columns_data = []
+
+            # get columns
+            try:
+                columns = inspector.get_columns(table, schema=self.schema)
+                # Obtener PKs para marcarlas
+                pks = inspector.get_pk_constraint(table, schema=self.schema).get('constrained_columns', [])
+
+                for col in columns:
+                    columns_data.append({
+                        "name": col['name'],
+                        "type": str(col['type']),
+                        "nullable": col.get('nullable', True),
+                        "pk": col['name'] in pks
+                    })
+            except Exception as e:
+                logging.warning(f"Could not inspect columns for table {table}: {e}")
+
+            structure[table] = {
+                "columns": columns_data
+            }
+
+        return structure

iatoolkit/repositories/document_repo.py

@@ -26,6 +26,13 @@ class DocumentRepo:
 
         return self.session.query(Document).filter_by(company_id=company_id, filename=filename).first()
 
+    def get_by_hash(self, company_id: int, file_hash: str) -> Document:
+        """Find a document by its content hash within a company."""
+        if not company_id or not file_hash:
+            return None
+
+        return self.session.query(Document).filter_by(company_id=company_id, hash=file_hash).first()
+
     def get_by_id(self, document_id: int) -> Document:
         if not document_id:
             return None

iatoolkit/repositories/filesystem_asset_repository.py

@@ -0,0 +1,36 @@
+from iatoolkit.common.interfaces.asset_storage import AssetRepository, AssetType
+from pathlib import Path
+
+
+class FileSystemAssetRepository(AssetRepository):
+    def _get_path(self, company_short_name: str, asset_type: AssetType, filename: str = "") -> Path:
+        return Path("companies") / company_short_name / asset_type.value / filename
+
+    def exists(self, company_short_name: str, asset_type: AssetType, filename: str) -> bool:
+        return self._get_path(company_short_name, asset_type, filename).is_file()
+
+    def read_text(self, company_short_name: str, asset_type: AssetType, filename: str) -> str:
+        path = self._get_path(company_short_name, asset_type, filename)
+        if not path.is_file():
+            raise FileNotFoundError(f"File not found: {path}")
+        return path.read_text(encoding="utf-8")
+
+    def list_files(self, company_short_name: str, asset_type: AssetType, extension: str = None) -> list[str]:
+        directory = self._get_path(company_short_name, asset_type)
+        if not directory.exists():
+            return []
+        files = [f.name for f in directory.iterdir() if f.is_file()]
+        if extension:
+            files = [f for f in files if f.endswith(extension)]
+        return files
+
+    def write_text(self, company_short_name: str, asset_type: AssetType, filename: str, content: str) -> None:
+        path = self._get_path(company_short_name, asset_type, filename)
+        # Ensure the directory exists (e.g. creating a new company structure)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+
+    def delete(self, company_short_name: str, asset_type: AssetType, filename: str) -> None:
+        path = self._get_path(company_short_name, asset_type, filename)
+        if path.exists():
+            path.unlink()

iatoolkit/repositories/llm_query_repo.py

@@ -35,6 +35,8 @@ class LLMQueryRepo:
                     Tool.system_function.is_(True)
                 )
             )
+            # Ordenamos descendente: True (System) va primero, False (Company) va después
+            .order_by(Tool.system_function.desc())
             .all()
         )
 

iatoolkit/repositories/models.py

@@ -5,12 +5,11 @@
 
 from sqlalchemy import Column, Integer, BigInteger, String, DateTime, Enum, Text, JSON, Boolean, ForeignKey, Table
 from sqlalchemy.orm import DeclarativeBase
-from sqlalchemy.orm import relationship, class_mapper, declarative_base
+from sqlalchemy.orm import relationship, class_mapper
 from sqlalchemy.sql import func
+from sqlalchemy import UniqueConstraint
 from datetime import datetime
 from pgvector.sqlalchemy import Vector
-from enum import Enum as PyEnum
-import secrets
 import enum
 
 
@@ -27,6 +26,7 @@ user_company = Table('iat_user_company',
                      Column('company_id', Integer,
                             ForeignKey('iat_companies.id',ondelete='CASCADE'),
                                 primary_key=True),
+                     Column('role', String, nullable=True, default='user'),
                      Column('created_at', DateTime, default=datetime.now)
                      )
 
@@ -36,7 +36,8 @@ class ApiKey(Base):
 
     id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id', ondelete='CASCADE'), nullable=False)
-    key = Column(String(128), unique=True, nullable=False, index=True) # La API Key en sí
+    key_name = Column(String, nullable=False)
+    key = Column(String, unique=True, nullable=False, index=True) # La API Key en sí
     is_active = Column(Boolean, default=True, nullable=False)
     created_at = Column(DateTime, default=datetime.now)
     last_used_at = Column(DateTime, nullable=True) # Opcional: para rastrear uso
@@ -49,12 +50,9 @@ class Company(Base):
     __tablename__ = 'iat_companies'
 
     id = Column(Integer, primary_key=True, autoincrement=True)
-    short_name = Column(String(20), nullable=False, unique=True, index=True)
-    name = Column(String(256), nullable=False)
+    short_name = Column(String, nullable=False, unique=True, index=True)
+    name = Column(String, nullable=False)
 
-    # encrypted api-key
-    openai_api_key = Column(String, nullable=True)
-    gemini_api_key = Column(String, nullable=True)
     parameters = Column(JSON, nullable=True)
     created_at = Column(DateTime, default=datetime.now)
 
@@ -78,13 +76,18 @@ class Company(Base):
                             back_populates="company",
                             cascade="all, delete-orphan")
 
-    tasks = relationship("Task", back_populates="company")
     feedbacks = relationship("UserFeedback",
                                back_populates="company",
                                cascade="all, delete-orphan")
     prompts = relationship("Prompt",
                              back_populates="company",
                              cascade="all, delete-orphan")
+    collection_types = relationship(
+        "CollectionType",
+        back_populates="company",
+        cascade="all, delete-orphan"
+    )
+
 
     def to_dict(self):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
@@ -95,13 +98,13 @@ class User(Base):
     __tablename__ = 'iat_users'
 
     id = Column(Integer, primary_key=True, autoincrement=True)
-    email = Column(String(80), unique=True, nullable=False)
-    first_name = Column(String(50), nullable=False)
-    last_name = Column(String(50), nullable=False)
+    email = Column(String, unique=True, nullable=False)
+    first_name = Column(String, nullable=False)
+    last_name = Column(String, nullable=False)
     created_at = Column(DateTime, default=datetime.now)
     password = Column(String, nullable=False)
     verified = Column(Boolean, nullable=False, default=False)
-    preferred_language = Column(String(5), nullable=True)
+    preferred_language = Column(String, nullable=True)
     verification_url = Column(String, nullable=True)
     temp_code = Column(String, nullable=True)
 
@@ -133,7 +136,7 @@ class Tool(Base):
     company_id = Column(Integer,
                         ForeignKey('iat_companies.id',ondelete='CASCADE'),
                         nullable=True)
-    name = Column(String(255), nullable=False)
+    name = Column(String, nullable=False)
     system_function = Column(Boolean, default=False)
     description = Column(Text, nullable=False)
     parameters = Column(JSON, nullable=False)
@@ -146,6 +149,29 @@ class Tool(Base):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
 
 
+class DocumentStatus(str, enum.Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    ACTIVE = "active"
+    FAILED = "failed"
+
+
+class CollectionType(Base):
+    """Defines the available document collections/categories for a company."""
+    __tablename__ = 'iat_collection_types'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    company_id = Column(Integer, ForeignKey('iat_companies.id', ondelete='CASCADE'), nullable=False)
+    name = Column(String, nullable=False)  # e.g., "Contracts", "Manuals"
+
+    # description - optional for the LLM to understand what's inside'
+    description = Column(Text, nullable=True)
+
+    __table_args__ = (UniqueConstraint('company_id', 'name', name='uix_company_collection_name'),)
+
+    company = relationship("Company", back_populates="collection_types")
+    documents = relationship("Document", back_populates="collection_type")
+
 class Document(Base):
     """Represents a file or document uploaded by a company for context."""
     __tablename__ = 'iat_documents'
@@ -153,17 +179,32 @@ class Document(Base):
     id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                     ondelete='CASCADE'), nullable=False)
-    filename = Column(String(256), nullable=False, index=True)
+    collection_type_id = Column(Integer, ForeignKey('iat_collection_types.id', ondelete='SET NULL'), nullable=True)
+
+    user_identifier = Column(String, nullable=True)
+    filename = Column(String, nullable=False, index=True)
+    status = Column(Enum(DocumentStatus), default=DocumentStatus.PENDING, nullable=False)
     meta = Column(JSON, nullable=True)
     created_at = Column(DateTime, default=datetime.now)
     content = Column(Text, nullable=False)
     content_b64 = Column(Text, nullable=False)
 
+    # For feedback if OCR or embedding fails
+    error_message = Column(Text, nullable=True)
+
+    # Hash column for deduplication (SHA-256 hex digest)
+    hash = Column(String(64), index=True, nullable=True)
+
     company = relationship("Company", back_populates="documents")
+    collection_type = relationship("CollectionType", back_populates="documents")
 
     def to_dict(self):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
 
+    @property
+    def description(self):
+        collection_type = self.collection_type.name if self.collection_type else None
+        return f"Document ID {self.id}: {self.filename} ({collection_type})"
 
 class LLMQuery(Base):
     """Logs a query made to the LLM, including input, output, and metadata."""
@@ -172,8 +213,7 @@ class LLMQuery(Base):
     id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                             ondelete='CASCADE'), nullable=False)
-    user_identifier = Column(String(128), nullable=False)
-    task_id = Column(Integer, default=0, nullable=True)
+    user_identifier = Column(String, nullable=False)
     query = Column(Text, nullable=False)
     output = Column(Text, nullable=False)
     response = Column(JSON, nullable=True, default={})
@@ -184,7 +224,6 @@ class LLMQuery(Base):
     created_at = Column(DateTime, default=datetime.now)
 
     company = relationship("Company", back_populates="llm_queries")
-    tasks = relationship("Task", back_populates="llm_query")
 
     def to_dict(self):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
@@ -203,59 +242,13 @@ class VSDoc(Base):
 
     # the size of this vector should be set depending on the embedding model used
     # for OpenAI is 1536, and for huggingface is 384
-    embedding = Column(Vector(1536), nullable=False)
+    embedding = Column(Vector(384), nullable=False)
 
     company = relationship("Company", back_populates="vsdocs")
 
     def to_dict(self):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
 
-class TaskStatus(PyEnum):
-    """Enumeration for the possible statuses of a Task."""
-    pendiente = "pendiente"  # task created and waiting to be executed.
-    ejecutado = "ejecutado"  # the IA algorithm has been executed.
-    aprobada = "aprobada"  # validated and approved by human.
-    rechazada = "rechazada"  # validated and rejected by human.
-    fallida = "fallida"  # error executing the IA algorithm.
-
-class TaskType(Base):
-    """Defines a type of task that can be executed, including its prompt template."""
-    __tablename__ = 'iat_task_types'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    name = Column(String(100), unique=True, nullable=False)
-    prompt_template = Column(String(100), nullable=True)  # Plantilla de prompt por defecto.
-    template_args = Column(JSON, nullable=True)  # Argumentos/prefijos de configuración para el template.
-
-class Task(Base):
-    """Represents an asynchronous task to be executed by the system, often involving an LLM."""
-    __tablename__ = 'iat_tasks'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    company_id = Column(Integer, ForeignKey("iat_companies.id"))
-
-    user_id = Column(Integer, nullable=True, default=0)
-    task_type_id = Column(Integer, ForeignKey('iat_task_types.id'), nullable=False)
-    status = Column(Enum(TaskStatus, name="task_status_enum"),
-                    default=TaskStatus.pendiente, nullable=False)
-    client_data = Column(JSON, nullable=True, default={})
-    company_task_id = Column(Integer, nullable=True, default=0)
-    execute_at = Column(DateTime, default=datetime.now, nullable=True)
-    llm_query_id = Column(Integer, ForeignKey('iat_queries.id'), nullable=True)
-    callback_url = Column(String(512), default=None, nullable=True)
-    files = Column(JSON, default=[], nullable=True)
-
-    review_user = Column(String(128), nullable=True, default='')
-    review_date = Column(DateTime, nullable=True)
-    comment = Column(Text, nullable=True)
-    approved = Column(Boolean, nullable=False, default=False)
-
-    created_at = Column(DateTime, default=datetime.now)
-    updated_at = Column(DateTime, default=datetime.now)
-
-    task_type = relationship("TaskType")
-    llm_query = relationship("LLMQuery", back_populates="tasks", uselist=False)
-    company = relationship("Company", back_populates="tasks")
 
 class UserFeedback(Base):
     """Stores feedback and ratings submitted by users for specific interactions."""
@@ -264,7 +257,7 @@ class UserFeedback(Base):
     id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                                             ondelete='CASCADE'), nullable=False)
-    user_identifier = Column(String(128), default='', nullable=True)
+    user_identifier = Column(String, default='', nullable=True)
     message = Column(Text, nullable=False)
     rating = Column(Integer, nullable=False)
     created_at = Column(DateTime, default=datetime.now)
@@ -293,12 +286,12 @@ class Prompt(Base):
     id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                                             ondelete='CASCADE'), nullable=True)
-    name = Column(String(64), nullable=False)
-    description = Column(String(256), nullable=False)
-    filename = Column(String(256), nullable=False)
+    name = Column(String, nullable=False)
+    description = Column(String, nullable=False)
+    filename = Column(String, nullable=False)
     active = Column(Boolean, default=True)
     is_system_prompt = Column(Boolean, default=False)
-    order = Column(Integer, nullable=False, default=0)  # Nuevo campo para el orden
+    order = Column(Integer, nullable=True, default=0)
     category_id = Column(Integer, ForeignKey('iat_prompt_categories.id'), nullable=True)
     custom_fields = Column(JSON, nullable=False, default=[])
 
@@ -314,18 +307,18 @@ class AccessLog(Base):
     id = Column(BigInteger, primary_key=True, autoincrement=True)
 
     timestamp = Column(DateTime(timezone=True), server_default=func.now(), nullable=False, index=True)
-    company_short_name = Column(String(100), nullable=False, index=True)
-    user_identifier = Column(String(255), index=True)
+    company_short_name = Column(String, nullable=False, index=True)
+    user_identifier = Column(String, index=True)
 
     # Cómo y el Resultado
-    auth_type = Column(String(20), nullable=False) # 'local', 'external_api', 'redeem_token', etc.
-    outcome = Column(String(10), nullable=False)   # 'success' o 'failure'
-    reason_code = Column(String(50))               # Causa de fallo, ej: 'INVALID_CREDENTIALS'
+    auth_type = Column(String, nullable=False) # 'local', 'external_api', 'redeem_token', etc.
+    outcome = Column(String, nullable=False)   # 'success' o 'failure'
+    reason_code = Column(String)               # Causa de fallo, ej: 'INVALID_CREDENTIALS'
 
     # Contexto de la Petición
-    source_ip = Column(String(45), nullable=False)
-    user_agent_hash = Column(String(16))           # Hash corto del User-Agent
-    request_path = Column(String(255), nullable=False)
+    source_ip = Column(String, nullable=False)
+    user_agent_hash = Column(String)           # Hash corto del User-Agent
+    request_path = Column(String, nullable=False)
 
     def __repr__(self):
         return (f"<AccessLog(id={self.id}, company='{self.company_short_name}', "