Large Language Model (LLM)
What is Langfuse, and How to Deploy It in an Enterprise Data Stack?
Last updated on
May 12, 2026
What is Langfuse?
Langfuse is an open-source LLM engineering platform that's gaining traction among tech-savvy teams for its robust observability and tracing capabilities. Its core differentiator lies in its production-ready, asynchronous architecture that doesn't compromise application performance. Organizations appreciate Langfuse for its ability to streamline debugging, analysis, and iteration of LLM applications, offering features like model-based evaluations, user feedback collection, and manual annotations. Teams using Langfuse report significant improvements in application latency and quality, with one European fintech halving their application's response time through Langfuse's tracing insights. The platform's open-core model, extensive integrations, and focus on data ownership also make it an attractive choice for enterprises looking to maintain control over their LLM infrastructure while benefiting from advanced observability tools.
Why is Langfuse better on Shakudo?
While Langfuse is powerful on its own, deploying it on Shakudo's data and AI operating system takes it to the next level.
By running Langfuse on Shakudo, you get the best of both worlds: Langfuse's cutting-edge LLM tools and Shakudo's seamless deployment and integration capabilities. Instead of wrestling with complex setups or worrying about security, you can have Langfuse up and running in minutes with just a few clicks. Shakudo's automated DevOps ensures your Langfuse instance is always optimized and secure, while its deep integration ecosystem allows you to effortlessly connect Langfuse with your existing AI stack. This combination not only saves you time and resources but also provides a level of operational efficiency and scalability that's hard to achieve with other solutions or self-deployment.
Why is better on Shakudo?
Core Shakudo Features
Own Your AI
Keep data sovereign, protect IP, and avoid vendor lock-in with infra-agnostic deployments.
Faster Time-to-Value
Pre-built templates and automated DevOps accelerate time-to-value.
Flexible with Experts
Operating system and dedicated support ensure seamless adoption of the latest and greatest tools.
Getting Started & Usage
Once Langfuse is deployed and the health check passes, you can start sending traces in minutes. This page covers creating your first project, getting API keys, and instrumenting your applications.
Step 1: Create a Project and Get API Keys
Open the Langfuse UI (http://localhost:3000 or the cluster-internal URL), log in, and:
- Click New Project
- Give it a name (e.g. production, risk-team-app)
- Go to Settings > API Keys > Create new API key
- Copy the Public Key and Secret Key — the secret is shown once
Sending Traces via the Python SDK
LiteLLM Integration (Automatic Tracing)
If you use LiteLLM, enable the Langfuse callback once and every model call is traced automatically. No SDK calls needed in application code.
# In LiteLLM litellmConfig
litellm_settings:
success_callback: ["langfuse"]
failure_callback: ["langfuse"]
langfuse_host: <http://langfuse.hyperplane-langfuse.svc.cluster.local:3000>
langfuse_public_key: os.environ/LANGFUSE_PUBLIC_KEY
langfuse_secret_key: os.environ/LANGFUSE_SECRET_KEY
LangChain Integration
from langfuse.callback import CallbackHandler
handler = CallbackHandler(
public_key="pk-...",
secret_key="sk-...",
host="<http://langfuse.hyperplane-langfuse.svc.cluster.local:3000>"
)
# Pass the handler to your LangChain chain
chain.invoke({"input": "Tell me about..."}, config={"callbacks": [handler]})
Dify Integration
Dify has a built-in Langfuse integration. In Dify settings:
- Go to Settings > Model Provider / Monitoring
- Enable Langfuse tracing
- Enter your Langfuse host, public key, and secret key
All Dify workflow executions and LLM calls will appear as traces in Langfuse automatically.
Viewing Traces in the UI
Open the Langfuse UI and navigate to Traces. For each trace you will see:
- Full timeline: every step and LLM call with start time and duration
- Input and output for each span
- Token usage and estimated cost per step
- Model used and latency
Click any span to expand it and see the full prompt and response.
Key Navigation
- Traces: all individual traces, filterable by user, session, date, model
- Sessions: groups of traces belonging to the same conversation
- Generations: all LLM calls across all traces, ranked by cost or latency
- Scores: evaluations attached to traces or spans
- Prompts: versioned prompt templates managed in Langfuse
- Datasets: collections of inputs used for evaluation runs
Shakudo SaaS-first quick start
This section is for customers using Langfuse as a managed component inside Shakudo. Start from the Shakudo platform instead of installing or exposing Langfuse manually.
1. Access the component in Shakudo
- Sign in to your Shakudo workspace with your organization-approved account.
- Open the workspace or environment where this component is enabled.
- Go to the Applications or component catalog area and select Langfuse.
- If you cannot see the component, ask your workspace administrator to confirm that it is enabled for your role and environment.
2. Open the component UI
- Use the Shakudo-provided Open, Launch, or Access action for Langfuse.
- Let Shakudo handle authentication, networking, and workspace routing. Avoid using internal service URLs unless your administrator explicitly provides them.
- Confirm that the component opens in the expected workspace before creating or changing resources.
3. Complete a first safe use case
Open the Langfuse UI, inspect traces for an existing application or send a small test trace from an approved client, then confirm the trace appears in the project dashboard.
- Use a small non-production example first, especially when testing credentials, scans, model calls, or data connections.
- Name the test clearly so other workspace users can recognize it as a first-run validation.
4. Monitor and validate the result
- Check the component UI for run status, logs, traces, scan results, job history, or project activity, depending on the component.
- Return to Shakudo if you need platform-level status, access control changes, or administrator support.
- Record any errors, missing permissions, or unexpected results before retrying with production workloads.
5. Next steps
- Review the use cases, administration, and troubleshooting pages in this knowledge base for deeper examples.
- For production usage, follow your team’s Shakudo workspace policies for credentials, data access, resource limits, and approvals.
- Previous getting-started content snapshot
- The page content below was present before this SaaS-first section was added. It is retained here as an inline snapshot so existing guidance is not lost.
- heading_1: Getting Started & Usage; paragraph: Once Langfuse is deployed and the health check passes, you can start sending traces in minutes. This page covers creating your first project, getting API keys, and instrumenting your applications.; heading_2: Step 1: Create a Project and Get API Keys; paragraph: Open the Langfuse UI (http://localhost:3000 or the cluster-internal URL), log in, and:; bulleted_list_item: Click New Project; bulleted_list_item: Give it a name (e.g. production, risk-team-app); bulleted_list_item: Go to Settings > API Keys > Create new API key; bulleted_list_item: Copy the Public Key and Secret Key — the secret is shown once; heading_2: Sending Traces via the Python SDK; code: pip install langfuse
- Set env vars or pass keys directly
- export LANGFUSE_PUBLIC_KEY=pk-...export LANGFUSE_SECRET_KEY=sk-...export LANGFUSE_HOST=http://langfuse.hyperplane-langfuse.svc.cluster.local:3000; code: from langfuse import Langfuse
- client = Langfuse()
- Create a trace for one user request
- trace = client.trace(name="user-query", user_id="user-123")
- Add a span for the LLM call
- span = trace.span(name="llm-call",input={"prompt": "Summarize this document"},model="gpt-4o",)
- ... call your LLM ...
- span.end(output={"response": "The document covers..."},usage={"input": 120, "output": 80})client.flush(); heading_2: LiteLLM Integration (Automatic Tracing)
