Convex: el backend reactive para agentes IA con TypeScript puro (2026)

El backend que los LLMs aman

Convex es la base de datos reactiva open source diseñada para hacer la vida fácil a developers de web apps —ya sean humanos o LLMs. Escribes tu backend en TypeScript puro: database schemas, queries, mutations, actions, auth y APIs. Todo typechecked, todo autocompletado, todo generado por IA con precisión excepcional.

Pero lo que hace a Convex único en 2026 es su Agent component: un building block para construir agentes IA con threads persistentes, message history, vector search integrado, workflows durables, streaming en tiempo real y debugging con playground. Todo en un solo backend, sin orquestar 10 servicios.

¿Qué es Convex?

Convex es una reactive database con server functions integradas. En lugar de escribir SQL, escribir queries y mutations en TypeScript que se ejecutan en el servidor de Convex. Los resultados se sincronizan en tiempo real con los clientes —sin websockets manuales, sin cache invalidation, sin state managers.

El stack de Convex incluye:

• Database ACID con esquemas definidos en TypeScript
• Server functions: queries (lectura reactiva), mutations (escritura transaccional), actions (async, third-party APIs)
• Realtime updates garantizados por las librerías de Convex
• Type safety end-to-end: el frontend autocompleta los tipos del backend
• Auth integrado
• File storage
• Vector search nativo
• Text search nativo
• Cron jobs
• HTTP actions para construir APIs directamente

Por qué Convex es ideal para agentes IA

La documentación de Convex lo dice claro: "LLMs love Convex". ¿Por qué?

1. TypeScript puro: Los LLMs generan código Convex con precisión excepcional porque todo es TypeScript —el mismo lenguaje que ya conocen
2. End-to-end type safety: El frontend, el backend y la database comparten tipos. La IA no tiene que adivinar la forma de los datos
3. Reactive by default: Los cambios en la database se reflejan en todos los clientes en tiempo real. Perfecto para chat UIs donde los mensajes del agente aparecen streaming
4. Agent component: Un building block completo para agentes con threads, messages, tools, workflows, RAG y debugging —todo integrado
5. Convex Agent Skills: Skills instalables que dan a tu AI coding agent workflows especializados de Convex
6. MCP Server: Convex tiene su propio MCP server para que Claude Code, Cursor y otros agents interactúen con tu backend

El Agent Component

El Agent component (@convex-dev/agent) es el core building block para construir agentes IA en Convex. Maneja threads y messages, alrededor de los cuales tus agentes cooperan en workflows estáticos o dinámicos.

Características clave

• Agents: Organizan LLM prompting con models, prompts y tools asociados. Pueden generar y streaminear texto y objetos
• Threads: Persisten messages y pueden ser compartidos por múltiples users y agents (incluyendo human agents)
• Conversation context automático: Incluido en cada LLM call, con hybrid vector/text search integrado para messages del thread
• Streaming via websockets: Texto y objetos via deltas sobre websockets. Todos los clientes se mantienen en sync eficientemente, sin HTTP streaming
• Workflows: Operaciones multi-step que pueden span agents, users, durables y reliables
• RAG: Técnicas de retrieval-augmented generation para prompt augmentation, upfront o como tool calls, usando el RAG Component
• Files en chat history: Soporte para archivos e imágenes en el historial, con guardado automático a file storage y ref-counting
• Debugging: Callbacks, agent playground para inspeccionar metadata, iterar en prompts y context settings, e inspección en el dashboard
• Usage tracking: Attribution per-provider, per-model, per-user, per-agent para billing y más
• Rate limiting: Powered by el Rate Limiter Component, controla la rate de interacción de users con agents
• Tool approval: Human-in-the-loop tool approval para agentes que necesitan supervisión

Code example: definir un agente

import { Agent } from "@convex-dev/agent";
import { openai } from "@ai-sdk/openai";
import { components } from "./_generated/api";
import { action } from "./_generated/server";
import { v } from "convex/values";

