DEV Community

Oscar Ricardo Sánche Gutierréz
Oscar Ricardo Sánche Gutierréz

Posted on

Saltcorn + agentes IA: crea apps empresariales sin quemar código

#ai #docker #agentskills #nocode

Architecture

Diagrama realizado con https://savnet.co

Pedirle a un agente de IA que construya un sistema empresarial completo con código tiene un problema conocido: el contexto se vuelve demasiado grande.

Un formulario con 4 campos es sencillo. Un sistema con 60 campos, relaciones, permisos, vistas, formularios, calendarios, tableros Kanban, gráficas, archivos y reglas de negocio ya no lo es. El agente empieza a tener lagunas, olvida decisiones anteriores, duplica lógica o termina rompiendo partes del código que él mismo había creado.

En Savne exploraron otra ruta: usar Saltcorn como lienzo no-code.

Saltcorn ofrece un marco estable para construir aplicaciones: tablas, campos, vistas, páginas, formularios, menús, relaciones, permisos y plugins de interfaz. Esto reduce la carga mental y de contexto que debe mantener la IA. En vez de pedirle que invente una aplicación completa desde cero, le pedimos que opere dentro de una plataforma ya estructurada.

El problema: Saltcorn no expone una API suficientemente completa para que un agente pueda construir y modificar aplicaciones de forma fluida.

Ahí entra savne-saltcorn-agent-api

https://github.com/OscarSanchezSavne/savne-saltcorn-agent-api

¿Qué es savne-saltcorn-agent-api?

Es un plugin para Saltcorn que expone una API administrativa pensada para agentes, scripts y herramientas de automatización.

La idea no es crear una segunda capa de aplicación por fuera de Saltcorn. Saltcorn sigue siendo la fuente de verdad.

El plugin permite que un agente pueda:

  • Inspeccionar tablas, vistas, páginas, plugins y menús existentes
  • Crear tablas, campos y relaciones
  • Insertar datos de prueba
  • Crear vistas List, Show, Edit, Tabulator, Kanban, Calendar y Charts
  • Crear páginas y páginas públicas
  • Modificar menús de forma controlada
  • Crear layouts avanzados de formularios
  • Trabajar con relaciones many-to-many
  • Crear triggers, actions y webhooks avanzados (bajo solicitud explícita)
  • Consultar un contrato OpenAPI
  • Seguir una skill diseñada para reducir errores y operaciones peligrosas

Por qué esto ayuda a la IA?

Cuando el agente programa todo desde cero, debe mantener en contexto:

  • Estructura de base de datos
  • Validaciones
  • Formularios
  • Endpoints
  • Estados de UI
  • Permisos
  • Estilos
  • Navegación
  • Reglas de negocio
  • Dependencias
  • Migraciones
  • Convenciones internas

Con Saltcorn, buena parte de eso ya existe como modelo de trabajo. El agente no necesita inventar una arquitectura nueva; necesita describir operaciones concretas sobre Saltcorn.

Esto reduce el riesgo de que el sistema termine dividido en dos capas frágiles:

  1. Una capa de código generada por IA
  2. Una capa de contexto que el agente intenta recordar

Tarde o temprano esa segunda capa se rompe. Con este plugin, Saltcorn guarda la estructura real del sistema y la API permite modificarla de forma explícita.

HTML manual vs request a Saltcorn

Supongamos que queremos un formulario simple de productos con 4 campos.

En HTML podríamos empezar así:

<form method="post" action="/products">
  <label for="code">Código</label>
  <input id="code" name="code" type="text" required>

  <label for="name">Producto</label>
  <input id="name" name="name" type="text" required>

  <label for="stock">Stock</label>
  <input id="stock" name="stock" type="number" min="0">

  <label for="active">Activo</label>
  <input id="active" name="active" type="checkbox">

  <button type="submit">Guardar</button>
</form>
Enter fullscreen mode Exit fullscreen mode

Eso parece poco, pero no incluye:

  • Tabla en base de datos
  • Validaciones persistentes
  • Vista de listado
  • Vista de edición
  • Permisos
  • Modal de creación
  • Menú
  • API
  • Exportación
  • Relación con otras tablas
  • Estilos consistentes con la aplicación

Con savne-saltcorn-agent-api, el agente puede pedirle a Saltcorn que cree la tabla:

{
  "name": "products",
  "label": "Productos",
  "fields": [
    { "name": "code", "label": "Código", "type": "String", "required": true, "unique": true },
    { "name": "name", "label": "Producto", "type": "String", "required": true },
    { "name": "stock", "label": "Stock", "type": "Integer" },
    { "name": "active", "label": "Activo", "type": "Bool" }
  ],
  "dry_run": true
}
Enter fullscreen mode Exit fullscreen mode

Y luego crear vistas básicas:

{
  "table": "products",
  "labels": {
    "view": "Ver",
    "edit": "Editar",
    "delete": "Eliminar",
    "save": "Guardar"
  },
  "dry_run": true
}
Enter fullscreen mode Exit fullscreen mode

En vez de gastar contexto generando HTML, backend, rutas y persistencia, el agente describe la intención. Saltcorn conserva el modelo real y el plugin ofrece una forma segura de operar sobre él.

Despliegue Saltcorn con docker

Para empezar, lo primero que debemos hacer es desplegar nuestra instancia Salcorn y para ello nos apoyaremos en docker y este manifiesto:

