Category: AI

Cómo crear aplicaciones full stack gratis con Antigravity para MVPs
Cómo crear aplicaciones full stack gratis con Antigravity (No Code)

Tiempo estimado de lectura: 5 min
Ideas clave
- Prioriza el modelado de datos antes de la UI para evitar deuda inmediata.
- Encapsula lógica de negocio en workflows; delega procesos pesados a webhooks cuando el plan gratuito limite.
- Usa integraciones externas para archivos y tareas costosas para mantenerte en el tier gratuito.
- Define criterios claros para migrar a código (tráfico, complejidad algorítmica, cumplimiento).
Tabla de contenidos
Introducción

Cómo crear aplicaciones full stack gratis con Antigravity (No Code) es una decisión de arquitectura, no un atajo. Si tu objetivo es validar una idea rápido, lanzar un MVP interno o iterar diseño de producto sin bloquear a Ingeniería, Antigravity te da el camino: editor visual, workflows y despliegue integrado. Aquí explico cómo hacerlo paso a paso, con buenas prácticas, límites del plan gratuito y criterios claros para migrar a código cuando toque.

Resumen rápido (lectores con prisa)

Antigravity es una plataforma visual que integra base de datos, workflows y frontend para prototipado rápido. Úsala para validar hipótesis, priorizando modelado de datos y encapsulando lógica en workflows; delega procesos pesados a webhooks o servicios externos cuando el plan gratuito sea limitante.
Cómo crear aplicaciones full stack gratis con Antigravity (No Code): visión general

Antigravity condensa frontend, backend y datos en un entorno visual. Técnicamente, reproduce las tres capas clásicas:
- Base de datos visual (esquemas, relaciones).
- Backend en forma de workflows y triggers.
- Frontend con binding de datos y componentes drag‑and‑drop.
No es magia: son abstracciones que generan código y artefactos exportables. La ventaja real es velocidad para prototipar y validar. El coste es control limitado sobre infra y escalado —pero si aplicas criterio, es una herramienta potente para MVPs.
1) Empieza por los datos: modelado como prioridad

No arranques por la UI. Diseña el modelo de datos primero.

Pasos prácticos
- Crea un proyecto y selecciona el plan Free/Starter.
- En “Data” define tus tablas/colecciones. Ej.: Projects, Tasks, Users.
- Tipifica campos (string, number, datetime, boolean). Evita usar campos libres cuando puedas normalizar.
- Define relaciones (1:N, N:M) en la interfaz. Un Project tendrá muchas Tasks.
- Planifica índices si Antigravity lo permite; si no, diseña consultas pensando en paginación.
Por qué: una UI mal ligada a datos mal modelados genera deuda inmediata. Normaliza, evita duplicados y documenta el modelo.
2) Construye la UI con binding de datos (no falsas promesas visuales)

El editor visual es potente si respetas la separación de concerns.

Recomendaciones
- Usa componentes reutilizables: listas, formularios, cards.
- Mapea cada componente a una fuente de datos (Data Source).
- Mantén lógica de presentación fuera de la base de datos: usa campos calculados en la UI, no copias de datos.
- Para estado local (por ejemplo selected_project_id) usa las herramientas de estado que ofrece la plataforma, no variables ad-hoc.
Ejemplo

Ejemplo: una lista de proyectos (componente “Repeating Group”) con binding al Projects y un evento que actualiza selected_project_id para filtrar Tasks.
3) Workflows: la lógica de negocio sin servidor

Los workflows reemplazan funciones server-side. Úsalos para lógica de negocio, integraciones y validaciones.

Patrones prácticos
- Trigger on event (click, submit, schedule).
- Actions: create/update/delete, call external API, send email.
- Condicionales: implementa reglas claras (ej. si amount > 1000 → marcar VIP).
- Atomicidad: agrupa acciones que deban ejecutarse juntas y contempla rollback o compensación si la plataforma lo soporta.
Si un workflow se hace demasiado complejo o consume muchas ejecuciones del plan gratuito, delega a un webhook y procesa fuera en una herramienta como n8n o un microservicio propio.
4) Integraciones y almacenamiento eficiente (mantén lo gratis gratis)
- Almacena archivos en Cloudinary o S3; guarda solo URLs.
- Usa webhooks a n8n o servicios gratuitos para tareas pesadas (p. ej. generación de PDFs).
- Aprovecha hosting gratuito: Netlify Drop o Firebase Spark para backends ligeros.
Evita subir blobs o logs pesados a la base de datos de Antigravity: esos límites suben rápido.
5) Seguridad, permisos y auditoría
- Aplica principio de menor privilegio al habilitar conectores (Google Drive, Gmail).
- Configura roles (admin, editor, reader) y controla qué workflows pueden leer/escribir datos sensibles.
- Habilita logs y guarda evidence (diffs, screenshots) de despliegues si la plataforma lo ofrece.
6) Criterio de migración: cuándo salir del No Code

Antigravity acelera ideas, pero hay señales claras para migrar:
- Tráfico real > 5–10k MAU o necesidades de performance específicas.
- Lógica algorítmica compleja (simulaciones, ML, procesamiento batch).
- Requisitos de compliance o auditoría estrictos.
- Costes de vendor que, al escalar, superen el coste de reescribir en código.
Plan mínimo de migración: exporta artefactos, documenta modelo de datos y workflows. Mueve a Next.js/Supabase o Next.js + Firebase según necesidades.
Ejemplo rápido: MVP To‑Do con auth y deploy gratis
1. Modelo: Users, Tasks (userId FK).
2. UI: lista de tareas vinculada a Tasks y formulario para crear.
3. Workflow: on submit → create Task → if due_date < ahora → mark urgent.
4. Integración: autenticación con provider gratuito (si Antigravity ofrece, si no, usa Netlify Drop o Firebase o terceros como Clerk/Firebase).
5. Deploy: usa el subdominio miapp.antigravity.app o export ZIP y deploy a Netlify Drop.
Conclusión: Antigravity como acelerador de validación

Cómo crear aplicaciones full stack gratis con Antigravity (No Code) es menos sobre evitar código y más sobre aplicar disciplina arquitectónica en un entorno visual. Prioriza datos, encapsula lógica en workflows bien pensados, delega procesos pesados a webhooks y controla permisos. Úsalo para validar hipótesis rápido; cuando el producto demuestre tracción, prepara la migración con la documentación que ya deberías haber generado.
Recursos útiles
Para continuidad y experimentación con workflows y automatizaciones relacionadas con los temas tratados (integraciones, webhooks y orquestación), considera explorar recursos adicionales y pruebas de concepto en Dominicode Labs como continuación lógica del enfoque aquí descrito.
FAQ
¿Qué es Antigravity y para qué sirve?

Antigravity es una plataforma visual que integra modelado de datos, workflows y un editor frontend para construir aplicaciones full stack sin escribir código. Sirve para prototipado rápido, MVPs y validación de ideas.

¿Por qué empezar por los datos?

Porque un modelo de datos sólido evita deuda técnica, duplicados y problemas de integración con la UI. Diseñar esquemas y relaciones primero facilita consultas eficientes y mantenimiento.

¿Cuándo debo delegar un workflow a un webhook?

Cuando la lógica sea demasiado compleja, consuma muchas ejecuciones del plan gratuito o requiera procesamiento pesado. En esos casos envía datos a un servicio externo (por ejemplo n8n) o un microservicio propio.

¿Cómo mantengo el proyecto en el plan gratuito?

Almacena media en servicios externos (Cloudinary o S3), usa webhooks para tareas costosas y aprovecha hosting gratuito como Netlify Drop o Firebase Spark.

¿Qué incluye el plan mínimo de migración?

Exporta artefactos, documenta el modelo de datos y workflows y selecciona destino (por ejemplo Next.js + Supabase o Next.js + Firebase). Prioriza migrar la lógica crítica y los datos exportables primero.

¿Qué herramientas externas recomiendan para almacenamiento y hosting?

Para media: Cloudinary. Para workflows externos: n8n. Para hosting y deploy rápidos: Netlify Drop y Firebase.
February 13, 2026
8 casos prácticos de uso de ChatGPT Agent para desarrolladores
8 formas increíbles de usar ChatGPT Agent en 2026 (Modo Agente explicado)

Tiempo estimado de lectura: 6 min
- Ideas clave:
- Un ChatGPT Agent es una arquitectura: LLM + herramientas + memoria + controlador de ejecución.
- Casos prácticos incluyen productividad, investigación, presentaciones, finanzas, viajes, contenido, ventas y monitorización.
- Diseño seguro y gobernanza (principio de menor privilegio, autenticación, observabilidad) son críticos.
Tabla de contenidos
Introducción

“8 formas increíbles de usar ChatGPT Agent en 2026 (Modo Agente explicado)” aparece aquí porque lo vamos a tratar con criterio técnico, no como hype. En 2026 un ChatGPT Agent deja de ser un “chat” y pasa a ser un ejecutor autónomo: recibe un objetivo, orquesta herramientas y entrega resultados reales.

A continuación explico la arquitectura mínima, requisitos prácticos y ocho casos de uso aplicables a equipos de producto, devs y Tech Leads —con ejemplos accionables y riesgos técnicos que debes medir.

Resumen rápido (lectores con prisa)

Qué es: Un agente es un sistema compuesto por un LLM conectado a herramientas, memoria y un controlador de ejecución.

Cuándo usarlo: Cuando necesites ejecutar objetivos autónomos que integren múltiples fuentes y acciones (investigación, automatización, monitorización).