// Definir un agente
const supportAgent = new Agent(components.agent, {
  name: "Support Agent",
  chat: openai.chat("gpt-4o-mini"),
  instructions: "You are a helpful assistant.",
  tools: { accountLookup, fileTicket, sendEmail },
});

// Crear un thread y generar respuesta
export const createThread = action({
  args: { prompt: v.string() },
  handler: async (ctx, { prompt }) => {
    const { threadId, thread } = await supportAgent.createThread(ctx);
    const result = await thread.generateText({ prompt });
    return { threadId, text: result.text };
  },
});

// Continuar un thread (contexto automático)
export const continueThread = action({
  args: { prompt: v.string(), threadId: v.string() },
  handler: async (ctx, { prompt, threadId }) => {
    const { thread } = await anotherAgent.continueThread(ctx, { threadId });
    const result = await thread.generateText({ prompt });
    return result.text;
  },
});

Dynamic Agent definition

Puedes definir un Agent en runtime, útil para crear un agente para un contexto específico:

function createAuthorAgent(ctx: ActionCtx, bookId: Id<"books">, model: LanguageModel) {
  return new Agent(components.agent, {
    name: "Author",
    languageModel: model,
    tools: {
      getChapter: getChapterTool(ctx, bookId),
      researchCharacter: researchCharacterTool(ctx, bookId),
      writeChapter: writeChapterTool(ctx, bookId),
    },
    stopWhen: stepCountIs(10),
  });
}

Componentes del ecosistema Convex

Convex tiene un ecosistema creciente de Components instalables con npm i:

Componente	Qué hace
Agent	Threads, messages, tools, workflows para agentes IA
RAG	Vector search + text search para retrieval-augmented generation
Rate Limiter	Rate limiting para controlar interacción de users con agents
Workflow	Workflows durables multi-step que span agents y users
Workpool	Retry con backoff y jitter para LLMs que fallan
File Storage	Storage de archivos con ref-counting, integrado en chat history
Vector Search	Búsqueda semántica nativa en la database
Text Search	Búsqueda full-text nativa
Aggregates	Agregaciones eficientes (count, sum, etc.)
Auth	Autenticación integrada con proveedores OAuth

Integración con AI coding agents

Convex está diseñado para que tu AI coding agent trabaje directamente con tu backend:

• Convex Agent Skills: Skills instalables que dan a tu AI coding agent workflows especializados de Convex
• Convex MCP Server: Model Context Protocol server para que agents interactúen con tu deployment
• Usando Claude Code con Convex: Tips y best practices documentados
• Usando Codex con Convex: Integración con OpenAI Codex
• Usando Cursor con Convex: Integración con Cursor IDE
• Usando GitHub Copilot con Convex: Integración con Copilot
• Usando Conductor con Convex: Integración con Conductor

Usar Claude Code con Convex

# Instalar Convex CLI
npm install -g convex

# Crear proyecto Convex
npx convex dev

# En otra terminal, abrir Claude Code en el proyecto
claude

# Claude Code puede:
# - Leer y escribir funciones de Convex
# - Modificar esquemas de database
# - Crear agents con el Agent component
# - Configurar RAG y vector search
# - Debuggear via dashboard

# El MCP server de Convex permite a Claude Code
# interactuar directamente con tu deployment
claude mcp add convex -- npx convex mcp

Streaming en tiempo real

Una de las características más poderosas del Agent component es el streaming via websockets. A diferencia del HTTP streaming tradicional, Convex usa deltas sobre websockets para que:

• Todos los clientes se mantengan en sync eficientemente
• El streaming funcione desde async functions
• No necesites configurar SSE o HTTP streaming manualmente
• Los mensajes del agente aparezcan en tiempo real en todos los dispositivos

// En el cliente (React)
import { useQuery } from "convex/react";
import { api } from "./_generated/api";

function ChatComponent({ threadId }) {
  const messages = useQuery(api.chat.list, { threadId });
  // messages se actualiza en tiempo real
  // cuando el agente genera nuevos mensajes
  
  return messages?.map(msg => (
    
{msg.text}
  ));
}

Workflows durables para agentes

