DEV Community: Spanish Total.js

Total.js AIModel: una base práctica para flujos de trabajo impulsados por IA

Spanish Total.js — Wed, 30 Sep 2026 07:12:48 +0000

La IA se está convirtiendo en una parte habitual del software empresarial. No como un chatbot aislado, sino como una funcionalidad integrada dentro de flujos de trabajo reales:

generación de código
traducciones
automatización del soporte
resúmenes
asistentes internos
análisis de monitorización
revisión de contenidos
procesamiento de documentos
asistentes basados en bases de conocimiento
flujos de trabajo controlados por herramientas

Lo importante no es únicamente llamar a un proveedor de IA. Lo importante es conectar el proveedor correctamente con la aplicación.

Total.js AIModel proporciona a los desarrolladores una base sencilla para crear flujos de trabajo impulsados por IA directamente dentro de aplicaciones Total.js. Permite utilizar modelos de IA con nombre, construir mensajes mediante una API fluida, trabajar con streaming, realizar parsing, obtener información del proceso de razonamiento, utilizar herramientas basadas en contexto y controlar la ejecución mediante acciones de Total.js.

El resultado es sencillo: puedes crear funcionalidades de IA sin distribuir llamadas HTTP específicas de cada proveedor por todo tu código.

Una única capa de IA para tu aplicación

Con AIModel, la implementación del proveedor se registra una sola vez mediante NEWAIMODEL().

NEWAIMODEL('qwen3-coder:480b-cloud', function($, next) {
    // Implementación específica del proveedor
});

Después, la aplicación utiliza el modelo mediante su nombre:

let response = await AIMODEL('qwen3-coder:480b-cloud')
    .system('Eres un desarrollador. Devuelve siempre únicamente código.')
    .user('Crea un ejemplo sencillo de "Hello world" en Node.js.')
    .promise();

Esta es la idea principal: la aplicación no necesita conocer qué endpoint HTTP, token, formato de payload o formato de streaming se utiliza. Ese conocimiento permanece dentro del registro del modelo.

Esto hace que la integración de IA sea más sencilla de mantener, más fácil de desplegar y más sencilla de cambiar posteriormente.

Registra una vez, utiliza en cualquier lugar

NEWAIMODEL() puede registrar uno o varios nombres de modelos y mantener la configuración personalizada en un único lugar.

NEWAIMODEL('qwen3-totaljs:8b', {
    url: 'http://localhost:11434/api/chat',
    temperature: 0
}, function($, next) {

    let opt = {};
    let parser = AIPARSER('ollama');

    $.payload.options = { temperature: $.config.temperature };
    $.payload.stream = true;
    $.payload.think = true;

    parser.on('content', function(event) {
        $.options.stream && $.options.stream(event.delta);
    });

    opt.method = 'POST';
    opt.url = $.config.url;
    opt.timeout = 100000;
    opt.custom = true;
    opt.type = 'json';
    opt.body = JSON.stringify($.payload);
    opt.callback = function(_, response) {
        response.stream.on('data', chunk => parser.write(chunk));
        response.stream.on('end', function() {
            let output = parser.end();
            next(null, output.content);
        });
    };

    REQUEST(opt);

});

Después, cualquier parte de la aplicación puede utilizarlo:

let response = await AIMODEL('qwen3-totaljs:8b')
    .system('Eres un experto en Total.js.')
    .user('Crea una acción sencilla para guardar un contacto.')
    .promise();

El proveedor puede ser local, privado, alojado en la nube o compatible con OpenAI. La aplicación Total.js llama a un modelo por su nombre y continúa trabajando.

Una API fluida para flujos de trabajo de IA

AIModel proporciona una API fluida y práctica para construir conversaciones:

AIMODEL('qwen3-totaljs:8b')
    .system('Eres un asistente de soporte.')
    .user('El usuario no puede restablecer su contraseña.')
    .assistant('Solicita más detalles y mantén la respuesta breve.')
    .user('El usuario dice que el correo de restablecimiento nunca llega.')
    .promise();

Esto hace que las tareas habituales de IA sean fáciles de leer:

generar código
explicar una entrada de log
resumir un ticket
traducir texto
clasificar contenido
preparar una respuesta
extraer campos útiles de una solicitud de un cliente

AIModel se convierte en un componente normal de la aplicación.

Streaming y razonamiento

Muchas funcionalidades de IA ofrecen una mejor experiencia cuando la respuesta se transmite progresivamente. AIModel permite utilizar streaming mediante .stream().