Por qué importa: Reduce semanas de trabajo a horas/minutos y habilita pipelines reproducibles.

Cómo funciona: Ciclo plan→act→observar→corregir con herramientas externas y persistencia de estado.

Qué es un ChatGPT Agent y cómo funciona técnicamente

Un Agent = LLM + herramientas + memoria + controlador de ejecución.

Componentes técnicos

LLM

LLM: GPT‑4o/o1 u otro modelo que razone en bucles.

Herramientas

Herramientas: navegador controlado, intérprete de Python, APIs (OpenAI Agents guide), n8n, Zapier.

Memoria/estado

Memoria/estado: persistencia de contexto y logs de acciones.

Controlador

Controlador: ciclo plan→act→observar→corregir (ReAct/OODA).

Requisitos prácticos
- Suscripción ChatGPT Plus/Team/Enterprise.
- Conectores habilitados (Google Workspace, Zapier).
- Permisos explícitos para ejecutar código y acceder a datos.
- Documentación útil: OpenAI Agents guide, n8n, Zapier.
Diseño seguro: permisos, auditoría y límites
- Principio de menor privilegio: activa solo los conectores imprescindibles.
- Autenticación: OAuth para Google APIs, claves rotadas para proveedores externos.
- Observabilidad: logueo estructurado de acciones y outputs; guarda hashes de archivos generados.
- Cuotas y rate limiting: controla llamadas a APIs para evitar costes descontrolados.
Ocho casos prácticos

Ahora sí: ocho casos prácticos, con foco en implementación real y valor medible.

1. Productividad personal: briefing diario automatizado

Objetivo: “Genera mi briefing diario a las 8:00 con acciones desde email y calendario.”

Implementación:
- Conector Gmail + Calendar.
- Filtro por remitentes VIP y por reuniones con alta prioridad.
- Salida: Markdown/Google Doc con 5 puntos accionables.
Por qué funciona: reduce overhead de triage de correo y acelera decisiones del día.

2. Investigación profunda: informe técnico en horas

Objetivo: “Analiza adopción de WebAssembly en infra server-side y genera matriz de pros/cons.”

Implementación:
- Browser tool para GitHub, RFCs, blogs.
- Intérprete Python para ejecutar pruebas ligeras (benchmarks de ejemplo).
- Salida: PDF con referencias y tabla CSV.
Valor: minutos en vez de días para hallazgos reproducibles.

3. Presentaciones automáticas: PPTX con datos reales

Objetivo: “Crea 12 slides sobre microfrontends, incluye diagramas y gráficos.”

Implementación:
- Generación de diagramas (Mermaid→SVG) y gráficas con Python (matplotlib/Plotly).
- Librerías como python‑pptx para compilar .pptx.
- Entrega lista para revisión, no diseño final.
Beneficio: reduce 60–80% del tiempo de montaje de presentaciones técnicas.

4. Finanzas: auditoría automática de P&L

Objetivo: “Analiza CSV trimestral y detecta desviaciones >15%.”

Implementación:
- Pandas en el entorno del agente para limpieza y detección de outliers.
- Export a Google Sheets + visualizaciones.
Riesgo: validar transformaciones y contar con pruebas unitarias en scripts del agente.

5. Viajes y logística: itinerarios optimizados

Objetivo: “Planifica viaje devrel: costes, horarios y proximidad a venue.”

Implementación:
- APIs de vuelos/hoteles + Google Maps.
- Generación de opciones A/B y calendario con enlaces de reserva.
Útil para: equipos con viajes frecuentes y restricciones presupuestarias.

6. Creación de contenido: pipeline editorial completo

Objetivo: “Planifica y redacta 4 posts SEO sobre n8n para Q1.”

Implementación:
- API de keyword research + generación de outlines.
- Borradores en Markdown y miniaturas generadas por modelo de imágenes.
- Integración con CMS via Zapier/n8n.
Escala: editorial sin multiplicar equipos.

7. Outreach y ventas: SDR autónomo

Objetivo: “Encuentra 10 fintechs España Serie A y redacta emails personalizados.”

Implementación:
- Data sources: Crunchbase/Dealroom + LinkedIn scraping controlado.
- Plantillas personalizadas con variables extraídas.
Cuidado legal: verifica términos de uso de fuentes y cumplimiento GDPR.

8. Monitorización recurrente: vigía 24/7

Objetivo: “Alertarme si aparece un piso 3 camas por debajo de X en barrio Y.”

Implementación:
- Búsquedas programadas, deduplicación y umbrales de notificación.
- Notificaciones vía Slack/email solo si condicionales se cumplen.
Resultado: alertas de alto valor, menos ruido.

Limitaciones y métricas que importan
- Coste por ejecución: controla llamadas a APIs y uso de cómputo.
- Fiabilidad de datos externos: siempre valida con checkpoints humanos.
- Métricas operativas: latencia de endpoints, tasa de éxito del workflow, número de correcciones humanas.
Conclusión: pasar de promter a manager de objetivos

ChatGPT Agent es arquitectura, no magia. Para sacarle partido necesitas objetivos claros, conectores bien gobernados y pipelines automatizados (n8n es un buen socio). Empieza por un caso pequeño (briefing o investigación). Implementa logs y validaciones. Y sí: esto no acaba aquí —en el próximo artículo mostraremos cómo integrar agentes con n8n y pruebas automatizadas para llevar estos flujos a producción.

Dominicode Labs

Si trabajas con automatización, agentes o workflows y quieres ejemplos reproductibles y patterns de ingeniería, echa un vistazo a Dominicode Labs. Es una continuación lógica para experimentar con pipelines y pruebas.

FAQ
¿Qué es exactamente un ChatGPT Agent?

Un Agent es una arquitectura compuesta por un LLM conectado a herramientas externas, memoria para persistir estado y un controlador que ejecuta ciclos de planificación y corrección.

¿Cuándo debería usar un agente en vez de un script programado?

Usa un agente cuando el flujo requiere razonamiento iterativo, acceso a múltiples fuentes y la capacidad de corregir acciones en tiempo real. Para tareas deterministas y simples, un script puede ser suficiente.

¿Qué permisos requiere un agente para acceder a Google Workspace?

Requiere OAuth con scopes mínimos necesarios (principio de menor privilegio). No des permisos de escritura si solo necesitas lectura.

¿Cómo audito las acciones de un agente?

Registra logs estructurados de cada acción y su output, guarda hashes de archivos generados y conserva trazas del plan→act→observar→corregir.

¿Cuáles son los riesgos legales al usar scraping en flujos de outreach?

Verifica términos de uso de las fuentes, respeta restricciones de scraping y considera cumplimiento GDPR cuando proceses datos personales.

¿Qué métricas operativas debo monitorizar?

Latencia de endpoints, tasa de éxito del workflow, número de correcciones humanas y coste por ejecución.
February 12, 2026
Utiliza Gemini para Estrategias de Marketing Efectivas
Cómo puedo usar Gemini para marketing?

Tiempo estimado de lectura: 6 min
- Gemini como motor de tareas automatizadas en marketing.
- Ventajas de contexto largo y multimodalidad nativa.
- Casos de uso prácticos implementables.
- Integración técnica a través de APIs y orquestación.
- Costos y criterios para la elección de tareas a automatizar.
Tabla de contenidos
Qué hace distinto a Gemini (y por qué importa para marketing)

Gemini combina tres ventajas relevantes para marketing técnico:
- Ventana de contexto muy larga (hasta millones de tokens) que reduce la necesidad de chunking y RAG para datasets grandes.
- Multimodalidad nativa: texto, imágenes, audio y video se procesan sin pasos intermedios.
- Salidas estructuradas (JSON mode / function calling) que facilitan integración directa con sistemas.
Fuentes oficiales: Google AI Studio y Vertex AI docs.

Estas capacidades convierten a Gemini en un motor para tareas que antes requerían arquitectura compleja: auditorías de contenido masivo, análisis de VoC y generación de assets multimedia a escala.

Tres casos de uso prácticos (implementables)

1) Auditoría de contenido masiva

Workflow: exporta tus últimos N artículos (HTML/PDF) → Request a Gemini con todo el corpus → salida en JSON con temas, gaps y enlaces rotos.

Beneficio: detectas inconsistencias de tono y contenido redundante en una pasada, sin montar un vector DB. Ideal para calendarios editoriales y SEO técnico.

2) Repurposing multimodal: video → artículos → social

Workflow: subes un webinar (mp4) al endpoint de Gemini → pides timestamps, 3 insights técnicos y un hilo de Twitter + descripción YouTube optimizada.

Beneficio: reduces coste y latencia de generar assets. Gemini “ve” diapositivas y transcribe/extrae contexto, creando versiones para distintos canales sin transcriptor externo.

3) Personalización de outreach a escala (integrado con n8n)

Arquitectura mínima:
- Trigger: nuevo lead en CRM.
- Enriquecimiento: scraping básico de la web del lead.
- Gemini Flash: análisis rápido de la landing.
- Gemini Pro: genera correo personalizado (JSON con asunto, body, 3 bullets técnicos).
- n8n: orquesta revisión humana y envíos vía API de tu ESP.
n8n: perfecto para orquestar sin reinventar la infraestructura. Usa nodos HTTP para llamar a Vertex AI o Google AI Studio.

Cómo integrar técnicamente (API + orquestación)
1. Registra proyecto en Google Cloud y usa Vertex AI o Google AI Studio.
2. Usa SDKs oficiales (@google/genai) o llamadas REST a generativelanguage.googleapis.com.
3. Diseña prompts con grounding: envía contexto estructurado (meta + fragmentos) y solicita JSON. Ejemplo de prompt: “Devuelve {subject, bullets[], cta} en JSON, respetando estos hechos: …”.
Mini ejemplo JS (esqueleto):