# docker-compose.yml 
services:
  postgres:
    image: postgres:16-alpine
    container_name: saltcorn-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - ./saltcorn_pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 10s
      timeout: 5s
      retries: 10
    networks:
      - saltcorn_net
    ports:
      - "5432:5432"

  saltcorn:
    image: saltcorn/saltcorn:latest
    container_name: saltcorn-app
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    command: serve
    environment:
      PGHOST: postgres
      PGPORT: 5432
      PGDATABASE: ${POSTGRES_DB}
      PGUSER: ${POSTGRES_USER}
      PGPASSWORD: ${POSTGRES_PASSWORD}
      SALTCORN_SESSION_SECRET: ${SALTCORN_SESSION_SECRET}
      SALTCORN_FILE_STORE: /opt/saltcorn/files
    volumes:
      - ./saltcorn_files:/opt/saltcorn/files
      - ./saltcorn_external_packages:/opt/saltcorn_external_packages
    ports:
      - "3000:3000"
    networks:
      - saltcorn_net

networks:
  saltcorn_net:
    name: saltcorn_net
Enter fullscreen mode Exit fullscreen mode

Adicional, manejaremos un archivo .env para nuestras variables:

#.env

POSTGRES_DB=saltcorn
POSTGRES_USER=postgres
POSTGRES_PASSWORD=Here_password_Strong
SALTCORN_SESSION_SECRET=Here_Secret_random
Enter fullscreen mode Exit fullscreen mode

Luego de tener nuestros archivos ejecuta los siguientes comandos para desplegar nuestra nueva instancia:

#Solo levantamos postgres
docker compose up -d postgres

# Creación de esquema en Base de datos
# Dale Yes cuando pida la confirmación
docker compose run --rm saltcorn reset-schema

#Reinicio de servicios
docker compose down          
docker compose up
Enter fullscreen mode Exit fullscreen mode

Los comandos anteriores solo se ejecutan la primera vez, luego solo debes ejecutar un docker compose up para que todo funcione.

Si todo fue exitoso, ve a http://localhost:3000 y deberás ver una pantalla para crear tu primer usuario en Saltcorn

Home page

Luego de crear tu usuario, continuemos con la instalación de nuestro plugin.

Instalación desde GitHub

En Saltcorn, abre (http://localhost:3000/plugins/new):

Setup/Modules -> Add another plugin
Enter fullscreen mode Exit fullscreen mode

Usa estos datos:

Nombre: savne-saltcorn-agent-api
Fuente: github
Ubicación: OscarSanchezSavne/savne-saltcorn-agent-api
Versión: v0.2.56
Enter fullscreen mode Exit fullscreen mode

Para seguir la rama principal:

Nombre: savne-saltcorn-agent-api
Fuente: github
Ubicación: OscarSanchezSavne/savne-saltcorn-agent-api
Versión: main
Enter fullscreen mode Exit fullscreen mode

Modules

Después de instalar, reinicia Saltcorn si la interfaz no registra las rutas inmediatamente.

Adicional a nuestro plugin se recomiendan estos plugins para mejorar la experiencia:

  • charts
  • flatpickr-date
  • fullcalendar
  • html
  • json
  • kanban
  • leaflet-map
  • many-to-many
  • markdown
  • material-design
  • mermaid
  • money
  • multi-file-upload
  • pivottable
  • qrcode
  • selectize
  • tabulator
  • time-type

Si todo fue exitoso, podras ver nuestro card:

Module

Al darle click en el icono de interrogación, podrás encontrar la url para la especificaci[on de openapi y de swagger, con lo cuál tendrás más información:

Info module

Las operaciones administrativas requieren token de usuario Saltcorn:

Authorization: Bearer <saltcorn-user-api-token>
Enter fullscreen mode Exit fullscreen mode

El cuál lo puedes obtener a nivel de tu usuario http://localhost:3000/auth/settings, recuerda, el token debe corresponder a un usuario admin:

Create token

Integración en nuestro Agente IA

Para enseñarle a nuestro agente a usar Saltcorn, solo tienes que descargar nuestra skill:

Forma de integrarlo según el agente que uses:

  • Claude Projects / Custom GPTs / Copilot: copia el contenido de SKILL.md directamente en las instrucciones del sistema del agente.
  • Agentes vía API (OpenAI, Anthropic, etc.): pasa el contenido como mensaje del sistema (system role) al inicio de cada conversación.
  • n8n / Make / automatizaciones: usa el archivo como prompt base del nodo de IA.

La skill define:

  • Qué endpoints llamar según la intención
  • Qué parámetros enviar
  • Qué no hacer (dry_run primero, no borrar sin permiso, etc.)
  • Cómo interpretar las respuestas del plugin

Sin esta skill, el agente opera a ciegas. Con ella, sabe exactamente cómo comportarse.

Cómo se lo pides al agente:

Ejemplo 1 — Sistema de inventario:

"Crea una app de inventario con productos, categorías y movimientos de entrada/salida. Cada producto debe tener código, nombre, stock y precio. Quiero una vista Kanban por categoría y un calendario de movimientos."

El agente interpreta, inspecciona el estado actual de Saltcorn, planea las tablas y vistas, y las crea paso a paso con dry_run: true para que revises antes de ejecutar.

Ejemplo 2 — Encuesta pública con validación:

"Necesito una encuesta pública de clima laboral. Que guarde las respuestas anónimas, pero que no permita duplicados por IP en 24 horas. Si la puntuación general es menor a 3, quiero que envíe un webhook a un canal de Slack."

Cierre

No se trata de reemplazar Saltcorn con IA. Se trata de darle a la IA un marco estable donde operar.

Saltcorn aporta la estructura no-code. savne-saltcorn-agent-api aporta una API segura, documentada y pensada para agentes. La skill aporta las reglas de uso para que el agente no tenga que adivinar.

El resultado es una forma más confiable de construir sistemas pequeños y medianos con ayuda de IA, sin obligar al usuario final a convertirse en programador y sin pedirle al agente que cargue todo el sistema en memoria como si fuera magia.

Enlaces relacionados:

Top comments (0)