Instalar Langfuse con Docker: Alternativa Self-Hosted a LangSmith

Esta guía instala Langfuse v4 con Docker Compose en tu propio servidor: una alternativa self-hosted a LangSmith que mantiene las trazas LLM, los costes y las evaluaciones en hardware que controlas. Langfuse es una plataforma open-source de ingeniería LLM con observabilidad, analítica, gestión de prompts, evaluaciones y experimentos con datasets en un solo stack. Está en 35,6k estrellas de GitHub (comprobado 10-10-2026), y el equipo se ha unido a ClickHouse, lo que importa porque ClickHouse es el motor de analítica debajo.

La cuestión de la versión primero, porque decide todo lo demás: Langfuse v4.0.0 salió el 29-07-2026 y v4.56.0 llegó el 09-10-2026. Langfuse v3 recibe solo parches de seguridad hasta finales de enero de 2027. Las instalaciones nuevas nunca deberían empezar en v3 ahora. Si ya corres v3, la sección de actualización de abajo recorre la migración; la infraestructura no cambia.

Funciones:

Qué hay de nuevo en Langfuse v4 (y por qué las instalaciones nuevas deberían saltarse v3)

v4 es mayormente un cambio de motor, no una reescritura del producto. El mayor cambio es el modelo de datos ClickHouse: los eventos aterrizan en events_full (filas anchas inmutables) con una proyección events_core optimizada para consultas encima. Las trazas ahora son spans raíz dentro de la misma tabla (span ID t-<trace_id>), y la superficie principal de la UI es una vista única de Observations, abierta filtrada a Is Root Observation = true. Si tienes capturas o memoria muscular de la tabla de trazas de v3, espera una primera pantalla distinta.

Lo que ese modelo de datos desbloquea para self-hosters (estas fueron primero funciones de Langfuse Cloud):

• Búsqueda de texto completo sobre inputs, outputs y metadatos, más una barra de búsqueda con filtros.
• Monitores y alertas sobre métricas de trazas.
• Observations API v2 y Metrics API v2 para exportaciones de datos más limpias.
• Agente en la app movido fuera de la edición enterprise a beta pública.
• Mejor ergonomía de self-hosting en el compose oficial: inicialización headless vía LANGFUSE_INIT_*, LANGFUSE_AI_* para el asistente en la app y modelos de eval, LANGFUSE_MCP_* para el servidor MCP, LANGFUSE_S3_BATCH_EXPORT_*, y REDIS_TLS_*.

¿Por qué saltarse v3 por completo? Está en modo mantenimiento con una fecha de fin de soporte dura, y v4 corre sobre la infraestructura idéntica. La propia FAQ de la guía de actualización responde “¿Necesito nuevos componentes de infraestructura?” con “No.” Los mismos contenedores web y worker, el mismo PostgreSQL, ClickHouse, Redis y S3. Empezar en v3 hoy significa hacer la migración después sin beneficio. Si ya estás en v3, lee la sección de actualización y la guía oficial de actualización v3 a v4. El historial de releases vive en GitHub releases.

Guía paso a paso para instalar Langfuse con Docker Compose

El recorrido de abajo cubre la instalación completa de Langfuse con Docker: archivo compose, secretos, verificación, HTTPS y backups. Si prefieres vídeo:

Si quieres vigilar CPU, memoria y disco mientras corre este stack, monta primero cómo monitorizar recursos del servidor y Docker. Langfuse es uno de los stacks compose más pesados que self-hostearás, y te dirá cuándo la máquina es demasiado pequeña.

1. Prerequisitos y dimensionado del VPS para Langfuse v4

Antes de empezar, ten esto en su sitio:

Los precios de VPS saltaron en bloque en 2026. Si estás replanteándote una máquina alquilada, mira qué cambió y cuándo gana un mini PC.

2. Archivo Docker Compose de Langfuse (imágenes v4)

El stack v4 son seis servicios, misma forma que v3:

1. langfuse-worker procesa eventos de trazas de la cola, los escribe en ClickHouse, y corre trabajos en segundo plano incluyendo el backfill histórico.
2. langfuse-web sirve la UI y las APIs públicas en el puerto 5061 del host. Este es el contenedor al que apunta tu reverse proxy.
3. postgres es la base de datos transaccional (PostgreSQL 17) para usuarios, organizaciones, proyectos, prompts y claves API.
4. clickhouse es el almacén OLAP para eventos y analítica. Aquí es donde vive el modelo de datos v4 (events_full + events_core).
5. minio es almacenamiento de blobs compatible con S3 para payloads de eventos (events/) y medios multi-modal (media/).
6. redis mantiene la cola de ingestión y la caché. Perderlo te cuesta eventos encolados, no tu base de datos.