import { GoogleGenAI } from “@google/genai”;

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_KEY });

const resp = await ai.models.generateContent({ model: “gemini-2.5-flash”, contents: “…” });

Para producción, añade retries, idempotency y límites de tokens.

Costos, seguridad y criterios para elegir tareas a automatizar
- Costos: usa modelos Flash/Lite para tareas de baja latencia; reserva Pro para razonamiento profundo. Mide tokens por flujo y calcula coste por lead.
- Seguridad: revisa permisos OAuth, enmascara PII antes de enviar y habilita logging controlado en Vertex AI.
- Criterio: automatiza tareas repetitivas y de alto volumen (análisis VoC, A/B copy generation, repurposing). No uses IA donde la verificación factual sea crítica sin human-in-the-loop.
Dominicode Labs: de la prueba al sistema productivo

Diseñar flows que integren Gemini, métricas y orquestación no es trivial. En Dominicode Labs construimos blueprints de n8n + Gemini que ya solucionan:
- Ingestion de data (sitemaps, CSVs, videos).
- Orquestación de prompts y validación humana.
- Outputs estructurados listos para pipelines de marketing.
Si tu objetivo es pasar de experimentos con prompts a sistemas repetibles y observables, Dominicode Labs ofrece templates y guías para acelerar esa transición sin vendor lock-in.

Conclusión: usar Gemini para marketing con criterio

Gemini no es un simple generador de textos; es una capa de razonamiento y procesamiento multimodal. Úsalo para: procesar grandes volúmenes de contenido, transformar multimedia en assets reutilizables y personalizar outreach mediante pipelines orquestados (n8n). El valor real aparece cuando la IA forma parte de una arquitectura medible: costos por token controlados, human-in-the-loop donde importa y observabilidad de resultados. Eso convierte experimentos en ventaja competitiva.

FAQ
¿Qué es Gemini y cómo se diferencia de otros LLMs?

Gemini es un modelo de lenguaje multimodal de Google que combina procesamiento de texto, imágenes, audio y video en un solo sistema, permitiendo integra contenido de manera más efectiva.

¿Cuál es el valor de usar Gemini en marketing?

El valor radica en su capacidad para realizar tareas que típicamente requieren arquitecturas complejas, como auditorías masivas y generación de contenido multicanal a escala.

¿Cómo puedo iniciar con Gemini en mis proyectos?

Puedes comenzar registrando un proyecto en Google Cloud, utilizando las APIs de Vertex AI o Google AI Studio, y aplicando los SDKs proporcionados.

¿Cuáles son las mejores prácticas para integrar Gemini?

Diseña prompts claros que incluyan contexto estructurado, y asegúrate de añadir elementos de retry y control de tokens para mantener eficiencia y coste manejable.

¿Qué costos debo considerar al utilizar Gemini?

Es importante evaluar la latencia de tareas, utilizando modelos adecuados para cada necesidad y controlando los tokens usados por lead para calcular costos eficaces.
February 10, 2026
Cómo Generar Clientes API con OpenAPI
Generación de clientes API OpenAPI para Angular

La Generación de clientes API OpenAPI para Angular reduce la fricción entre frontend y backend convirtiendo la especificación OpenAPI en servicios, modelos y la capa de red completa de tu aplicación. Si la introducción no lo dice claro: genera el cliente, no copies interfaces a mano. Esto evita rupturas en runtime, recupera tipado estricto y convierte la API en la única fuente de verdad.

Tiempo estimado de lectura: 4 min
- Ideas clave:
- Generar el cliente desde OpenAPI mantiene un tipado 100% fiel y reduce bugs por discrepancias entre equipos.
- Usa herramientas maduras (OpenAPI Generator) para control a largo plazo; commitea el cliente generado y crea wrappers para extensiones.
- Protege el contrato en CI: regenera y falla el pipeline si hay diffs.
- Aplica patrones: base URL dinámica, interceptor para fechas y string enums para mejores tipos TS.
Resumen rápido (lectores con prisa)

Qué es: Producción automática de clientes TypeScript/Angular desde una spec OpenAPI.

Cuándo usarlo: Siempre que frontend y backend evolucionen en paralelo y quieras una única fuente de verdad para la API.

Por qué importa: Evita errores por desalineación, asegura tipado fiel y facilita detección temprana de breaking changes en CI.

Cómo funciona: Una CLI genera modelos, servicios y módulos Angular a partir de un JSON/YAML OpenAPI; se integra con Dependency Injection y HttpClient.

Generación de clientes API OpenAPI para Angular: por qué importa

En equipos paralelos, el frontend comienza antes que el backend y viceversa. Sin una fuente de verdad única, los cambios sutiles (un campo renombrado, una paginación distinta) provocan bugs que no se detectan hasta producción.

Beneficios técnicos
Tipado 100% fiel a la especificación.

Servicios Angular idiomáticos (HttpClient, DI).

Detección temprana de breaking changes en CI.

Menos boilerplate y menos deuda técnica.
Fuentes útiles
OpenAPI Generator

npm package

OpenAPI Spec

Angular DI
Herramientas recomendadas

– OpenAPI Generator (recomendado para empresas): maduro, configurable y soportado por la comunidad.

– ng-openapi-gen: más idiomático para Angular, menos configurable.

– Orval: buena opción si trabajas multi-framework (React/Vue + Angular).

Recomendación práctica: usa OpenAPI Generator si buscas control y estabilidad a largo plazo.

Flujo mínimo práctico con OpenAPI Generator
1. Exporta o publica tu spec en JSON/YAML (p. ej. /swagger.json).
2. Añade la CLI como devDependency:
```
npm install -D @openapitools/openapi-generator-cli
```
3. Configura un archivo (infra-as-code), ejemplo openapitools.json:
```
{
  "generator-cli": {
    "generators": {
      "v1": {
        "generatorName": "typescript-angular",
        "inputSpec": "api-specs/openapi.json",
        "output": "src/app/core/api/v1",
        "additionalProperties": {
          "ngVersion": "16.0",
          "fileNaming": "kebab-case",
          "stringEnums": true
        }
      }
    }
  }
}
```
4. Añade script en package.json:
```
"scripts": {
  "api:generate": "openapi-generator-cli generate"
}
```
5. Ejecuta npm run api:generate. Resultado: src/app/core/api/v1 con models/, services/ y api.module.ts.

Integración en Angular (ejemplo)

Configura el módulo generado en tu AppModule/CoreModule:
```
import { ApiModule, Configuration } from './core/api/v1';
@NgModule({
  imports: [
    ApiModule.forRoot(() => new Configuration({ basePath: environment.apiUrl }))
  ]
})
export class CoreModule {}
```
Uso en componentes (inyección del servicio generado):
```
constructor(private usersService: UsersService) {}
ngOnInit() {
  this.usersService.getUsers().subscribe(users => this.users = users);
}
```
Decisiones de arquitectura y buenas prácticas
Commitea el código generado. Razón: reproducibilidad y revisiones PR que muestran cambios en el contrato. Tener el cliente en el repo permite build inmediato tras git clone.

No edites la carpeta generada. Crea wrappers o servicios “decorator” para añadir lógica (caching, retries, mapping).

Base URL dinámica: inyecta Configuration con environment.apiUrl.

Fechas: el spec transmite fechas como strings. Aplica un HttpInterceptor que transforme ISO strings a Date para evitar parsing repetido.

Enums: activa stringEnums para mejores tipos TS.

Naming collisions: usa additionalProperties (prefijos/sufijos) para evitar choques.
Ejemplo rápido de interceptor para fechas:
```
intercept(req, next) {
  return next.handle(req).pipe(map(event => {
    if (event instanceof HttpResponse && typeof event.body === 'object') {
      traverseAndConvertDates(event.body);
    }
    return event;
  }));
}
```
CI/CD: proteger el contrato

Añade paso en CI para regenerar y comprobar diffs. Ejemplo GitHub Actions snippet:
```
- run: npm ci
- run: npm run api:generate
- run: git diff --exit-code src/app/core/api || (echo "API client changed but not committed" && exit 1)
```
Si hay cambios, el pipeline falla y el equipo revisa la especificación o commitea el cliente actualizado.

Errores comunes y cómo evitarlos
Editar el código generado → perderás cambios en la próxima generación. Solución: wrappers.

No commitear el cliente → builds frágiles. Solución: commitea.

Tratar fechas como strings en toda la app → lógica dispersa. Solución: interceptor centralizado.

Ignorar versionado de API → mezclar v1 y v2 sin control. Solución: carpetas /v1 /v2 y switch configurable.
Conclusión

La generación de clientes OpenAPI para Angular transforma especificaciones en código útil, confiable y mantenible. No es una moda: es una práctica de ingeniería que reduce errores, acelera el desarrollo y deja claro quién es responsable del contrato. Implementa la generación con OpenAPI Generator, commitea el cliente, encapsula extensiones y protege el flujo con CI. Tu equipo y tu base de código te lo agradecerán.
FAQ
¿Por qué generar el cliente en lugar de copiar interfaces?

Generar garantiza que el tipado refleje exactamente la especificación OpenAPI, evitando discrepancias que provocan errores en runtime y mejorando la detección de breaking changes.

¿Debo commitear el código generado?

Sí. Commitear el cliente permite reproducibilidad, revisiones en PR y builds inmediatos tras clonar el repositorio.