AIMODEL('qwen3-totaljs:8b')
    .system('Eres un desarrollador.')
    .user('Crea un componente de Total.js Flow que ejecute Hello World.')
    .stream(function(line) {
        console.log(line);
    });

Para integraciones de streaming de nivel más bajo, Total.js también proporciona AIPARSER(). Puede analizar los streams de los proveedores y exponer eventos útiles como contenido, razonamiento y llamadas a herramientas.

let parser = AIPARSER('ollama');

parser.on('thinking', function(event) {
    console.log('THINKING:', event.delta);
});

response.stream.on('data', chunk => parser.write(chunk));
response.stream.on('end', function() {
    let output = parser.end();
    console.log(output);
});

Esto resulta útil cuando un proveedor devuelve fragmentos mediante streaming, información de razonamiento o instrucciones para llamar a herramientas. En lugar de escribir un parser personalizado para cada flujo de trabajo, el parser se convierte en parte de la capa de IA de Total.js.

Asistentes conscientes del contexto

El verdadero valor de la IA aparece cuando comprende el contexto propio de la aplicación.

El ejemplo de Peter muestra un patrón sencillo y potente: almacenar contextos en Markdown, analizarlos y exponerlos al modelo como archivos legibles. De esta forma, el asistente puede solicitar exactamente el contexto que necesita.

let context = (await Total.readfile('context.txt', 'utf8')).parseContext();
let items = [];

for (let m of context) {
    items.push('- ' + m.name + ': ' + m.summary);
    AICONTEXT.push(m);
}

Total.actions['AI|Ask'].config.system += '\n\nLos posibles contextos de archivos que se pueden utilizar son:\n\n' + items.join('\n');

Un archivo de contexto puede contener reglas para generar componentes de Flow, scripts de PostgreSQL, convenciones de programación de Total.js o reglas de negocio específicas de una aplicación.

Esto convierte un modelo genérico en un asistente especializado para tu producto.

Herramientas conectadas a las acciones de Total.js

La parte más potente de AIModel es la ejecución de herramientas. En Total.js, las herramientas pueden ser manejadores normales de NEWACTION().

El modelo de IA no ejecuta directamente el código de la aplicación. Solicita una llamada a una herramienta. Total.js genera el esquema de la herramienta a partir de la entrada de la acción, ejecuta la acción y envía el resultado de vuelta al modelo.

Aquí tienes un ejemplo completo:

require('total5');

const TOOLS = {};

NEWACTION('AI', {
    input: '*user,system,tools,model,think:Boolean',
    config: {
        ollama: 'http://127.0.0.1:11434/api/chat',
        model: 'qwen3-totaljs:8b'
    },
    action: function($, model) {

        let history = { messages: [], tools: [], limits: {} };

        model.system && history.messages.push({ role: 'system', content: model.system });

        if (model.tools) {
            let tools = model.tools.split(',').trim();
            for (let tool of tools) {

                let action = Total.actions[tool];

                if (!TOOLS[tool]) {
                    let schema = action.jsinput ? action.jsinput.aitool(tool) : {
                        type: 'function',
                        function: {
                            name: tool,
                            parameters: { properties: {}, required: [] }
                        }
                    };

                    schema.function.description = action.summary || action.name || tool;
                    TOOLS[tool] = schema;
                }

                history.limits[tool] = action.config?.limit == null ? 1000 : action.config.limit;

                if (action.config?.end)
                    history.end = tool;

                history.tools.push(TOOLS[tool]);
            }
        }

        history.messages.push({ role: 'user', content: model.user });

        let opt = {};
        let payload = {};
        let parser = AIPARSER('ollama');

        payload.model = model.model || $.config.model;
        payload.stream = true;
        payload.think = model.think;
        payload.messages = history.messages;
        payload.tools = history.tools;

        opt.method = 'POST';
        opt.url = $.config.ollama;
        opt.timeout = 100000;
        opt.custom = true;
        opt.type = 'json';

        opt.callback = function(_, response) {

            response.stream.on('data', chunk => parser.write(chunk));
            response.stream.on('end', function() {

                let output = parser.end();

                if (output.reasoning === 'tool') {

                    payload.messages.push({
                        role: 'assistant',
                        content: '',
                        tool_calls: output.tools.map(tool => ({
                            function: {
                                name: tool.name,
                                arguments: tool.arguments
                            }
                        }))
                    });

                    output.tools.wait(function(tool, next) {

                        history.limits[tool.name] -= 1;

                        ACTION(tool.name, tool.arguments).callback(function(_, response) {

                            if (tool.name === history.end)
                                output.END = response;

                            payload.messages.push({
                                role: 'tool',
                                name: tool.name,
                                content: JSON.stringify(response)
                            });

                            next();
                        });

                    }, function() {
                        if (output.END) {
                            $.callback(output.END);
                        } else {
                            parser.reset();
                            opt.body = JSON.stringify(payload);
                            REQUEST(opt);
                        }
                    });

                } else
                    $.callback(output);
            });
        };

        opt.body = JSON.stringify(payload);
        REQUEST(opt);

    }
});

