Builder CRM

CRM multicanal con agente de IA, hecho para entregarle una instancia propia a cada
cliente. Una bandeja para WhatsApp, Instagram y Messenger, un agente que califica
leads y mueve el pipeline, y un arnes de Claude Code que adapta, despliega y prueba
una instancia con un solo prompt.

Open source, licencia MIT: usalo, modificalo, desplegalo para tus clientes y cobra
por eso. Nacio dentro de la comunidad IA Builder Lab, que es donde se ensena a usarlo,
pero no hace falta ser miembro de nada para que sea tuyo.

"Adapta Builder CRM para una inmobiliaria llamada Casa Sur, con modulo de
propiedades y agendamiento de visitas, y despliegalo en mi Coolify."
Claude escribe la spec, configura, construye, despliega, prueba y entrega la URL.

Que trae el nucleo

• Login con roles admin y asesor (Supabase Auth): un asesor ve solo sus contactos.
• Bandeja multicanal en tiempo real (Zernio: WhatsApp, Instagram DM, Messenger),
  ventana de 24 h y plantillas de WhatsApp.
• Contactos con ficha, documentos (bucket S3 opcional), campos personalizados por
  cliente y resumen del agente.
• Pipeline kanban con etapas configurables que el agente puede mover.
• Agente de IA (OpenRouter, modelo por variable): lee el historial, responde por
  el canal, actualiza la ficha, mueve etapas, registra actividades, deja un resumen y
  deriva a una persona (pausa por conversacion).
• Reportes reales por periodo y dashboard honesto.
• Ajustes: canales, agente por canal, equipo, notificaciones push.
• Entrar con Google y otros proveedores, opcional: ver docs/GOOGLE-AUTH.md.
• Invitaciones por correo y "olvide mi contrasena", opcional: ver
  docs/CORREO.md. Sin esto, el admin crea la cuenta y pasa la
  contrasena temporal a mano, que es como viene de fabrica.
• Automatizaciones (disparador -> filtros -> acciones), PWA instalable.
• Simulador: chatear con el agente sin ningun canal conectado (demos y
  autoverificacion).
• Modulos: todo lo especifico de un cliente vive en modules/ y se enciende por
  configuracion. Plantilla de nicho incluida: inmobiliaria (propiedades + visitas).

Requisitos

• Node.js 22 y npm. Nada mas para probarlo: el modo local trae su propia base.
  En Windows, clona en una ruta corta (C:\proyectos\...): con carpetas muy
  anidadas, el compilador de Next falla por el limite de caracteres del sistema de
  archivos.
• Para una instancia de verdad: una cuenta de Supabase (un proyecto por cliente;
  el plan gratuito alcanza), o tu propio Postgres mas GoTrue en el VPS (ver
  docs/SUPABASE-EN-VPS.md).
• Para desplegar: un VPS con Coolify y un dominio.
• Opcional: OpenRouter (agente), Zernio (canales), bucket S3 (documentos).
• Claude Code con el repo abierto; ver CLAUDE.md y
  docs/MCP.md.

Probarlo en tu PC (2 minutos, sin crear ninguna cuenta)

git clone https://github.com/diegovasquez-ai/builder-crm.git && cd builder-crm
npm install
npm run local

Y ya esta: http://localhost:3000 con el CRM lleno de datos de demostracion. No hace
falta Supabase, ni Docker, ni un archivo .env.

npm run local levanta un Postgres embebido (un paquete de npm compilado a
WebAssembly, guardado en .local/db), aplica las mismas migraciones que una instancia
desplegada —con su RLS—, carga los datos demo y abre el CRM. No hay login: en modo
local no hay servidor de autenticacion, asi que entras directo como administrador y el
menu lateral te lo recuerda.

Para que el agente responda en el simulador hace falta una clave de OpenRouter:
copia .env.example a .env.local y pone OPENROUTER_API_KEY. Sin ella el CRM
funciona igual (los mensajes entran a la bandeja y crean el contacto), solo que nadie
contesta del otro lado.

Lo que el modo local no tiene, porque necesita una instancia de verdad: login,
equipo con roles, invitaciones por correo y la busqueda semantica del modulo
propiedades (el Postgres embebido no trae pgvector).

Con tu propio Supabase (para adaptar y desplegar)

cp .env.example .env.local        # completar al menos Supabase (4 variables)
npm run db:migrar                 # crea tablas, RLS y el trigger del primer admin
npm run dev                       # http://localhost:3000

1. Abre /signup: mientras no haya miembros, el registro esta abierto y la primera
   cuenta queda como administrador. Despues se cierra solo.