Arquitectura self-hosted de Langfuse v4: langfuse-web y langfuse-worker conectados a PostgreSQL, Redis, ClickHouse y MinIO

Crea un directorio para el stack y suelta este archivo compose:

mkdir -p /opt/langfuse && cd /opt/langfuse

services:
  langfuse-worker:
    image: langfuse/langfuse-worker:4
    restart: always
    depends_on:
      postgres:
        condition: service_healthy
      minio:
        condition: service_healthy
      redis:
        condition: service_healthy
      clickhouse:
        condition: service_healthy
    ports:
      - 127.0.0.1:3030:3030 # worker health endpoint (new vs the old v3 file)
    environment:
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
      NEXTAUTH_URL: https://langfuse.yourdomain.com
      SALT: ${SALT}
      ENCRYPTION_KEY: ${ENCRYPTION_KEY}
      NODE_OPTIONS: --max-old-space-size=4096
      TELEMETRY_ENABLED: false
      CLICKHOUSE_MIGRATION_URL: clickhouse://clickhouse:9000
      CLICKHOUSE_URL: http://clickhouse:8123
      CLICKHOUSE_USER: ${CLICKHOUSE_USER}
      CLICKHOUSE_PASSWORD: ${CLICKHOUSE_PASSWORD}
      LANGFUSE_S3_EVENT_UPLOAD_BUCKET: langfuse
      LANGFUSE_S3_EVENT_UPLOAD_REGION: auto
      LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID: ${MINIO_ROOT_USER}
      LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD}
      LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT: http://minio:9000
      LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE: true
      LANGFUSE_S3_EVENT_UPLOAD_PREFIX: events/
      LANGFUSE_S3_MEDIA_UPLOAD_BUCKET: langfuse
      LANGFUSE_S3_MEDIA_UPLOAD_REGION: auto
      LANGFUSE_S3_MEDIA_UPLOAD_ACCESS_KEY_ID: ${MINIO_ROOT_USER}
      LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD}
      LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT: http://minio:9000
      LANGFUSE_S3_MEDIA_UPLOAD_FORCE_PATH_STYLE: true
      LANGFUSE_S3_MEDIA_UPLOAD_PREFIX: media/
      REDIS_HOST: redis
      REDIS_PORT: 6379
      REDIS_AUTH: ${REDIS_PASSWORD}

  langfuse-web:
    image: langfuse/langfuse:4
    restart: always
    depends_on:
      postgres:
        condition: service_healthy
      minio:
        condition: service_healthy
      redis:
        condition: service_healthy
      clickhouse:
        condition: service_healthy
    ports:
      - 5061:3000
    environment:
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
      NEXTAUTH_URL: https://langfuse.yourdomain.com
      NEXTAUTH_SECRET: ${NEXTAUTH_SECRET}
      SALT: ${SALT}
      ENCRYPTION_KEY: ${ENCRYPTION_KEY}
      NODE_OPTIONS: --max-old-space-size=4096
      TELEMETRY_ENABLED: false
      CLICKHOUSE_MIGRATION_URL: clickhouse://clickhouse:9000
      CLICKHOUSE_URL: http://clickhouse:8123
      CLICKHOUSE_USER: ${CLICKHOUSE_USER}
      CLICKHOUSE_PASSWORD: ${CLICKHOUSE_PASSWORD}
      LANGFUSE_S3_EVENT_UPLOAD_BUCKET: langfuse
      LANGFUSE_S3_EVENT_UPLOAD_REGION: auto
      LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID: ${MINIO_ROOT_USER}
      LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD}
      LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT: http://minio:9000
      LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE: true
      LANGFUSE_S3_EVENT_UPLOAD_PREFIX: events/
      LANGFUSE_S3_MEDIA_UPLOAD_BUCKET: langfuse
      LANGFUSE_S3_MEDIA_UPLOAD_REGION: auto
      LANGFUSE_S3_MEDIA_UPLOAD_ACCESS_KEY_ID: ${MINIO_ROOT_USER}
      LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD}
      LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT: http://minio:9000
      LANGFUSE_S3_MEDIA_UPLOAD_FORCE_PATH_STYLE: true
      LANGFUSE_S3_MEDIA_UPLOAD_PREFIX: media/
      REDIS_HOST: redis
      REDIS_PORT: 6379
      REDIS_AUTH: ${REDIS_PASSWORD}
      AUTH_DISABLE_SIGNUP: ${AUTH_DISABLE_SIGNUP}

  postgres:
    image: postgres:17-alpine
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5
      start_period: 10s
    volumes:
      - ./langfuse-db:/var/lib/postgresql/data:rw
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}

  clickhouse:
    image: clickhouse/clickhouse-server:25.12 # pinned: v4 minimum is 25.12, 26.4 recommended
    restart: always
    user: "101:101"
    ports:
      - 127.0.0.1:8123:8123 # localhost only
      - 127.0.0.1:9000:9000
    environment:
      CLICKHOUSE_DB: default
      CLICKHOUSE_USER: ${CLICKHOUSE_USER}
      CLICKHOUSE_PASSWORD: ${CLICKHOUSE_PASSWORD}
    volumes:
      - ./langfuse-clickhouse:/var/lib/clickhouse
      - ./langfuse-clickhouse-logs:/var/log/clickhouse-server
    healthcheck:
      test: wget --no-verbose --tries=1 --spider http://localhost:8123/ping || exit 1
      interval: 5s
      timeout: 5s
      retries: 10
      start_period: 30s

  minio:
    image: cgr.dev/chainguard/minio
    restart: always
    entrypoint: sh
    command: -c 'mkdir -p /data/langfuse && minio server --address ":9000" --console-address ":9001" /data'
    environment:
      MINIO_ROOT_USER: ${MINIO_ROOT_USER}
      MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD}
    ports:
      - 127.0.0.1:9090:9000 # localhost only
      - 127.0.0.1:9091:9001 # MinIO console, localhost only
    volumes:
      - ./langfuse-minio:/data
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 1s
      timeout: 5s
      retries: 5
      start_period: 10s

  redis:
    image: redis:7
    restart: always
    command: >
      --requirepass ${REDIS_PASSWORD}
      --maxmemory-policy noeviction
    ports:
      - 127.0.0.1:6379:6379 # localhost only, for debugging
    volumes:
      - langfuse_redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 3s
      timeout: 10s
      retries: 10
      start_period: 5s

