Langfuse
Open-source LLM observability - tracing, evals, prompt management - the full v3 stack with no per-unit metering.
One-click deploy, from $49/mo on a Miget plan.
The moment agents ship, tracing volume explodes: every LLM call, tool invocation, and retry becomes a span you want to see when something goes weird. Langfuse is the open-source standard for that - traces, evaluations, prompt management, cost and latency dashboards - with SDKs and OpenTelemetry support across every framework.
This template mirrors the official v3 self-host topology: web and worker on a managed Postgres, single-node ClickHouse for the analytics volume (CLICKHOUSE_CLUSTER_ENABLED=false, no Keeper), a Valkey wrapper pinned to maxmemory-policy=noeviction (Langfuse queues jobs there - eviction would lose events), and a MinIO blob store with the bucket pre-created.
Hosted LLM observability meters by the unit - and a busy agent emits thousands per hour. Self-hosted Langfuse meters nothing; ClickHouse compression eats traces for breakfast, and the catalogue’s sizing gives it room to.
Upstream project: Langfuse
#what you get
- Tracing for LLM apps and agents: spans, generations, costs, latencies
- Evals: LLM-as-judge, human annotation queues, datasets and experiments
- Prompt management with versioning and deployment labels
- SDKs (Python/JS), OpenTelemetry, and integrations for every framework
- Official v3 topology: web + worker + Postgres + ClickHouse + Valkey + S3
- No tracing-unit metering - volume costs disk, not dollars
#topology
| Service | Role | Public |
|---|---|---|
| web | Langfuse UI + API (:5000) | yes |
| worker | async ingestion/processing | no |
| db | Postgres - managed service on Miget | no |
| clickhouse | single-node ClickHouse (traces, analytics) | no |
| cache | Valkey, noeviction (queue) | no |
| blob | MinIO S3 store (events/media), bucket pre-created | no |
#miget sizing
// this stack needs
7 GiB RAM · 35 GB disk · 6 services
ClickHouse is the scaling dial - 2 GiB suits steady team usage; raise it (and its 20 GB volume) as trace volume grows. Web and worker scale independently at 1 GiB each.
Hobby - recommended fit
$49/mo
4 vCPU · 8 GiB · 160 GiB disk
Headroom for your own apps: 16 GiB at $97/mo
Professional - production
$85/mo
4 vCPU · 8 GiB · 50 GiB disk
Dedicated resources, production SLOs - plan details
One Miget plan is a fixed pool of compute - the whole stack (managed databases included) deploys inside it, and anything left over runs your other apps. No per-service or per-seat math.
#vs. the managed service
What the hosted equivalents charge, against the flat Miget plan this stack fits on. Prices as of June 2026, sources linked.
| Service | Plan | Monthly | What you get |
|---|---|---|---|
| Langfuse on Miget ★ | 8 GiB plan | $49 | this whole stack, flat - no usage meters, and room left for your own apps |
| Langfuse Cloud | Core | ~$29 | 100k tracing units/mo, then graduated overage from $8/100k; Pro $199/mo |
| LangSmith | Plus | ~$39 | per seat + 10k traces included, then $2.50 per 1k base traces |
LLM tracing volume explodes the moment agents ship - every span is a unit. Self-hosted Langfuse meters nothing; ClickHouse compression eats traces for breakfast.
#vs. other PaaS
Estimated monthly cost of running this exact stack (7 GiB RAM, 35 GB disk, 6 containers) elsewhere, from published June 2026 rates.
| Platform | Est. monthly | Notes |
|---|---|---|
| Miget ★ | $49 flat | compose stacks first-class: one deploy, dedicated vCPU, managed Postgres/Valkey, volumes and TLS all included in the plan |
| Heroku | ~$350 | no volumes; nothing between 1 GB ($50) and 2.5 GB ($250) dynos - 2 GB containers cost far more than shown |
| Render | ~$96 | per-service instances (0.5 GB $7, 2 GB $25) - every container is its own paid service |
| DO App Platform | ~$89 | no persistent volumes - stateful containers need managed DBs/Spaces (base $5 Spaces included here) |
| Railway | ~$75 | usage-based ($10/GB RAM-mo); vCPU billed separately at $20/vCPU-mo on top |
| Fly.io | ~$47 | cheapest sticker price - but burstable shared CPUs (1/16 core; dedicated vCPUs cost ~2-3×), no compose deploys (one app per container, manual wiring), managed DBs billed extra |
Estimates assume RAM fully allocated at published on-demand rates - and sticker price isn't the whole comparison: the cheaper rows buy burstable shared CPUs, per-service wiring instead of a compose deploy, and managed databases billed separately. Heroku and DO App Platform have no persistent volumes at all - stateful stacks like this one need workarounds there.
#deploy it
On Miget
- Create a Compose Stack in app.miget.com pointing at the templates repository
- Set the stack path to
langfuse -
Set the required variables:
NEXTAUTH_SECRET / SALT, auth + API-key hashing (openssl rand -base64 32 each)ENCRYPTION_KEY, exactly 64 hex chars (openssl rand -hex 32)CLICKHOUSE_PASSWORD / REDIS_AUTH / MINIO_ROOT_PASSWORD, internal service credentialsNEXTAUTH_URL, set to the web app’s https domain after first deploy
- Deploy. Miget layers
compose.miget.yaml(RAM, privacy, volumes, managed services) automatically
Locally first?
Every template is portable, vanilla Docker Compose - the Miget overrides are ignored locally:
git clone https://github.com/deployable-sh/stacks
cd miget-compose-templates/langfuse
docker compose up -dSame files, same behavior. The template README covers connection strings and scaling notes.
#faq
How does self-hosting compare to Langfuse Cloud pricing?
Langfuse Cloud Core is $29/month for 100k tracing units with graduated overage from $8 per 100k - and agentic apps burn units fast, since every span counts. This stack is $49/month flat at any volume; the crossover for a team running agents in production arrives within weeks.
Is self-hosted Langfuse the full product?
The core platform - tracing, evals, datasets, prompt management, dashboards - is MIT-licensed and fully included. A few enterprise features (SSO enforcement, audit logs) sit behind a commercial license, same as the cloud tiers gate them.
Why does the stack need six services?
It mirrors the official v3 architecture: Postgres for transactional state, ClickHouse for the analytical trace volume, a queue (Valkey) between API and worker so ingestion never blocks, and S3 (MinIO) for raw event and media payloads. The template wires all of it - you deploy one stack.
How do my apps send traces to it?
Point the Langfuse SDK (or OpenTelemetry exporter) at your web app domain with keys from project settings. Apps inside the same Miget project can use http://web:5000 and skip the public hop entirely.
Does single-node ClickHouse limit me?
Not until serious scale - single-node handles hundreds of millions of spans with compression. The template sets CLICKHOUSE_CLUSTER_ENABLED=false accordingly; if you ever outgrow it, the catalogue’s 3-node clickhouse template is the upgrade path.
Ship Langfuse today
One compose stack, 7 GiB of RAM, from $49/month flat, and it runs on your laptop with the same files.