2. En el inicio pulsa Cargar demo (o npm run seed) para ver el CRM lleno.
3. Abre Simulador y chatea con el agente (necesita OPENROUTER_API_KEY).
4. Conecta WhatsApp/Instagram/Messenger cuando quieras: skill conectar-zernio.

Sin interfaz: npm run admin:crear -- --email [email protected] --password 'xxxxxxxx'.

Desplegar en Coolify

Resumen (el detalle paso a paso esta en la skill deploy-coolify):

1. Base y Auth. Dos caminos y conviene elegir antes de empezar:

   • Supabase cloud, un proyecto por cliente. Mas rapido, con panel y respaldos; el
     plan gratuito pausa los proyectos inactivos.
   • Autoalojados en el mismo Coolify (Postgres + GoTrue): sin cuenta de Supabase,
     sin pausas y sin costo por cliente, pero los respaldos son tuyos. Es el camino de
     la instancia de demostracion. Guia:
     docs/SUPABASE-EN-VPS.md.

   Despues, desde tu maquina: npm run db:migrar y npm run admin:crear.

2. En Coolify: aplicacion desde el repo (build pack Dockerfile, puerto 3000,
   dominio) y las variables de .env.example, todas en runtime. No
   hace falta marcar ninguna como "Build Variable": desde 1.2.2 el servidor le pasa al
   navegador la configuracion publica en tiempo de ejecucion, asi que la misma imagen
   sirve para cualquier instancia. El Dockerfile igual acepta las NEXT_PUBLIC_* como
   build args, por si construis en una plataforma que las hornea (Vercel).

3. Deploy. Las migraciones corren solas al arrancar el contenedor.

4. curl https://<dominio>/api/health -> {"ok":true,"version":"<la del package.json>","db":"ok"}.

5. node scripts/seed-demo.mjs --url https://<dominio> y
   node scripts/verificar-instancia.mjs --url https://<dominio> --email ... --password ....

Tambien funciona con docker compose up -d --build (solo la app; la base es
Supabase) o en Vercel (vercel.json + barridos por GitHub Actions).

Adaptarlo a un cliente (sin tocar el nucleo)

Zona del cliente: config/cliente.ts (marca, pipeline, campos, agente),
config/modulos.json, modules/<nombre>/, public/marca/, specs/<cliente>/.
Nucleo: src/, supabase/, scripts/, Docker. Reglas en
specs/CONSTITUCION.md.

// config/cliente.ts
import { plantillaInmobiliaria } from "./plantillas/inmobiliaria";
export default definirConfig({ ...plantillaInmobiliaria, marca: { ...plantillaInmobiliaria.marca, nombre: "Casa Sur" } });

config/modulos.json: { "activos": ["propiedades", "visitas"] } -> npm run db:migrar.

Con Claude Code: abre el repo y pide la adaptacion en lenguaje natural; la skill
adaptar-a-cliente sigue el flujo entender -> especificar -> configurar -> construir ->
desplegar -> probar -> entregar. Para un modulo nuevo: crear-modulo. Para una
plantilla nueva: nueva-plantilla-nicho.

Estructura

config/            zona del cliente: cliente.ts, modulos.json, plantillas/
modules/           modulos (ejemplo, propiedades, visitas, _plantilla)
public/marca/      logo e icono del cliente
specs/             constitucion, plantilla de spec, specs del nucleo y del cliente
tests/             invariantes que fallan en silencio (firma, ventana 24h, roles)
.local/            base embebida del modo local (no se versiona)
src/               nucleo (app, lib, components, db)
supabase/          migraciones del nucleo (base, RLS, primer admin)
scripts/           migrar, crear-admin, seed-demo, verificar-instancia, zernio:*
docker/, Dockerfile, docker-compose.yml
.claude/skills/    el arnes: 7 skills del flujo one-shot
docs/              MCP, agente, Zernio, Supabase en tu VPS, entrar con Google, correo

Scripts

Versiones

La version corre en package.json, se ve en /api/health y al pie del menu. SemVer
desde el punto de vista de quien opera una instancia:

Como traer una version nueva a una instancia adaptada: ACTUALIZAR.md.
Cambios por version: CHANGELOG.md. Secretos, roles y RLS:
SEGURIDAD.md.

Licencia

MIT. Copyright (c) 2026 Diego Vásquez. Podes usarlo, copiarlo, modificarlo,
desplegarlo para tus clientes, cobrar por eso y distribuirlo. La unica condicion es
conservar el aviso de copyright. Sin garantia: quien despliega una instancia es
responsable de sus datos, de sus credenciales y de lo que el agente le responda a las
personas que escriben. El texto completo esta en LICENSE.

Nacio como fork de auto-crm, tambien MIT; su
aviso de copyright se conserva en NOTICE, junto con el de las dependencias.
La arquitectura de entrega para agencias toma ideas de
vocero-crm.