volumes:
  langfuse_redis_data:

Una nota sobre registries, ya que el compose oficial hace pull desde docker.langfuse.com:

Notas sobre el archivo:

• Las variables de entorno (${VARIABLE_NAME}) mantienen secretos y hostnames fuera del YAML. La siguiente sección los genera.
• Todos los servicios de respaldo tienen healthchecks con start_period, y los contenedores Langfuse esperan a dependencias sanas antes de arrancar.
• Los bind mounts (./langfuse-db, ./langfuse-clickhouse, ./langfuse-minio) mantienen los datos en el filesystem del host. Prefiero bind mounts aquí frente a volúmenes nombrados: son triviales de empaquetar en tar en la sección de backups y triviales de inspeccionar cuando algo se rompe.
• Telemetría desactivada. El default de compose de Langfuse es ahora true, así que mantén esta línea si no quieres estadísticas phone-home.
• Los prefijos S3 events/ y media/ están puestos explícitamente; el servidor tiene los mismos defaults, así que esto es documentación más que configuración.
• Para despliegues reproducibles, fija la versión de patch exacta (por ejemplo langfuse/langfuse:4.56.0, actual al 10-10-2026). El tag :4 sigue el minor actual y se parchea aproximadamente a diario. Vigila los GitHub releases de cualquier modo.

La referencia completa de cada variable vive en los docs oficiales de configuración self-hosting. El archivo upstream contra el que hacer diff es el docker-compose.yml oficial de Langfuse.

3. El archivo .env: secretos y variables LANGFUSE_INIT opcionales

Crea .env junto al archivo compose:

