TL;DR: Langfuse is an open-source LLM observability platform. It captures the traces and generations from your AI apps — prompts, completions, model, token usage, latency and cost — so you can actually see what your LLM calls are doing. Now packaged for Cloudron and ready to install. Built and tested on Cloudron 9.x; unofficial and community-maintained.

Links

• Project homepage: https://langfuse.com
• Upstream repo: https://github.com/langfuse/langfuse
• 🧱 Cloudron package repo: https://github.com/OrcVole/langfuse-cloudron

Self-hosted, so there's no public demo to click — once installed it has a full web UI at your chosen domain, behind your Cloudron login. (Screenshot below.)

How to install

Community packages aren't in the App Store, so install via the CLI or easily as explained here:

Installation

• Click on the Add custom app drop down top right in the App Store and choose Community app:
• Then paste in the CloudronVersions.json URL into the box that pops up:

# recommended: install the published community build from the versions URL
cloudron install \
  --versions-url https://raw.githubusercontent.com/OrcVole/langfuse-cloudron/main/CloudronVersions.json \
  --location langfuse.example.com

# or pin the prebuilt image directly (digest is in CloudronVersions.json)
cloudron install \
  --image ghcr.io/orcvole/langfuse-cloudron@sha256:3e1388815ef1d0faecd9f4571e174d8ffa0e2d2a01a658119629c62d5e501dbb \
  --location langfuse.example.com

# or build it yourself from the repo
git clone https://github.com/OrcVole/langfuse-cloudron.git
cd langfuse-cloudron
cloudron build
cloudron install --image your-registry/langfuse:latest --location langfuse.example.com

Minimums: 5 GiB RAM (ClickHouse is the main consumer; a 4 GiB constrained option is documented). Addons used: localstorage, postgresql, redis, oidc, and sendmail (optional). It also claims one extra subdomain for trace-media presigned URLs — Cloudron prompts for it during install. Needs box version 9.1.0+.

First run: sign in with your Cloudron account (OIDC SSO). Create a project, then copy your public and secret API keys from the Langfuse UI (Settings → API Keys) for your SDKs or the OTLP endpoint. The trace-encryption key is generated for you and preserved across updates and restores — you never have to manage it.

For users

Why try it: if you're building anything with LLMs and can't see what your prompts, completions, costs and latencies actually are, Langfuse is the open-source answer — self-hosted, on your own box.

What you get out of the box:

• Trace and generation capture from the Langfuse SDKs (Python/JS) or any OpenTelemetry/OTLP client — prompts, completions, model, tokens, cost, latency.
• Evals, datasets, prompt management and dashboards layered on top of those traces.
• Cloudron-specific wins: SSO through your Cloudron login, automatic backups (the bundled ClickHouse, the trace media and the secrets all ride along), one-click updates with your encryption key preserved, and all state under /app/data.

Good fit if you run AI apps and want self-hosted observability instead of shipping traces to a SaaS. Probably not for you if you only need basic request logging, or if you specifically need the enterprise/EE features — this ships the MIT core only.

🧰 For packagers: what we learned

What helped

• Cloudron's postgresql and redis addons cover two of Langfuse's four stores out of the box, so only ClickHouse and S3 needed bundling.
• localstorage gives /app/data backup and restore for free — the bundled ClickHouse and MinIO data ride along with it, no custom backup hook needed.

What was tricky and how we solved it

• Langfuse ships musl (Alpine) Node and Prisma engine binaries, but the Cloudron base is glibc. Because the ELF interpreter is per-binary, the two coexist: we run the upstream musl Node and musl Prisma engines in place via an isolated musl loader, with PRISMA_*_ENGINE pointed at version-agnostic paths so Prisma doesn't try to re-detect the platform.
• ClickHouse defaulted to listening on all interfaces — removed the docker-related config so it binds localhost only.
• MinIO collided with ClickHouse on a port; moved MinIO to alternate ports.
• A bootstrap script used a bashism (&>) but /bin/sh is dash — run it with bash, not sh.

Still rough and open questions

• Memory sizing: ClickHouse is the swing factor. We default to 5 GiB; real-world footprint reports would be very welcome.

️ For the Cloudron team

Maintenance burden: Langfuse is very actively developed and releases often, so expect regular version bumps — but the build takes a single LANGFUSE_VERSION arg, so a rebump is one line plus a rebuild.

Why it would suit the App Store: LLM observability is a hot category with real demand, the upstream is clean with official Docker images, ingestion is the vendor-neutral OTLP standard, and the core is MIT.

Friction worth knowing about: the versions-url install path silently requires packagerName in the manifest (it's stricter than the documented schema and fails install without it); and the httpPorts contract (manifest key = the runtime env var that holds the subdomain FQDN) took some trial and error to get right.

For the app's developers and contributors

A few low-effort things that help packagers a lot:

• Document the musl-vs-glibc assumption explicitly — that the Node and Prisma binaries are musl surprises anyone packaging onto a glibc base.
• Keep the single-encryption-key and single-data-directory model; it's what makes backup/restore clean.
• Keep tagging releases and publishing the changelog so we can track update triggers.

Package source and PRs welcome here: https://github.com/OrcVole/langfuse-cloudron. Happy to co-maintain.

Unlocks

Once it's running, you can:

• Point any LLM app's OpenTelemetry exporter or Langfuse SDK at your own instance and watch traces and generations land in real time.
• Track token usage and cost per model, feature or user across all your AI apps — fully self-hosted, nothing leaves your box.

Synergies

Pairs nicely with other Cloudron apps:

• Langfuse + Open WebUI: Open WebUI's built-in OpenTelemetry export lands infrastructure traces in Langfuse over TLS (point OTEL_EXPORTER_OTLP_ENDPOINT at the Langfuse OTLP path with OTEL_OTLP_SPAN_EXPORTER=http); for rich per-generation tracing, use Open WebUI's Pipelines Langfuse filter.
• Langfuse + your own AI code: any app or script using the Langfuse Python/JS SDK — RAG pipelines, agents, batch jobs — gets a full trace and generation tree, including model, prompt and token usage.

Feedback, bug reports, and "works on my install" confirmations all welcome below.