¿Qué herramienta recomiendan para empresas?

OpenAPI Generator es recomendado para empresas por ser maduro, configurable y con soporte comunitario. Otras opciones como ng-openapi-gen u Orval pueden encajar según necesidades.

¿Cómo manejo fechas provenientes del backend?

Aplica un HttpInterceptor que recorra las respuestas y convierta ISO strings a objetos Date para evitar parsing repetido y lógica dispersa.

¿Cómo protejo el contrato en CI/CD?

Incluye un paso que regenere el cliente y falle si hay diffs, forzando al equipo a revisar y commitear cambios en el cliente o la especificación.

¿Qué hago si necesito lógica adicional sobre los servicios generados?

No modifiques la carpeta generada. Crea wrappers o servicios “decorator” para añadir caching, retries o mapping sin perder la capacidad de regenerar el cliente.
February 10, 2026
Cómo los desarrolladores pueden mejorar su programación colaborando con la IA
Acabo de aprender a programar, y ahora la IA programa mejor que yo, ¿Qué puedo hacer?

Tiempo estimado de lectura: 5 min
- La sintaxis dejó de ser la ventaja: la IA genera boilerplate y código correcto rápidamente; tu valor se traslada a criterio técnico y arquitectura.
- Prioriza sistemas y debugging: aprende a diseñar, orquestar y romper para arreglar sistemas reales.
- Especialízate en áreas que la IA no automatiza bien: seguridad, observabilidad, integración y arquitectura.
- Trabaja con la IA como asistente: pide tests primero, prototipa con LLMs y refactoriza aplicando patterns.
Introducción

Acabo de aprender a programar, y ahora la IA programa mejor que yo, ¿Qué puedo hacer? Si esa frase te ronda la cabeza, respira: no es el fin, es el punto de inflexión. La IA escribe mejor sintaxis y genera boilerplate en segundos. Tu ventaja competitiva es ahora otra: criterio técnico, diseño de sistemas y orquestación.

Este texto no es consuelo vacío. Es un plan operativo para dejar de competir con los autocompletados y empezar a liderar lo que la IA genera.

Resumen rápido (lectores con prisa)

Qué es: Cambio donde la generación de código vía IA convierte la sintaxis en commodity.

Cuándo usarlo: Cuando la IA acelera prototipos y necesitas control, calidad y diseño de sistemas.

Por qué importa: Porque el valor real pasa a la arquitectura, orquestación, seguridad y observabilidad.

Cómo actúo: Aprende patterns, rompe y arregla sistemas, pide tests primero y especialízate en áreas no automatizadas.

Acabo de aprender a programar, y ahora la IA programa mejor que yo, ¿Qué puedo hacer? — el cambio real

La realidad es brutal pero simple: escribir código correcto dejó de ser escaso. Herramientas como GitHub Copilot, ChatGPT o Claude resuelven la mayor parte de las tareas de sintaxis y plantillas. Eso convierte la habilidad de teclear en una commodity.

Pero el software no es solo líneas ejecutables. Es:
- Decidir arquitectura.
- Diseñar flujos de datos.
- Evitar que una “mejora rápida” rompa TODO.
- Traducir problemas de negocio en soluciones técnicas fiables.
Si la IA es la máquina de escribir, tú debes convertirte en el editor, el arquitecto y el controlador de calidad.

Qué dejar de hacer y qué empezar a practicar hoy

1) Deja de competir en la cantera.
No gastes tiempo memorizando APIs que la IA ya conoce. Apréndelas a nivel conceptual: ¿qué hace y por qué elegirla?

2) Empieza a leer arquitectura, no snippets.
Aprende patterns (Clean Architecture, Hexagonal, CQRS) y por qué existen. La IA puede generar un endpoint; no decidirá cómo encaja en tus dominios y límites contextuales.

3) Haz del debugging tu ventaja competitiva.
Genera código con IA. Arranca el proyecto, rompe cosas a propósito (race conditions, concurrencia, límites de memoria) y arregla esos fallos. La habilidad para diagnosticar sistemas dinámicos mantiene tu valor.

Cuatro áreas donde tu criterio es irremplazable

Arquitectura de software

Elección de bases de datos, particionado, estrategia de caché.

Integración y orquestación

Workflows, colas, compensaciones y retry logic (aprende n8n).

Seguridad y compliance

Identificar vulnerabilidades reales (OWASP Top 10).

Observabilidad y SLOs

Diseñar alertas accionables, trazabilidad y dashboards (Prometheus/Grafana).

Estas no son “habilidades blandas”; son el núcleo técnico que la IA no automatiza bien.

Roadmap práctico (90 días)

Mes 0: herramientas y mentalidad
- Instala Copilot/Cursor en tu IDE. Úsalos como asistentes, no como reemplazo.
- Aprende a escribir prompts técnicos: especifica inputs, outputs, constraints y tests.
Mes 1: fundamentos sólidos
- Profundiza en HTTP internals, asincronía, y modelos de concurrencia.
- Haz 3 ejercicios de debugging donde rompas y arregles intencionadamente.
Mes 2: sistemas y orquestación

Construye una app que integre Next.js + Supabase + un workflow en n8n.

Añade tests end‑to‑end (Cypress) y unitarios (Jest). Pide a la IA que genere tests y tú revísalos.

Mes 3: especializa y publica
- Elige un nicho: performance (Web Vitals: Web Vitals), seguridad, automatización.
- Contribuye a un repo open source y haz PRs con reviews humanos.
Cómo trabajar con la IA, no contra ella
- Pide tests primero: solicita que la IA genere tests unitarios y funcionales; tú validas casos límite.
- Usa la IA para prototipar, no para la versión final: genera el primer draft y refactorízalo aplicando patterns.
- Versiona prompts y resultados: guarda los prompts que funcionan en tu repo y documenta por qué un resultado es correcto o no.
- Automatiza orquestación: conecta agentes/LLMs a pipelines con n8n o Genkit para casos repetibles.
Señales de que es hora de migrar a código “puro”

La IA acelera prototipos, pero llega un momento en que necesitas control total:
- Tráfico real que exige optimización de costes/latencia.
- Requisitos regulatorios o de seguridad que demandan auditorías exhaustivas.
- Lógica de negocio compleja que requiere pruebas de rendimiento y reproducibilidad.
Si alcanzas cualquiera de estos puntos, prepara una migración: exporta modelos de datos, tests y workflows. Tener artefactos bien documentados hace la transición viable.

Cierre — qué hacer ahora mismo

No te rindas porque la IA escribe mejor funciones. Aprende a:
- Pedir código con intención.
- Romper el código y arreglarlo.
- Diseñar sistemas y orquestar procesos.
Empieza hoy: genera un proyecto con IA, rómpelo deliberadamente y arregla lo que falle. Ese bucle —generación, rotura, reparación— es la nueva escuela del desarrollador que quiere ser indispensable.

Si trabajas con automatización, agentes o workflows (por ejemplo con n8n o Genkit), puede ser útil explorar recursos y experimentos prácticos que complementen este plan. Revisa Dominicode Labs para ejemplos de integración y orquestación aplicados a pipelines reales. Considera documentar prompts y pipelines allí como parte de tu repositorio de conocimiento.

FAQ
Respuesta: No, no dejes de aprender APIs a nivel conceptual. Evita memorizarlas; en su lugar entiende qué hacen, sus trade-offs y cuándo elegir una sobre otra.

Respuesta: Prioriza según impacto: sistemas con alto tráfico, requisitos regulatorios o donde la seguridad/fiabilidad son críticas. También considera lo que te resulta más interesante y donde puedas aportar juicio técnico.

Respuesta: Romper el código significa inducir fallos deliberados (ej.: condiciones de carrera, límites de memoria, fallos de red) para practicar diagnóstico y mitigación. Es una forma práctica de consolidar habilidades de debugging.

Respuesta: Pide a la IA que genere tests antes de código de producción: unitarios y funcionales con casos límite. Tú debes revisar, completar casos faltantes y validar supuestos arquitectónicos.

Respuesta: Migra cuando haya tráfico real que exija optimización, requisitos regulatorios o lógica de negocio compleja que necesite reproducibilidad y pruebas de rendimiento.

Respuesta: No necesariamente. La especialización te hace más valioso en áreas críticas; además puedes combinar especialización con contribuciones generales (por ejemplo, PRs en proyectos open source).
February 6, 2026
Cómo crear tu primer agente con Google ADK usando Firebase Genkit
Como crear tu primer agente con Google ADK ?

Como crear tu primer agente con Google ADK ? La respuesta práctica hoy es usar Firebase Genkit: el framework code‑first de Google para construir, testear y desplegar agentes de IA en producción. Aquí tienes una guía técnica, paso a paso, pensada para desarrolladores y tech leads que quieren pasar de experimentos a agentes confiables y auditables.

Resumen rápido (lectores con prisa)

Firebase Genkit es un Agent Development Kit (ADK) que estructura agentes como Flows tipados, soporta tool calling y trazabilidad. Úsalo cuando necesites agentes mantenibles, testeables y auditables con deploy serverless. Funciona conectando Flows tipados con herramientas externas y desplegando como funciones HTTP.

Qué es: un framework code‑first para agentes de IA. Por qué: trazabilidad, tests y despliegue sencillo. Cómo: define Flows (Zod), añade Tools y despliega a Firebase/Cloud Run.