POSTGRES_USER='langfuse'
POSTGRES_PASSWORD='change-me-strong'
POSTGRES_DB='langfuse'
NEXTAUTH_SECRET=
SALT=
ENCRYPTION_KEY=
CLICKHOUSE_USER=clickhouse
CLICKHOUSE_PASSWORD=change-me-strong
MINIO_ROOT_USER=minio
MINIO_ROOT_PASSWORD=change-me-strong
REDIS_PASSWORD=change-me-strong
AUTH_DISABLE_SIGNUP=false

Genera los tres secretos y pégalos. No deben ser adivinables, y ENCRYPTION_KEY tiene un formato fijo:

openssl rand -base64 32
openssl rand -base64 32
openssl rand -hex 32

Luego bloquea el archivo:

chmod 600 .env

Inicialización headless opcional: si prefieres no hacer clic por el registro de primer arranque, Langfuse puede pre-crear la organización, el proyecto, las claves API y el primer usuario desde variables env al arrancar. Añade esto a .env:

# Optional: headless initialization (skip the UI first-run flow)
# LANGFUSE_INIT_ORG_NAME=My Org
# LANGFUSE_INIT_PROJECT_NAME=default
# LANGFUSE_INIT_PROJECT_PUBLIC_KEY=pk-lf-...
# LANGFUSE_INIT_PROJECT_SECRET_KEY=sk-lf-...
# LANGFUSE_INIT_USER_EMAIL=you@yourdomain.com
# LANGFUSE_INIT_USER_PASSWORD=change-me-strong

Déjalas comentadas y el primer usuario se crea desde la página de registro en su lugar. Ambos caminos valen; el init headless es mejor cuando automatizas despliegues y quieres una clave API impresa en logs en vez de cliqueada. Detalles en los docs de inicialización headless.

4. Desplegar el stack y verificar que está sano

Arranca todo desde el directorio con el archivo compose:

docker compose up -d

Eso baja imágenes, crea contenedores y los arranca en segundo plano. Comprueba que existen:

docker compose ps

Los seis servicios deberían reportar running, y los cuatro servicios de respaldo deberían pasar a healthy en cosa de un minuto.

Vigila el contenedor web hasta que esté listo:

docker compose logs -f langfuse-web

La señal de éxito es una línea de log Ready. Luego golpea los endpoints de salud:

# web: expect {"success":true}
curl -s http://localhost:5061/api/public/health | jq

# web with DB check: expect {"success":true}
curl -s "http://localhost:5061/api/public/health?failIfDatabaseUnavailable=true" | jq

# readiness: expect 200
curl -s -o /dev/null -w '%{http_code}\n' http://localhost:5061/api/public/ready

# worker: expect {"success":true}
curl -s http://localhost:3030/api/health | jq

La referencia oficial de endpoints es el doc de endpoints de salud y readiness. Dos modos de fallo aparecen aquí más a menudo: una dependencia atascada en unhealthy (casi siempre credenciales malas en .env, revisa docker compose logs postgres o clickhouse), y el puerto 5061 del host ya ocupado (ss -tlnp | grep 5061, luego cambia el puerto del host en el archivo compose). Más de estos en la sección de troubleshooting.

5. HTTPS con Cloudflare Tunnels

Cloudflare Tunnels conectan tu app a internet sin abrir puertos entrantes en el servidor. El daemon cloudflared marca hacia la red de Cloudflare y mantiene un tunnel persistente a tu origen. Las peticiones a tu dominio bajan por ese tunnel a tu servidor, y las respuestas suben por él. Sin port forwarding, sin agujeros de firewall.