Esto crea un flujo completo de IA:

El usuario realiza una pregunta.
El modelo determina que necesita una herramienta.
Total.js valida y ejecuta la acción.
El resultado de la herramienta se envía de vuelta al modelo.
El modelo genera la respuesta final.

Así es como la IA pasa de ser un simple "chat" a convertirse en automatización real dentro de una aplicación.

Prueba completa

Las siguientes acciones son suficientes para probar la funcionalidad. El modelo puede llamar a Math|add y después finalizar el flujo con AI|done.

NEWACTION('Math|add', {
    summary: 'Suma dos números.',
    input: '*a:Number,*b:Number',
    config: { limit: 5 },
    action: function($, model) {
        $.callback({ value: model.a + model.b });
    }
});

NEWACTION('AI|done', {
    summary: 'Finaliza el flujo de IA con la respuesta final.',
    input: '*response',
    config: { end: true, limit: 1 },
    action: function($, model) {
        $.callback(model.response);
    }
});

ACTION('AI', {
    user: 'Utiliza las herramientas y calcula 20 + 22. Finaliza con AI|done.',
    system: 'Eres un asistente matemático. Utiliza siempre las herramientas disponibles.',
    tools: 'Math|add,AI|done',
    think: true
}).callback(function(_, response) {
    console.log(response);
});

Este ejemplo es intencionadamente pequeño, pero el mismo patrón puede ejecutar cualquier acción de Total.js: leer un documento, buscar en una base de datos, crear un ticket, llamar a una API interna o generar un componente de Flow.

Memoria para las conversaciones

Los flujos de trabajo de AIModel también pueden mantener el historial de una conversación.

let history = AIMEMORY[model.id];

if (!history) {
    history = AIMEMORY[model.id] = {
        expire: NOW.add('15 minutes'),
        messages: [],
        tools: []
    };
}

history.messages.push({ role: 'user', content: model.content });

Esto permite crear asistentes que recuerdan la sesión actual, mantienen el contexto de un cliente, continúan tareas de generación de código o guían a un operador a través de un flujo de trabajo.

La memoria puede caducar automáticamente:

ON('service', function() {
    for (let key in AIMEMORY)
        if (AIMEMORY[key].expire < NOW)
            delete AIMEMORY[key];
});

De nuevo, la aplicación mantiene el control.

Qué puedes construir

Con AIMODEL, NEWAIMODEL y AIPARSER, las aplicaciones Total.js pueden incorporar muchas funcionalidades basadas en IA:

un asistente de programación entrenado con las reglas del proyecto
un generador de componentes de Flow
un asistente para scripts de PostgreSQL
un resumidor de tickets de soporte
un asistente de documentación
un flujo de traducción
un asistente para búsquedas de productos
un asistente para análisis de incidencias
un asistente para operadores de back-office
una capa de automatización controlada utilizando acciones de Total.js como herramientas

Este es el potencial práctico de AIModel. No es únicamente un wrapper alrededor de un proveedor de IA. Es una base para crear flujos de trabajo impulsados por IA dentro de aplicaciones reales.

Conclusión

Total.js AIModel proporciona a los desarrolladores una forma limpia, ligera y flexible de añadir capacidades de IA a las aplicaciones Total.js.

NEWAIMODEL() mantiene la integración con el proveedor en un único lugar. AIMODEL() proporciona a la aplicación una API fluida y sencilla. AIPARSER() gestiona el streaming, la información de razonamiento y las llamadas a herramientas. Las acciones de Total.js pueden convertirse en herramientas de IA controladas.

El resultado es una arquitectura práctica para crear funcionalidades de IA útiles, mantenibles y preparadas para software empresarial real.

Total.js Icons

Spanish Total.js — Tue, 29 Sep 2026 20:54:31 +0000

Total.js Icons — Crea interfaces que comunican al instante, con el diseño limpio y expresivo de Total.js Icons.

https://blog.totaljs.com/posts/1554872001ei71b/
https://componentator.com/icons/

icons #totaljs #totaljsicons #svgicons #webicons #icondesign

Total.js LessCode

Spanish Total.js — Mon, 28 Sep 2026 07:37:28 +0000