Ideas clave
- Flows tipados: entradas y salidas validadas con Zod para reducir errores y hallucinations.
- Tool calling: interfaz controlada a APIs/DBs que mejora seguridad y auditabilidad.
- Trazabilidad: traces con tokens, latencias y llamadas a tools para debugging y auditoría.
- Deploy serverless: exporta Flows como funciones HTTP y despliega con Firebase/Cloud Run.
Tabla de contenidos
Qué es Google ADK (Genkit) y por qué usarlo

Firebase Genkit actúa como un “Agent Development Kit” real: estructura agentes como Flows tipados, soporta tool calling, ofrece trazabilidad (traces) y facilita deploy serverless en Firebase/Cloud Run. No es un playground: es ingeniería.

Beneficios clave
- Flows tipados (Zod) para entradas/salidas.
- Tools como interfaces a APIs o DBs.
- Trace UI para tokens, latencias y llamadas a herramientas.
- Deploy automático a Firebase Functions/Cloud Run.
Requisitos rápidos
- Node.js 20+
- Firebase CLI: npm i -g firebase-tools y firebase login
- Proyecto Google Cloud con facturación habilitada para Vertex AI (si usas Gemini)
- Opcional: Docker para ejecutar dev UI local
Referencias: Vertex AI, Genkit repo.

Paso 1 — Inicializa el scaffold (2–5 minutos)

Crea el proyecto y usa el inicializador de genkit:
```
mkdir mi-agente-genkit
cd mi-agente-genkit
npx genkit init
```
El asistente te pedirá TypeScript y proveedor de modelo (Vertex AI / Gemini). Genera estructura con src/ y genkit.config.ts. Guarda las claves de API en variables de entorno, nunca en el repo.

Paso 2 — Define el Flow: contrato y handler

En Genkit un agente es un Flow: entrada validada, salida validada, handler con lógica y llamadas a herramientas. Usa Zod para evitar parsing frágil.

Ejemplo mínimo
```
import { genkit } from '@genkit-ai/core';
import { z } from 'zod';
import { gemini15Flash } from '@genkit-ai/googleai';

const sdk = genkit({ /* config */ });

const In = z.object({ code: z.string(), language: z.enum(['typescript','python','go']) });
const Out = z.object({ suggestion: z.string(), risk: z.enum(['LOW','MEDIUM','HIGH']) });

export const codeRefactorAgent = sdk.defineFlow(
  { name: 'codeRefactor', inputSchema: In, outputSchema: Out },
  async (input) => {
    const prompt = `Actúa como Staff Engineer... analiza este código...`;
    const resp = await sdk.generate({
      model: gemini15Flash,
      prompt,
      output: { format: 'json', schema: Out }
    });
    return resp.output(); // validado por schema
  }
);
```
Puntos técnicos

Usa output: { format: 'json', schema } para minimizar hallucinations estructurales; valida todo en entrada; añade timeouts/try‑catch.

Paso 3 — Añade Tools (llamadas externas controladas)

Tools son funciones que el LLM puede invocar para consultar docs, bases de datos o sistemas internos.