Los workflows permiten construir operaciones multi-step que pueden span agents, users, y ser durables y reliables. Si el servidor se reinicia o el API provider tiene issues, el workflow se reanuda:

import { Workflow } from "@convex-dev/workflow";

const myWorkflow = new Workflow(components.workflow, {
  workpool: components.workpool,
});

export const researchWorkflow = myWorkflow.define({
  args: v.object({ topic: v.string() }),
  handler: async (step, { topic }) => {
    // Step 1: Research
    const research = await step.runAction(
      internal.research.search, { topic }
    );
    
    // Step 2: Generate
    const draft = await step.runAction(
      internal.agents.draft, { research }
    );
    
    // Step 3: Review
    const reviewed = await step.runAction(
      internal.agents.review, { draft }
    );
    
    return reviewed;
  },
});

RAG integrado

El RAG component permite añadir retrieval-augmented generation a tus agentes:

import { RAG } from "@convex-dev/rag";
import { openai } from "@ai-sdk/openai";

const rag = new RAG(components.rag, {
  textEmbedding: openai.embedding("text-embedding-3-small"),
});

// Añadir contenido
await rag.add(ctx, {
  text: "Document content here...",
  namespace: "user-123",
});

// Buscar
const { results } = await rag.search(ctx, {
  query: "search query",
  namespace: "user-123",
  limit: 10,
});

Características del RAG component:

• Add Content: Añade o reemplaza contenido con text chunks y embeddings
• Semantic Search: Vector-based search con embedding models configurables
• Namespaces: Organiza contenido en namespaces para per-user search
• Custom Filtering: Filtra contenido con custom indexed fields

Usage Tracking y billing

El Agent component incluye usage tracking con attribution per-provider, per-model, per-user, per-agent:

const supportAgent = new Agent(components.agent, {
  name: "Support Agent",
  chat: openai.chat("gpt-4o-mini"),
  usageHandler: async (ctx, args) => {
    const { usage, model, provider, agentName, threadId, userId } = args;
    // Guardar usage en tu database para billing
    await ctx.runMutation(internal.usage.record, {
      userId, model, provider, agentName,
      inputTokens: usage.inputTokens,
      outputTokens: usage.outputTokens,
      totalCost: usage.totalCost,
    });
  },
});

Ideal para SaaS que necesita facturar a users por uso de IA.

Rate Limiting

Powered by el Rate Limiter Component, controla la rate de interacción de users con agents:

import { RateLimiter } from "@convex-dev/rate-limiter";

const rateLimiter = new RateLimiter(components.rateLimiter);

// En tu action
export const sendMessage = action({
  args: { prompt: v.string(), threadId: v.string() },
  handler: async (ctx, { prompt, threadId }) => {
    const userId = await ctx.auth.getUserIdentity();
    
    // Rate limit: 10 mensajes por minuto por user
    const { ok, retryAfter } = await rateLimiter.limit(ctx, {
      name: "agent_message",
      key: userId?.subject,
      limit: 10,
      period: 60_000,
    });
    
    if (!ok) {
      throw new Error(`Rate limit exceeded. Retry after ${retryAfter}s`);
    }
    
    // Continuar con el agente...
  },
});

Agent Playground

Convex incluye un agent playground en el dashboard donde puedes:

• Inspeccionar todos los threads y messages
• Ver metadata de cada LLM call (model, tokens, tools usados)
• Iterar en prompts y context settings
• Debuggear tool calls y sus resultados
• Probar diferentes configurations en tiempo real

Pricing

Free & Starter

Para personal projects y prototypes:

• Free: $0/mes con recursos incluidos
• Starter: $0/mes + pay-as-you-go beyond free limits
• 1-6 developers
• 40 deployments
• 1M function calls/mes
• 0.5 GB database storage
• 1 GB file storage
• Vector search, text search, crons, auth, Node.js actions
• Health & insights dashboard
• Preview deployments
• Selectable data region

Professional

$25/developer/mes:

• 1-20 developers
• 300 deployments
• 25M function calls/mes incluidas
• 50 GB database storage
• 100 GB file storage
• Exception reporting
• Daily backups
• Custom domains
• Email support