Total.js LessCode - ¡Desarrolla de forma más inteligente, no más complicada!

Total.js LessCode te ofrece las herramientas que necesitas para crear aplicaciones potentes con el mínimo esfuerzo.

https://www.totaljs.com/lesscode/

lesscode #totaljs #nodejs #code #programming #devtools #codesmarter #codelessdomore

¿Cómo escribir mejores aplicaciones Total.js usando IA?

Spanish Total.js — Thu, 24 Sep 2026 07:30:45 +0000

La IA puede escribir mucho código. Eso no significa necesariamente que pueda escribir buen código Total.js. Y esto es algo que hemos observado repetidamente al utilizar agentes de programación con IA para crear aplicaciones Total.js reales. Si le das a un modelo de IA una funcionalidad y le pides que la implemente en Node.js, normalmente encontrará la forma de hacerlo. Pídele al mismo modelo que implemente algo específicamente en Total.js y la cosa se vuelve más interesante. El modelo conoce JavaScript. Conoce Node.js. Probablemente conoce Express extremadamente bien.

Total.js tiene su propia filosofía. Tiene su propia estructura de aplicaciones, globals, schemas, routing system, QueryBuilder, definitions, modules, plugins, helpers para el sistema de archivos, RESTBuilder, mecanismos de autenticación y muchas otras convenciones.

Un agente de IA que no entienda esas convenciones puede seguir generando código que funcione. El problema es que el resultado a menudo no parece realmente "Total.js".

Así empiezan a aparecer imports innecesarios, capas de servicios inspiradas en Express, clases repository, abstracciones de middleware personalizadas, librerías de acceso directo a bases de datos y dependencias que resuelven problemas que Total.js ya resuelve.

En Total.js empezamos a tratar esto como un problema de contexto en lugar de un problema del modelo.

La pregunta pasó a ser:

¿Cómo hacemos que un agente de programación con IA piense en Total.js antes de empezar a escribir código Total.js?

Hay varias formas de abordar este problema.

Enfoque 1: Fine-tuning de un modelo

El enfoque más ambicioso sería hacer fine-tuning de un modelo de programación open source utilizando aplicaciones Total.js de alta calidad.

En teoría, esto podría enseñar al modelo patrones específicos del framework.

En la práctica, requiere un dataset cuidadosamente seleccionado, una separación clara entre patrones modernos y legacy, una capacidad de cómputo considerable y, aun así, deja abierta la pregunta de si el modelo ha aprendido realmente los principios o simplemente está imitando código.

Para la mayoría de los equipos, este enfoque es simplemente demasiado pesado.

Enfoque 2: RAG

Otra opción es Retrieval-Augmented Generation (RAG).

Podemos indexar la documentación de Total.js, ejemplos y repositorios públicos, e introducir fragmentos relevantes en el contexto del modelo cuando sean necesarios.

Esto ya resulta útil.

Pero sigue teniendo una limitación: la documentación explica las APIs, pero no siempre explica cómo pensar con ellas.

Responde: ¿Qué hace ROUTE()?

Pero no siempre: ¿Cuándo deberíamos utilizarlo y qué deberíamos evitar construir a su alrededor?

Ese vacío nos llevó a un tercer enfoque.

Enfoque 3: Dar al agente un contexto de IA

En lugar de entrenar un nuevo modelo o depender únicamente de retrieval, empezamos a mantener un repositorio que proporciona contexto práctico de ingeniería para agentes de IA que trabajan con Total.js.

El repositorio es:

totaljs/aicontext

La idea es sencilla: no nos limitamos a decirle a la IA que construya esta aplicación utilizando Total.js. Colocamos un conjunto estructurado de conocimientos de ingeniería sobre Total.js directamente dentro del workspace del proyecto y hacemos que forme parte del contexto de trabajo del agente.

El repositorio describe cómo debería estructurarse una aplicación Total.js y cómo deberían abordar los agentes la arquitectura, schemas, actions, controllers, routing, bases de datos, autenticación, operaciones con el sistema de archivos, plugins, funcionalidades en tiempo real, jobs, integración con el frontend y mucho más.

Y, lo que es más importante, incluye explícitamente anti-patterns.
Porque un agente de IA no solo necesita saber qué puede hacer. También necesita saber qué no debería hacer.

Por ejemplo, antes de introducir capas de servicios, abstracciones repository, contenedores de inyección de dependencias, frameworks de middleware, librerías WebSocket o sistemas internos personalizados de require(), el agente debería preguntarse primero:

¿Total.js ya proporciona un mecanismo nativo para esto?

En la mayoría de los casos, la respuesta es sí.