Ejemplo de tool para buscar en npm registry
```
const npmSearch = sdk.defineTool({
  name: 'npmSearch',
  inputSchema: z.object({ q: z.string() }),
  outputSchema: z.object({ name: z.string(), version: z.string(), desc: z.string() }),
  call: async ({ q }) => {
    const r = await fetch(`https://registry.npmjs.org/-/v1/search?text=${q}`);
    const json = await r.json();
    return json.objects[0].package;
  }
});
```
El modelo decide cuándo invocar la tool; Genkit ejecuta la función y retorna el resultado al LLM. Esto mantiene seguridad y auditabilidad.

Paso 4 — Dev UI y pruebas automáticas

Dev UI

Levanta la UI local: npx genkit start. En localhost:4000:
- Ejecuta flows con JSON.
- Inspecciona traces: prompt final, tool calls, tokens y latencia.
- Guarda artifacts (diffs, screenshots) para auditoría.
Pruebas automáticas

Integra tests unitarios: mockea respuestas de tools y valida que el Flow cumple output schema. Automatiza en CI.

Paso 5 — Deploy y orquestación

Exporta el Flow como función HTTP y despliega
1. firebase init functions
2. Importa y exporta el Flow en functions/src/index.ts.
3. firebase deploy --only functions
Orquestación empresarial

Para orquestación empresarial conecta el endpoint a n8n o un workflow manager: n8n → HTTP Request → parse → branch por riesgo.

Limitaciones y criterios para migrar

Usa Genkit cuando:
- Necesitas trazabilidad, tests y tool calling.
- Quieres despliegue serverless rápido.
Migra a código tradicional si
- La lógica es intensiva en CPU/GPU (procesamiento batch).
- Tienes requisitos de latencia estrictos o compliance que impiden servicios cloud gestionados.
- Coste por token/despliegue supera reescribir servicio en microservicios.
Métrica práctica: si tu agente supera 5–10k invocaciones/mes o la fricción en coste/latencia aumenta, planifica migración.

Buenas prácticas operativas
- Principio de menor privilegio para tools y claves.
- Versiona prompts como código y mantén changelogs.
- Define SLAs y monitorea latencia, tasa de errores y ratio de respuestas estructuradas válidas.
- Implementa fallback humano para casos de riesgo alto.
Conclusión

Saber cómo crear tu primer agente con Google ADK (Genkit) significa pensar en agentes como software: flujos tipados, herramientas controladas, pruebas y trazabilidad. Genkit transforma experimentos en sistemas desplegables y auditables; úsalo para prototipos robustos y como base técnica antes de escalar. Recursos y docs: Genkit, Vertex AI, repo.

Dominicode Labs

Si trabajas en automatización, agentes o workflows y buscas recursos prácticos y experimentos aplicados, revisa Dominicode Labs. Es una continuación lógica para prototipos técnicos y pruebas de integración.
FAQ
¿Qué es Firebase Genkit y cómo se diferencia de un playground?

Firebase Genkit es un framework code‑first para construir agentes de IA como Flows tipados, con soporte para tool calling y trazabilidad. A diferencia de un playground, está diseñado para ingeniería: testing, deploy serverless y auditoría, no solo experimentación interactiva.

¿Cuándo debo usar Genkit en lugar de microservicios tradicionales?

Usa Genkit cuando necesitas trazabilidad, tests y tool calling integrados rápidamente y cuando la lógica del agente beneficia de validación tipada. Considera migrar a microservicios si la carga crece a niveles donde coste/latencia o uso intensivo de GPU/CPU hacen más eficiente una implementación dedicada.

¿Qué requisitos de infraestructura necesito?

Node.js 20+, Firebase CLI (instala con npm i -g firebase-tools), y un proyecto Google Cloud con facturación habilitada para Vertex AI si usas Gemini. Docker es opcional para ejecutar la Dev UI local.

¿Cómo aseguro las claves y tools?

Aplica principio de menor privilegio para las claves y cuentas de servicio. Guarda credenciales en variables de entorno o secretos gestionados; nunca en el repositorio. Limita permisos de las tools a lo estrictamente necesario.

¿Cómo se gestionan las pruebas y CI para Flows?

Mockea respuestas de tools en tests unitarios y valida que los outputs cumplan el schema Zod. Automatiza esos tests en CI y añade pruebas de integración que revisen traces y artefactos relevantes.

¿Qué métricas debo monitorear en producción?

Monitorea latencia, tasa de errores, tokens consumidos y ratio de respuestas válidas según el schema. Define SLAs y habilita fallback humano para casos de riesgo alto.
February 6, 2026
Cómo implementar evals como unit tests para LLMs
Qué son los evals; los unit test de los LLMs

Tiempo estimado de lectura: 4 min
- Los evals son unit tests para sistemas basados en LLMs: pipelines reproducibles que miden si un modelo/prompt/pipeline sigue entregando lo que el negocio necesita.
- Tipos de evaluadores: determinista (regex/JSON Schema), semántico (embeddings + similitud) y LLM-as-a-Judge.
- Práctica: crea un dataset representativo, define la métrica principal, implementa runner y scorer, e integra en CI/CD.
Introducción

Que son los evals; los unit test de los llms. Lo repito porque es la pregunta que nadie hace en serio hasta que algo falla en producción y empiezan a llover tickets.

Resumen rápido (lectores con prisa)

Eval: pipeline reproducible con dataset (golden set), runner, scorer y reporte que actúa como CI para la parte probabilística del sistema. Busca señales (factualidad, coherencia, formato), no igualdad exacta. Usa validación determinista, similitud de embeddings o un LLM-judge según el caso.

¿Qué son los evals; los unit test de los llms?

Un eval es un pipeline reproducible: un dataset de entradas y salidas (golden set), un runner que envia prompts al modelo, un scorer que compara la respuesta con criterios, y un reporte que te dice si rompiste algo. Piénsalo como CI para la parte probabilística del sistema.

A diferencia de un test unitario clásico, aquí no buscas igualdad exacta: buscas señales. Precisión factual, coherencia, formato JSON válido, ausencia de alucinaciones, y que el tono encaje con la interfaz. Todo eso se mide con métricas y reglas. Y sí: algunas veces el “juez” también es otro LLM.

Tipos prácticos de evaluadores (y cuándo usarlos)

Descripción breve de los enfoques más prácticos para evaluar salidas de LLMs y cuándo aplicarlos.

Determinista

Regex, validación de esquema (JSON Schema), comprobaciones de campo. Útil cuando la salida debe ser parseable. Ejemplo: validar que el LLM devuelva {"name": "...", "email": "..."}.

Semántico

Embeddings + similitud coseno. Ideal para summarization y Q&A donde importa el sentido, no la palabra exacta.

LLM-as-a-Judge

Un LLM potente evalúa las respuestas según una rúbrica. Sirve para tono, coherencia o seguridad, pero introduce sesgo y coste.

No mezcles métricas porque sí. Prioriza la que más impacta tu negocio: si tu app depende de JSON bien formado, la métrica principal es “JSON parseable + campos obligatorios”.

Herramientas y referencias prácticas

Empieza con herramientas que ya existen:
Estos proyectos te dan fixtures, runners y ejemplos para arrancar. No reinventes la rueda: adapta un benchmark a tu caso de uso.

Cómo montar tu primer eval (en 5 pasos reales)

Pasos concretos para crear un eval operativo.

1. Crea un dataset de 50–100 ejemplos representativos

Incluye casos comunes y edge cases que te aterran.

2. Define la métrica principal

Ej.: exact match para IDs, coseno>0.85 para respuestas semánticas, 0-1 score para seguridad.

3. Implementa el runner

Script que llama al LLM con el prompt actual y guarda outputs.

4. Añade el scorer

Validación JSON + embeddings o LLM-judge según necesites.

5. Integra en CI/CD

Si la puntuación baja del umbral, el pipeline falla y se bloquea el despliegue.

Resultado: antes de tocar el botón de deploy sabes si rompiste la experiencia.

Ejemplo corto: validar extracción de entidades en n8n

Tienes un workflow que extrae nombre, email y producto de emails entrantes. Tu eval debería:
- Enviar 200 emails sintéticos + reales.
- Comprobar que el JSON sea válido.
- Verificar que el campo email pase regex.
- Comparar entidades con embeddings para detectar ocasionalmente false negatives.
Si el score cae de 0.92 a 0.82 tras un cambio de prompt, no lo llames “variación normal”. Llama a la rollback.

Peligros reales (y cómo evitarlos)
- Data contamination: cuidado con ejemplos de test que el modelo ya vio en entrenamiento. Usa datos frescos.
- Varianza: ejecuta cada caso varias veces (n=3–5) y usa la media o el percentil.
- Métricas irrelevantes: BLEU o ROUGE por costumbre no te salvan; usa métricas alineadas con el objetivo del negocio.
- Juez sesgado: si usas un LLM como juez, documenta la rúbrica y haz validaciones humanas periódicas.
Punto para líderes técnicos

Los evals transforman subjetividad en trazabilidad. Permiten comparar coste vs. calidad (GPT-4o-mini vs. otro) con cifras, no con intuiciones. Integrar evals es un paso pequeño en esfuerzo y gigante en reducción de riesgos.

Haz esto ahora: crea un mini-eval con 50 ejemplos, añade una job en tu CI que ejecute el runner y falle si el score < 0.8. Si en 2 semanas no tienes alertas útiles, sube el umbral.

No es sexy. Es necesario. Y cuando el sistema falle a las 3 a.m., agradecerás haberlos hecho.

Dominicode Labs

Si trabajas con automatización, IA aplicada, n8n o workflows, puede interesarte explorar recursos adicionales en Dominicode Labs. Es una continuación lógica para prototipar mini-evals y automatizar runners en pipelines existentes.

FAQ

Preguntas frecuentes — haz clic en una pregunta para ir a la respuesta.
¿Qué es un eval?

Un eval es un pipeline reproducible que incluye un dataset (golden set), un runner que llama al modelo, un scorer que compara salidas según reglas o métricas y un reporte que indica si el rendimiento cumple el umbral esperado.

¿Cuándo usar evaluadores deterministas?

Usa evaluadores deterministas cuando la salida debe ser parseable y exacta (por ejemplo JSON con campos obligatorios). Validaciones por regex y JSON Schema son adecuadas en esos casos.

¿Por qué usar embeddings en evaluaciones semánticas?

Porque las tareas como summarization y Q&A requieren comparar significado, no coincidencia literal. Embeddings + similitud coseno capturan la proximidad semántica entre la salida y la referencia.

¿Cómo integrar evals en CI/CD sin frenar despliegues válidos?

Define umbrales claros y ejecuta las evaluaciones en una job separada. Si el score baja del umbral, falla la job y bloquea el despliegue. Ajusta el umbral basado en datos y monitoriza alertas para evitar falsos positivos.

¿Qué precauciones tomar si uso un LLM como juez?

Documenta la rúbrica, valida el juez con comparaciones humanas periódicas y considera el sesgo y coste. Guarda ejemplos y decisiones para auditoría.
February 3, 2026
Cómo implementar observabilidad en LLMs para evitar errores
El mayor error al trabajar con LLMs: no saber qué está pasando

Tiempo estimado de lectura: 4 min

Ideas clave
- Sin observabilidad, los LLMs son cajas negras: problemas de calidad, inconsistencias y costes inesperados.
- Instrumenta trazas completas: prompts versionados, pasos intermedios, tokens y costes por traza.
- Usa herramientas existentes (Langfuse, LangChain, n8n) y métricas estándar (TTFT, latencias, tokens).
- Un trace_id por interacción facilita depuración, reproducibilidad y ahorro de costes.
Tabla de contenidos
Introducción

¿Tu LLM falla y no sabes por qué? Es el problema silencioso que paraliza a los equipos de IA. Implementas un agente, pasa las pruebas locales y en producción un usuario reporta una alucinación grave. La API devuelve 200 OK. No hay excepciones. Y, aun así, la respuesta es basura.

Ese es el síntoma claro de el mayor error al trabajar con LLMs: no saber qué está pasando dentro de la caja negra. Tratar componentes estocásticos como si fuesen APIs deterministas es pedir problemas: calidad errática, usuarios frustrados y facturas que suben sin control.

Resumen rápido (lectores con prisa)

Observabilidad para LLMs = trazas completas + prompts versionados + tokens/costes por interacción. Útil cuando necesitas reproducir alucinaciones, recuperar cambios de prompt o reducir costes. Implementa un trace_id único por interacción y registra system prompt, contexto, pasos intermedios y métricas (TTFT, latencias, tokens).

Los síntomas de operar a ciegas

Integrar un LLM con un par de console.log puede ser aceptable en prototipos. En producción, verás tres dolores rápidos:
- Prompts que “caducan”: un prompt que funcionaba cambia comportamiento sin que tú cambies nada. Puede ser una actualización del modelo, un token limit o un caso borde de entrada. Sin historial no hay diagnóstico.
- Outputs inconsistentes y alucinaciones: usuarios reciben información inventada. Sin la traza completa (system prompt, contexto inyectado, temperatura, seed), no hay forma de reproducir ni arreglar.
- Costes opaques: la factura sube. ¿Más usuarios o un bucle de agentes que consume 10k tokens por interacción? Sin coste por traza, la optimización es adivinatoria.
De la “ingeniería de prompts” a la ingeniería de software

En software serio nadie despliega sin observabilidad: logs estructurados (ELK), seguimiento de errores (Sentry), métricas y trazas (Prometheus, Datadog). Allí donde una API falla, un trace te muestra la consulta SQL que la bloqueó.

Con LLMs muchos equipos siguen sin esos instrumentos. Error fundamental: los LLMs son componentes no deterministas. Requieren más visibilidad, no menos. No basta con saber que “falló”; hay que saber qué pasos siguió el modelo hasta fallar.

Observabilidad para LLMs: qué necesitas medir

No es cuestión de adoptar buzzwords. Es instrumentar las interacciones de forma estructurada. Un stack mínimo de LLM Ops debe capturar:
- Trazas de ejecución: cada trace debe guardar los pasos intermedios —retrievals (RAG), llamados a herramientas, subtasks del agente— para reconstruir el árbol de decisiones.
- Prompts versionados: almacenar el prompt exacto (y su versión) usado en cada llamada para poder comparar A/B y revertir cambios malos.
- Tokens y costes por traza: tokens de entrada/salida, coste estimado por llamada, y agregados por feature (ej. “Resumen PDF” vs “Chat general”).
- Latencias y TTFT: Time To First Token y latencia total, separando orquestación (vector search, DB) y generación de tokens.
- Metadata contextual: user_id, request_id, model_version, env, y un trace_id único para correlación con logs y métricas.
Con esos datos ya puedes responder preguntas operativas: ¿por qué un caso concreto alucina? ¿Qué prompt/version empeoró la calidad? ¿Qué feature consume más presupuesto?

Herramientas y patrón de integración

No reinventes todo. Hay proyectos y herramientas que encapsulan la observabilidad de LLMs:
- Langfuse: plataforma orientada a trazas de LLMs, visualización de árboles de ejecución y curación de datasets. Convierte prompts en artefactos depurables.
- LangChain: framework de chains/agents que puedes instrumentar.
- n8n: útil cuando orquestas workflows y quieres nodos que emitan trazas estructuradas.
Patrón práctico:
1. Instrumenta cada llamada al modelo con un trace_id.
2. Registra prompt completo, system prompt, variables, model_version, y parámetros (temperature, max_tokens).
3. Registra pasos intermedios (RAG hits, tool outputs).
4. Calcula y almacena coste estimado por traza.
5. Expón dashboards y búsquedas por trace_id para depuración rápida.
Ejemplo táctico (mental): un trace_id cambia todo

Imagina que un usuario reporta una factura errónea. Buscas trace_id y ves:
- System prompt v2.1
- Contexto RAG: documento X con fecha antigua
- Agent: intentó lookup_price → timeout → fallback generó precio estimado
- Tokens: 9k tokens consumidos → coste alto
Con esa traza decides: ajustar RAG freshness, aumentar timeouts de la tool, y agregar verificación post-mutation. Sin traza, solo especularías y aplicarías parches a ciegas.

Cierre: deja de depender de la esperanza

Operar LLMs sin observabilidad es lo mismo que conducir de noche sin luces: puedes avanzar, pero no sabes cuándo chocarás. La observabilidad transforma la incertidumbre en datos accionables: reproduce errores, reduce costes y crea ciclos de mejora operativa.

Langfuse convierte tus prompts en algo depurable. Así debería ser cualquier sistema serio. Si estás construyendo con LLMs en producción, esto no es opcional: instrumenta, mide y mantén control.

Dominicode Labs

Si trabajas en automatización, agentes o workflows y buscas un punto de partida con prácticas de observabilidad, mira lo que propone Dominicode Labs. Es una referencia práctica para equipos que necesitan trazabilidad y herramientas operativas.
FAQ

¿Qué es una traza de LLM?

¿Qué debe incluir un prompt versionado?

¿Cómo se calcula coste por traza?

¿Qué métricas operativas son críticas?

¿Cuándo usar Langfuse o LangChain?

¿Cómo empezar con trazabilidad mínima?

¿Qué es una traza de LLM?

Una traza es un registro estructurado de una interacción completa con el sistema: prompts (system y user), pasos intermedios (RAG hits, llamadas a herramientas), tokens consumidos, latencias y metadata contextual (request_id, user_id, model_version, trace_id).

¿Qué debe incluir un prompt versionado?

El prompt exacto usado, su versión o hash, variables inyectadas, system prompt asociado y el conjunto de reglas de post-procesado. Esto permite comparar A/B y revertir cambios.

¿Cómo se calcula coste por traza?

Suma el coste estimado por token de entrada y salida para cada llamada al modelo, añade coste de herramientas externas si aplica, y agrega por feature para obtener métricas agregadas por funcionalidad.

¿Qué métricas operativas son críticas?

TTFT (Time To First Token), latencia total, tokens de entrada/salida, coste estimado, tasas de alucinación o error y métricas de orquestación (ej. tiempos de búsqueda vectorial, timeouts de tools).

¿Cuándo usar Langfuse o LangChain?

Usa Langfuse para trazas y curación de datasets; usa LangChain cuando tu arquitectura gira en torno a chains/agents que necesitas instrumentar. No son mutuamente excluyentes.

¿Cómo empezar con trazabilidad mínima?

Implementa un trace_id por interacción, guarda prompt completo y system prompt, registra tokens consumidos y latencias, y al menos un campo de metadata (request_id/user_id). Esto ya te permite reproducir y diagnosticar muchos problemas.
February 3, 2026
Qué es LangGraph y para qué sirve?
Tiempo estimado de lectura: 5 min
- LangGraph modela agentes LLM como grafos de estado para soportar reintentos, checkpoints y flujos cíclicos.
- Arquitectura basada en State, Nodes y Edges que permite persistencia y rutas condicionales.
- Ideal para agentes que requieren autocorrección, aprobaciones humanas y orquestación multi-agente; no es la mejor opción para RAG lineal.
Tabla de contenidos
Introducción

LangGraph es una arquitectura y biblioteca pensada para convertir prototipos basados en LLM en sistemas operativos de IA: máquinas de estado con persistencia, rutas condicionales y capacidad de autocorrección. A diferencia de flujos lineales, LangGraph modela grafos dirigidos con estado compartido entre nodos, lo que facilita reintentos, aprobaciones humanas y trazabilidad en producción.

Resumen rápido (lectores con prisa)

LangGraph modela aplicaciones LLM como StateGraphs: un objeto de estado central que pasa por nodos (unidades de trabajo) y aristas (rutas condicionales). Es útil cuando necesitas reintentos, checkpoints, aprobaciones humanas y observabilidad en flujos complejos. No sustituye a LangChain; complementa su ecosistema para agentes stateful.

Qué es LangGraph y para qué sirve?

Qué es LangGraph y para qué sirve: en pocas palabras, LangGraph es la evolución arquitectónica para construir agentes de IA que necesitan razonar en ciclos, mantener estado persistente y coordinar múltiples acciones en producción. Si LangChain te ayuda a encadenar pasos (A → B → C), LangGraph te permite modelar grafos con bucles y condiciones (A → B → ¿volver a A? → C), lo que convierte prototipos en sistemas robustos y auditables.

Qué es LangGraph: definición técnica y contexto

LangGraph es una biblioteca del ecosistema LangChain orientada a modelar aplicaciones LLM como grafos dirigidos con estado (StateGraphs). Su objetivo no es sustituir a LangChain, sino ofrecer una abstracción para agentes stateful: nodos que transforman un objeto de estado central y aristas que dictan rutas condicionales o recurrentes. Documentación oficial: Documentación oficial y LangChain.

¿Por qué importa esto? Porque los agentes reales no funcionan con una sola pasada. Necesitan checkpoints, reintentos, intervención humana y la capacidad de inspeccionar y reactivar flujos largos. LangGraph incorpora esos elementos de forma nativa.

Arquitectura: State, Nodes y Edges

La arquitectura de LangGraph se resume en tres piezas principales que convierten al agente en una máquina de estados capaz de iterar y autocorregirse.

Estado (State)

Estado (State): un TypedDict/estructura que contiene todo el contexto del agente (historial de mensajes, resultados de herramientas, flags de control). El estado persiste y se pasa entre nodos.

Nodos (Nodes)

Nodos (Nodes): unidades de trabajo que reciben el estado, ejecutan lógica (llamadas a LLM, ejecución de tools, transformaciones) y devuelven una actualización del estado.

Aristas (Edges)

Aristas (Edges): definen el flujo. Pueden ser incondicionales o condicionales, permitiendo rutas distintas según el resultado (p. ej. error → corrección, éxito → siguiente etapa).

Esta organización convierte al agente en una máquina de estados que puede iterar, corregirse y limpiar su plan a medida que avanza.

Ejemplo mínimo (conceptual)
```
from langgraph.graph import StateGraph, END