Business & Enterprise

• Business: $2,500/mes mínimo, month-to-month
• Enterprise: Custom enterprise agreements, precommit discounts
• Unlimited developers y deployments
• Dedicated deployment classes

Resource pricing (Free & Starter)

Recurso	Free incluido	Extra
Function calls	1M/mes	$2.20 por 1M adicional
Action compute	20 GB-hours/mes	$0.33/GB-hour
Database storage	0.5 GB	$0.22/GB/mes
File storage	1 GB	$0.033/GB/mes
Search storage	0.5 GB	$0.55/GB/mes
Database I/O	1 GB/mes	$0.22/GB
Data egress	1 GB/mes	$0.132/GB

Open source y self-hosting

Convex backend es open source (12,112 stars en GitHub). El repositorio get-convex/convex-backend contiene el backend completo, escrito en TypeScript (44.3%) y Rust (43.4%).

Self-hosted Convex funciona con:

• Docker (recomendado) o prebuilt binary
• Neon, Fly.io, Vercel, Netlify, RDS, SQLite, Postgres y más
• Incluye dashboard y CLI
• Community support en Discord #self-hosted

# Self-host con Docker
git clone https://github.com/get-convex/convex-backend.git
cd convex-backend/self-hosted
# Ver guía de self-hosting en ./README.md

Quick start

# Crear proyecto nuevo
npm create convex@latest

# O añadir a proyecto existente
npm install convex
npx convex dev

# Instalar Agent component
npm install @convex-dev/agent

# Instalar RAG component
npm install @convex-dev/rag

# Instalar Rate Limiter
npm install @convex-dev/rate-limiter

# Instalar Workflow
npm install @convex-dev/workflow

Convex vs otros backends para IA

Aspecto	Convex	Supabase	Firebase	Custom (Node+PG)
Lenguaje	TypeScript puro	SQL + JS/TS	JS/TS	Cualquiera
Reactive	Por defecto	Realtime subscriptions	Realtime listeners	Manual (websockets)
Agent component	Sí (nativo)	No	No	DIY
Vector search	Nativo	pgvector	Vertex AI	pgvector / Pinecone
Streaming	Websockets deltas	Manual	Manual	Manual (SSE/WS)
Type safety	End-to-end	Generada	Parcial	Manual
Open source	Sí (self-hostable)	Sí (self-hostable)	No	Sí
MCP server	Sí	Sí	No	No
Free tier	1M calls/mes	500MB DB, 50K MAU	Spark plan	$0 (self-host)
LLM code gen	Excelente (TS puro)	Bueno	Regular	Depende

Casos de uso ideales

• Chatbots y asistentes IA: Threads persistentes con message history y streaming en tiempo real
• Multi-agent systems: Workflows que coordinan múltiples agentes con diferentes modelos
• SaaS con IA billing: Usage tracking per-user para facturar por consumo de IA
• RAG applications: Vector search + text search integrados con el Agent component
• AI Town / simulaciones: Agentes que conversan entre sí con memoria persistente
• Customer support: Agentes con tools (account lookup, file ticket, send email) y human-in-the-loop
• Content generation: Workflows durables para research → draft → review → publish
• Apps realtime con IA: Cualquier app que necesite reactividad + agentes IA en el mismo backend

Conclusión

Convex es el backend más integrado para agentes IA en 2026. Mientras otras soluciones te hacen ensamblar database + vector store + websocket server + agent framework + rate limiter + usage tracker por separado, Convex lo trae todo en un solo paquete TypeScript con type safety end-to-end.

El Agent component elimina el boilerplate de manejar threads, messages, context, streaming y workflows. El playground hace debugging visual. El usage tracking habilita billing desde día uno. Y el MCP server + Agent Skills permiten que Claude Code, Cursor y otros agents trabajen directamente con tu backend.

Para developers que construyen products con IA, Convex elimina la fricción de backend para que te enfoques en el producto. Y con el free tier de 1M function calls/mes, puedes empezar sin coste.