Y esa única restricción mejora significativamente la calidad del código generado.

De dónde surgió todo esto

El repositorio actual aicontext no apareció de la noche a la mañana.

Durante aproximadamente seis meses lo utilizamos directamente en aplicaciones reales.

Cada vez que un agente interpretaba mal una convención de Total.js, introducía un patrón genérico de Node.js donde Total.js ya disponía de una solución nativa o generaba una arquitectura que resultaba ajena al framework, teníamos una oportunidad para mejorar el contexto.

Algunas mejoras fueron manuales. Otras surgieron directamente de problemas encontrados en producción. Algunas se perfeccionaron mediante la colaboración iterativa con la propia IA: analizando su comportamiento, comparando resultados y afinando las instrucciones.

Con el tiempo, se convirtió en una guía de ingeniería viva.

Utilizarlo en un proyecto real

Una configuración práctica sería esta.

Supongamos que estamos desarrollando una aplicación llamada myapp:

myapp/
├── backend/
├── frontend/
├── aicontext/
├── README.md
└── ...

La parte importante es el límite del workspace. Todo el proyecto se encuentra aquí, backend/ contiene la aplicación Total.js, frontend/ puede ser cualquier cosa ---React, React Native, Flutter u otro cliente--- y después añadimos el contexto de IA:

git clone https://github.com/totaljs/aicontext.git

Ahora el agente tiene acceso directo a las directrices de ingeniería de Total.js dentro del workspace.

Antes de iniciar el agente, también recomendamos mantener un README.md claro o un documento de especificaciones de la aplicación en un archivo *.md situado en la raíz del proyecto.

Solo necesita describir:

qué hace la aplicación
funcionalidades principales
expectativas arquitectónicas
restricciones
contexto de la lógica de negocio

Ahora el agente trabaja con tres capas de contexto: especificación de la aplicación, contexto de ingeniería de Total.js, código fuente existente y el agente de programación con IA.

Esto es considerablemente más eficaz que empezar simplemente con:
Construye un marketplace utilizando Total.js.

Utilizarlo con Codex

Esto se vuelve todavía más potente con agentes capaces de inspeccionar todo el workspace. Con Codex, por ejemplo:

codex

Después:

/init

Codex genera sus propias instrucciones para el agente en AGENTS.md basándose en el workspace. Como aicontext/ forma parte de ese workspace, podemos definir explícitamente cuál es su función. No es código de la aplicación. Es la capa de referencia de ingeniería de Total.js.

Un proyecto en evolución

totaljs/aicontext no es un producto terminado.

No debería considerarse definitivo. Total.js evolucionará. Los agentes de IA evolucionarán. Y seguiremos descubriendo mejores formas de expresar el contexto de ingeniería. Animamos a los desarrolladores a clonarlo, utilizarlo con Codex, Claude Code, Grok CLI u otros agentes, aplicarlo en proyectos reales, observar dónde falla o qué partes están incompletas y mejorarlo mediante contribuciones.

Conclusión

Los modelos de IA seguirán mejorando. Pero mejores modelos no significan automáticamente mejor código Total.js. Ahí es donde el contexto importa.

Prueba totaljs/aicontext en un proyecto real. Y cuando tu agente haga algo mal, no te limites a corregir el código: mejora también el contexto.

Publicado originalmente en Total.js Blog.

Enlaces:

Total.js UI Components

Spanish Total.js — Tue, 22 Sep 2026 13:51:26 +0000

Total.js UI Components — Tu interfaz inteligente empieza aquí.

¡Componentes de interfaz modulares para aplicaciones modernas!

https://www.totaljs.com/components/

ui #components #javascript #webdev #html #totaljs #programming #code

TotalVM

Spanish Total.js — Mon, 21 Sep 2026 07:24:27 +0000

TotalVM convierte tu Mac con Apple Silicon en un entorno Linux completo para desarrollo.

Ubuntu o Arch, Docker, PostgreSQL, pgAdmin, Total.js Code y Flow, proyectos compartidos con macOS y todo listo.

https://totalvm.totaljs.es/

TotalJS #TotalVM #Linux #AppleSilicon #Docker

TotalIDE — el IDE nativo para Total.js en macOS.

Spanish Total.js — Sat, 19 Sep 2026 18:06:45 +0000

Desarrolla, ejecuta y depura tus aplicaciones con soporte para Total.js 4/5, jComponent 19/20, debugging, preview, IA, agentes, MCP y modelos locales.

Code. Build. Run. Enjoy.

totalide.totaljs.es

Descargar TotalIDE en la Mac App Store