class AgentState(TypedDict):
    messages: list
    attempts: int

g = StateGraph(AgentState)
g.add_node("think", call_model_node)      # produce propuesta en estado
g.add_node("act", call_tool_node)         # ejecuta acción externa
g.set_entry_point("think")

# condicional: si falla, volver a "think" (loop); si OK, terminar
g.add_conditional_edges("act", check_result, {"retry": "think", "done": END})

app = g.compile(checkpointer=MemorySaver())
```
Este patrón es el que permite, por ejemplo, que un agente escriba código, ejecute tests, lea errores y reescriba hasta que todo pase.

Casos de uso reales y por qué elegir LangGraph

LangGraph es la opción adecuada cuando tu aplicación requiere control fino y durabilidad. Es preferible cuando la lógica no cabe en una sola pasada y necesitas checkpoints, reintentos o pausas para intervención humana.
- Agentes de auto-corrección (self-correcting): p. ej., un asistente que escribe y prueba código repetidamente.
- Planificación y ejecución por etapas: descomposición de objetivos complejos en subtareas que se ejecutan y replanifican.
- Flujos human-in-the-loop: pausas para aprobación humana manteniendo estado; crítico en entornos regulados.
- Orquestación multi-agente: coordinar agentes especializados (investigador, verificador, redactor) que comparten estado y tareas.
Para casos simples de RAG o chatbots lineales, LangChain/LCEL es más rápido de implementar; LangGraph entra cuando la lógica necesita reintentos, memoria o human approvals. Referencia: LangChain/LCEL.

Integraciones, durabilidad y observabilidad

LangGraph se integra con herramientas de almacenamiento y trazabilidad que son esenciales en producción.
- Checkpointers/Recorders: MemorySaver, PostgresSaver, etc., permiten reanudar ejecuciones y persistir threads largos.
- Observabilidad: integración con LangSmith (tracing, evaluaciones) para depurar y medir decisiones internas.
- Vector stores y RAG: combina con Pinecone, Chroma o Weaviate cuando necesitas evidencia externa en nodos de razonamiento.
- Orquestación externa: útil en pipelines con n8n para integrar herramientas empresariales.
La durabilidad es la gran ventaja: si un proceso falla a mitad, LangGraph permite retomar desde el último checkpoint con el mismo objeto estado.

Riesgos y consideraciones técnicas

LangGraph añade complejidad. No es la herramienta para todo; evalúa trade-offs antes de adoptar.
- Curva de aprendizaje: modelar grafos y estados correctamente exige diseño y pruebas.
- Overhead: persistencia y checkpoints implican coste y latencia; mide y optimiza.
- Seguridad: cualquier tool que ejecute código o acceda a datos sensibles debe estar sandboxeada y auditada.
- Depuración: sin buenas métricas y trazabilidad (LangSmith u otras), los grafos cíclicos pueden volverse opacos.
Tu criterio de adopción debe basarse en evidencia: prototipa en LangChain; si la solución requiere reintentos, memoria o human approvals, modela en LangGraph.

Conclusión práctica

LangGraph transforma agentes experimentales en sistemas operativos de IA: máquinas de estado con persistencia, rutas condicionales y capacidad de autocorrección. Úsalo cuando tus flujos necesiten reintentos, checkpoints y supervisión humana; queda corto para tareas lineales de RAG. Documentación y templates: Documentación oficial y repositorio.

Empieza con un caso controlado (un agente que intenta, falla y reintenta una acción concreta), instrumenta trazabilidad y luego amplía a flujos multi-agente. Es así como pasas de “probar IA” a “operar IA” con seguridad.

Dominicode Labs

Si tu equipo trabaja en orquestación, automatización o agentes de producción, considera explorar plantillas y pruebas conceptuales en Dominicode Labs. Puede ser útil como punto de partida para validar patrones de checkpointing, trazabilidad y human-in-the-loop en proyectos reales.

FAQ
¿En qué casos conviene usar LangGraph en lugar de LangChain puro?

Usa LangGraph cuando tu flujo requiere reintentos, checkpoints, memoria persistente o aprobaciones humanas. Si tu aplicación es lineal (RAG simple o chat básico), LangChain/LCEL suele ser suficiente y más rápido de implementar.

¿LangGraph reemplaza a LangChain?

No. LangGraph complementa el ecosistema LangChain: ofrece abstracciones para agentes stateful y grafos con condiciones. LangChain sigue siendo útil para pipelines lineales y muchas integraciones.

¿Cómo se persiste el estado en LangGraph?

El estado se persiste mediante checkpointers/recorders como MemorySaver o PostgresSaver. Estos componentes permiten reanudar ejecuciones y almacenar el objeto de estado para procesos largos o interrumpidos.

¿Qué impacto tiene LangGraph en latencia y costes?

La persistencia y checkpoints añaden overhead: más I/O y potencialmente mayor latencia. Es importante medir, optimizar y balancear la durabilidad frente al coste operativo.

¿Cómo manejar la seguridad al ejecutar tools desde nodos?

Sandboxea y audita cualquier herramienta que ejecute código o acceda a datos sensibles. Implementa controles de acceso, validación de inputs y trazabilidad exhaustiva para cada ejecución de herramienta.

¿Puedo integrar vector stores y herramientas externas?

Sí. LangGraph se integra con servicios como Pinecone, Chroma y Weaviate, y se puede orquestar con herramientas externas como n8n para flujos empresariales.
February 1, 2026
Cómo usar n8n como backend sin servidor de tu aplicación Next.js?
Tiempo estimado de lectura: 4 min

Ideas clave
- Usar n8n como motor de orquestación y computación para reducir lógica en API Routes de Next.js.
- Patrón: Next.js → webhook n8n → procesamiento (IA, scraping, APIs) → persistencia (Supabase) → frontend en realtime.
- Ideal para MVPs y pipelines IA/ETL; observar límites de latencia, escalabilidad y complejidad de workflows.
Tabla de contenidos
La automatización con IA y n8n te permite convertir los workflows visuales en el “backend” de una aplicación Next.js. En lugar de desplegar lógica compleja en API Routes, orquestas webhooks, llamadas a LLMs y persistencia en Supabase desde n8n. El resultado: iteración rápida, menos infra y más foco en producto.

Resumen rápido (lectores con prisa)

Qué es: Uso de n8n como gateway y motor de cómputo para orquestar webhooks, llamadas a LLMs, scraping y persistencia.

Cuándo usarlo: Orquestación entre APIs, pipelines IA/ETL y MVPs donde la latencia y el throughput no son críticos.

Por qué importa: Permite iterar sin redeploy, con reintentos nativos, observabilidad visual y menos código inicial.

Cómo funciona (alto nivel): Next.js → webhook n8n → procesamiento (IA/scraping/APIs) → persistencia en Supabase → frontend en realtime.

Automatización con IA y n8n: modelo arquitectónico y por qué funciona

El patrón es simple y poderoso: Next.js → webhook n8n → procesamiento (IA, scraping, APIs) → persistencia (Supabase) → frontend en realtime. n8n actúa como API Gateway y motor de cómputo sin que tengas que escribir ni desplegar microservicios.

Ventajas prácticas:
- Cambios en lógica sin redeploy.
- Reintentos y manejo de errores nativos en los workflows.
- Observabilidad visual por ejecución.
Limitaciones obvias: latencia, complejidad de workflows y límites de escala. Documentación útil: n8n, Supabase, OpenAI embeddings y límites de funciones en serverless como referencia a por qué evitar lógica pesada en serverless.

Playbooks prácticos de Dominicode Labs (de idea a producción)

A continuación tres playbooks reales, listos para implementar y adaptar.

Playbook A — Generador de informes (asíncrono, UX responsiva)
- 1. Next.js POST → webhook n8n con {userId, url, jobMeta}.
- 2. n8n: valida auth (JWT de Supabase), inserta fila en reports con status=pending.
- 3. n8n: descarga HTML o usa scraping (Browserless/Playwright), extrae texto.
- 4. n8n: genera embeddings y contexto; llama a LLM para generar el informe.
- 5. n8n: guarda PDF/markdown en Supabase Storage y actualiza reports a completed.
- 6. Frontend: escucha Supabase Realtime y muestra resultado cuando cambia el status.
Playbook B — Enriquecimiento y scoring de leads (evento-driven)
- 1. Webhook recibe lead.
- 2. n8n: Clearbit/Hunter → enriquece.
- 3. n8n: LLM evalúa fit (prompt estructurado), asigna score.
- 4. Si score > threshold, n8n: crea entidad en CRM y notifica Slack; siempre actualiza tabla leads.
Playbook C — Pipeline RAG ligero (knowledge base)
- 1. Ingesta: usuario sube documento → Supabase insertar fila uploads.
- 2. Database Webhook de Supabase → n8n: descarga, chunking, embeddings (OpenAI), inserción en tabla documents con pgvector.
- 3. Consulta: usuario pregunta → webhook → n8n: embed query, RPC a Postgres/pgvector, LLM con contexto, actualizar queries con respuesta.
Referencias técnicas: pgvector en Supabase y ejemplos de workflows en n8n.

Límites y señales de que debes refactorizar a código

n8n no es la solución para todo. Señales de alarma:
- Workflows con más de ~25–30 nodos: difícil de mantener.
- Necesidad de latencia sub-500ms o throughput extremo (>10k reqs/min).
- Estado transaccional complejo o requisitos ACID.
- Lógica condicional anidada profunda o cálculos intensivos.
Si observas esas señales, muévete a servicios escritos (Deno/Cloudflare Workers, microservicios en Node/Python) y usa n8n para orquestación superior o tareas periféricas.

Seguridad y operaciones: checklist mínimo
- Nunca expongas webhooks sin proteger:
  - Validación de header x-api-key o JWT en el primer nodo.
  - Rotación periódica de claves.
- Row Level Security (RLS) en Supabase para evitar lecturas no autorizadas.
- Rate limiting y circuit breaker: implementa checks iniciales (Redis o tablas de rate) para mitigar bursts.
- Logging centralizado y alertas (Slack/email) en fallos críticos.
- Dev local: ngrok/localtunnel o host.docker.internal para probar webhooks.
Guía RLS: Guía RLS. n8n security docs: n8n.

Cómo decidir en 3 pasos (criterio Dominicode)
1. ¿La tarea es orquestación entre APIs o requiere IA/ETL? Si sí → n8n.
2. ¿Requiere latencia ultra-baja o transacciones complejas? Si sí → código.
3. ¿La complejidad del workflow crecerá con el tiempo? Si sí → diseñar desde el inicio con posibilidad de migración gradual a servicios.
Cierre: cuándo apostar por n8n (y cómo hacerlo responsablemente)

Usar n8n como backend serverless para Next.js acelera la entrega de features de IA y reduce boilerplate. Es ideal para MVPs y procesos de integración/orquestación donde latencia y throughput no sean críticos. Implementa límites claros, monitoreo y una ruta de migración a microservicios cuando la complejidad y el tráfico lo exijan. Con esos guardrails, automatización con IA y n8n deja de ser un experimento y se convierte en una herramienta productiva para equipos que quieren mover rápido y mantener criterio técnico.

Más recursos

Si buscas playbooks, plantillas y ejemplos prácticos para acelerar pipelines de IA y orquestación, revisa Dominicode Labs. Encontrarás material orientado a producción y guías para migración gradual desde workflows a servicios cuando haga falta.

FAQ

¿Por qué usar n8n como backend sin servidor?

n8n permite orquestar llamadas a APIs, LLMs, scraping y persistencia sin desplegar microservicios. Esto reduce tiempo de entrega y el esfuerzo operativo en etapas tempranas del producto.

Además incluye reintentos, manejo de errores y observabilidad visual por ejecución, lo que facilita iterar en lógica de negocio sin redeploys constantes.

¿Cuándo n8n no es la mejor opción?

Cuando necesitas latencia sub-500ms, throughput extremo (>10k reqs/min), transacciones ACID o workflows con más de ~25–30 nodos mantenibles, es preferible migrar a servicios escritos (Deno, Cloudflare Workers, microservicios en Node/Python).

¿Cómo proteger los webhooks de n8n?

Valida un header x-api-key o un JWT en el primer nodo del workflow y rota las claves periódicamente. Complementa con rate limiting y checks previos para mitigar abusos.

¿Cómo integrar con Supabase y pgvector?

Usa webhooks de la base de datos para disparar workflows en n8n que descarguen archivos, realicen chunking y generen embeddings (OpenAI). Inserta vectores en una tabla con pgvector en Supabase y consulta con RPC a Postgres/pgvector desde n8n.

¿Qué monitoreo y manejo de errores aplicar?

Centraliza logs y configura alertas (Slack/email) en fallos críticos. Aprovecha reintentos nativos de n8n y añade circuit breakers o tablas/Redis para rate limiting y protección frente a bursts.

¿Qué documentación debo revisar primero?

Revisa la doc oficial de n8n, las guías de Supabase y la guía de embeddings de OpenAI embeddings.
January 29, 2026