En el panel de Cloudflare Zero Trust, ve a Access - Tunnels, elige tu tunnel, y añade un hostname que mapee tu subdominio al servicio y puerto (http://langfuse-web:3000 si el tunnel corre en la misma red Docker, o http://localhost:5061 si corre en el host).

Verifica desde tu estación de trabajo:

curl -I https://langfuse.yourdomain.com

Deberías obtener un 302 o 200 apuntando a la página de login de Langfuse, no un error de Cloudflare. Si ves un 502, el tunnel no puede alcanzar el puerto de origen.

Alternativamente, puedes usar Setup CloudPanel as Reverse Proxy with Docker and Dockge o How to Use Traefik as A Reverse Proxy in Docker.

6. Primer login: crea tu cuenta de admin (o haz init headless)

Una vez dentro, el ciclo de despliegue está cerrado: proyecto creado, clave API generada, listo para trazar. En v4 la pantalla principal es la vista de Observations filtrada a observaciones raíz, no la vieja tabla de trazas de v3, así que las capturas más viejas pueden resultar extrañas.

Puedes integrarlo con tus apps IA a continuación. El vídeo incrustado muestra la integración con Flowise; para la otra mitad de ese stack mira cómo instalar FlowiseAI con Docker Compose.

Actualizar una instalación Langfuse v3 existente a v4

Si seguiste la versión vieja de esta guía, la actualización son tres pasos y puedes pausar entre ellos. No es una instalación nueva: tus datos se quedan en los mismos bind mounts. El detalle completo vive en la guía oficial de actualización v3 a v4; esto es el resumen para operadores.

Cronología de migración de Langfuse v3 a v4: backup, actualización de ClickHouse, imágenes v4 con backfill, luego cutover

Paso 1: actualiza ClickHouse primero, aún en v3. v4 necesita ClickHouse >= 25.12 (26.4 recomendado) para lightweight updates, el tipo JSON y la búsqueda de texto completo. Las releases v3 actuales son compatibles con ClickHouse actual, así que sube la imagen en el stack v3 corriendo:

clickhouse:
  image: clickhouse/clickhouse-server:25.12

docker compose up -d clickhouse
docker compose ps   # clickhouse must go healthy before you continue

Paso 2: sube las imágenes del servidor a v4. Cambia langfuse/langfuse:3 y langfuse/langfuse-worker:3 a :4, luego:

docker compose pull
docker compose up -d

Las migraciones de schema corren automáticamente al arrancar. Los datos históricos se re-rellenan en segundo plano, de más nuevo a más viejo. El backfill es reanudable, pero necesita espacio de trabajo.

El comportamiento de escritura durante la migración se controla con variables env que puedes poner en ambos contenedores:

Si corre un periodo de escritura dual, comprueba la sonda de propagación del worker (espera la publicación de puerto 127.0.0.1:3030 del archivo compose de arriba):

curl -s "http://localhost:3030/api/health?failIfEventPropagationStuck=true" | jq

Un 503 significa que la propagación de eventos lleva atascada más de 15 minutos. Arréglalo antes del cutover.

Paso 3: cutover, el punto de no retorno. Actualiza primero tus SDKs: la escritura directa necesita Python SDK >= 4.7.0 y JS/TS SDK >= 5.4.0. Los clientes Python v2 y JS/TS v3 son rechazados una vez que estás en la nueva ruta de escritura. Luego mueve los evaluadores a puntuación a nivel de observación, cambia las exportaciones a la fuente “Enriched observations”, y corre con defaults. Desde aquí, un rollback a v3 es un rewind de schema (migrate ... goto 37 desde la imagen web v4 en /app/packages/shared) o una restauración desde tu backup. Prefiere el backup.

La infraestructura en sí no cambió: mismos contenedores web y worker, mismo PostgreSQL, ClickHouse, Redis y S3. Solo se movieron las versiones mínimas (ClickHouse 25.12, PostgreSQL 15, Redis 7.0). Una advertencia honesta: este resumen sigue la guía oficial, pero una actualización de ClickHouse en sitio sobre datos en bind-mount merece una pasada en staging antes de hacerla en algo que te importe.

Troubleshooting: fallos comunes de la instalación Docker de Langfuse

Asegurar tu instancia Langfuse self-hosted

Por defecto, cualquiera que encuentre la URL puede registrarse y crear una cuenta. Después de crear la cuenta de admin, activa el flag en .env:

AUTH_DISABLE_SIGNUP=true

Aplica el cambio:

docker compose up -d

Más opciones de endurecimiento de los docs oficiales de hardening:

• AUTH_EMAIL_VERIFICATION_REQUIRED=true si tienes SMTP configurado.
• AUTH_SESSION_MAX_AGE controla la duración de la sesión (default 43200 minutos, 30 días). Bájalo en máquinas compartidas.
• AUTH_DOMAINS_WITH_SSO_ENFORCEMENT y AUTH_DISABLE_USERNAME_PASSWORD=true si corres SSO y quieres que el login con contraseña desaparezca por completo.
• Langfuse self-hosted rechaza objetivos privados o de loopback para conexiones LLM configuradas por el usuario y webhooks por defecto (defensa SSRF). Hay overrides *_WHITELISTED_* si apuntas intencionadamente a un servidor de modelos interno.

A nivel de servidor entero, no solo Langfuse: cómo aseguré mi servidor Docker (guía de hardening BSI) cubre el firewall y los agujeros específicos de Docker que importan aquí.

Límite de coste que vale conocer: el núcleo es licencia MIT y gratis para siempre, pero SSO/SAML, RBAC, SCIM y audit logs viven en la edición enterprise y requieren una clave de licencia de pago. Todo lo de esta guía corre sin ella.

Hacer backup de tus volúmenes Docker de Langfuse

Self-hostear significa que los datos son tuyos de perder. El stack escribe en tres bind mounts y un volumen nombrado:

Los backups de ClickHouse son tu trabajo al self-hostear. La guía oficial de backups dice lo mismo: snapshots de volumen o clickhouse-backup, tú eliges. Un script mínimo programable por cron:

#!/usr/bin/env bash
set -euo pipefail
cd /opt/langfuse
set -a; source ./.env; set +a   # export POSTGRES_USER / POSTGRES_DB for pg_dump
STAMP=$(date +%F)
DEST="/backup/langfuse/$STAMP"
mkdir -p "$DEST"

# Postgres logical dump
docker compose exec -T postgres pg_dump -U "$POSTGRES_USER" "$POSTGRES_DB" | gzip > "$DEST/postgres.sql.gz"

# ClickHouse: cold copy of the data dir (stop-free, consistent enough for most self-hosters;
# use clickhouse-backup for stricter consistency)
sudo tar -czf "$DEST/clickhouse.tar.gz" ./langfuse-clickhouse

# MinIO blobs
sudo tar -czf "$DEST/minio.tar.gz" ./langfuse-minio

# Secrets: without these, the volume backups are half a restore
cp .env "$DEST/env.copy"

# Offsite sync (rclone, restic, rsync over SSH, whatever you already trust)
# rclone sync "$DEST" remote:langfuse-backups/"$STAMP"

Verifica el backup, no solo el trabajo de backup. Restaura los tres directorios de datos más .env en un directorio compose limpio en otra máquina, corre docker compose up -d, y comprueba que aparecen tus proyectos y trazas. Un backup que nunca has restaurado es una hipótesis. Para la parte offsite, mira configurar backups de Dokploy con Cloudflare R2 (compatible con S3).

Langfuse self-hosted vs LangSmith: precios 2026

La parte de “alternativa a LangSmith” del título es mayormente un argumento de coste y control de datos. Cifras al 10-10-2026:

La matemática de coste del self-hosting es el VPS más tu tiempo. En una máquina clase CPX41 de Hetzner (orden de magnitud 15-25 €/mes) tienes trazas ilimitadas y usuarios ilimitados, y el trade-off es que posees las actualizaciones y los backups. Cuando un equipo necesita SSO/SAML, RBAC, SCIM o audit logs, esos son features de la edición enterprise que necesitan una clave de licencia de pago encima. La plataforma núcleo de esta guía sigue gratis de todas formas.

Conclusión

Self-hostear Langfuse con Docker Compose te da control total sobre tus datos y corre la misma infraestructura que alimenta Langfuse Cloud. El rendimiento depende de tu hardware, el ejemplo oficial empieza en 4 núcleos y 16 GiB, y los endpoints de salud te dicen rápido cuándo algo va mal.

El resumen para operadores: despliega el stack v4 de seis servicios, verifica con /api/public/health y la sonda del worker, haz backup de los volúmenes más .env antes de necesitarlos, y decide entre el tag flotante :4 y un langfuse/langfuse:4.56.0 fijado (actual 10-10-2026) según quieras parches automáticos o despliegues reproducibles. Si sigues en v3, actualiza antes de finales de enero de 2027.

Un ángulo más si usas agentes de codificación: la organización Langfuse publica plugins de observabilidad que trazan sesiones de Claude Code, Codex, Cursor, OpenCode y Pi a Langfuse, más un servidor MCP (el bloque env LANGFUSE_MCP_*) que expone la gestión de prompts a agentes. Es pronto, pero trazar sesiones de agentes al mismo sitio que las trazas de tu app es útil una vez que depuras ejecuciones de agente multi-paso.

Si quieres explorar más contenedores Docker para tu home server, incluyendo otras herramientas IA, mira los mejores 100+ contenedores Docker para home server. Langfuse también está listado con LiteLLM, OmniRoute y el stack de agentes en top AI GitHub repos.