Understanding AI Observability¶
Here we’ll explore the basics of AI Observability, why it’s needed, what you can achieve using it, and other basic concepts.
The "Black Box" Problem¶
In various LLM-applications (or AI-applications) - it’s very hard to understand what’s actually happening. Every time you see a little AI chat-box and you type in your answer, behind the scenes a LOT of things can happen:
- Query Optimization: Your question might be reformulated, or multiple alternatives are generated for the AI.
- System Prompting: The AI receives strict instructions on how to behave and format its response.
- Context Retrieval: Relevant context is fetched from your Drupal database or external sources.
- Answer Generation: The AI processes the context and formulates the initial answer.
- Refinement: A secondary AI model might step in to adjust the tone, humanize the text, or proofread the output.
- Next-Step Prediction: Finally, another AI anticipates your next moves and generates 3 clickable "chips" or suggested actions.
All of these steps happen inside a "black box" in mere seconds. The user only sees the final Input → Output, leaving you entirely blind to what happened in the middle.
This - is where Observability and Tracing comes in - meet Langfuse. Langfuse allows you to “x-ray” your AI application, understand what’s happening, where, how much time each step takes, how much money does each step cost you, and much more. It’s a crucial part in running modern AI applications.
Langfuse can also handle much more complex "agentic" interactions. If your AI Agent calls multiple external tools or forwards sub-tasks to other agents, the trace will map out the entire timeline:
Using this knowledge - developers can optimize certain steps, to make the applications faster, or cheaper, or more efficient (potentially skipping some unnecessary steps).
We will introduce more User Guides in the following months - some of those will include not only tracing, but also advanced features such as: Metrics, Prompt Management, Evaluations, Annotations and using LLM-as-a-Judge to maintain or improve the quality of your AI applications.
Key Concepts Explained¶
- Trace: Think of a Trace as the entire lifecycle of a single user action. If a user asks the AI search block a question and gets an answer, that entire interaction from start to finish is one Trace.
- Span: A Span is a specific, measured step inside a Trace. For example, retrieving context documents from the Drupal database is one Span, and formatting those documents into a string is another Span.
- Generation (LLM Call): This is a specific type of Span where the actual request is sent to the AI model (like OpenAI or Anthropic). This tracks the exact prompt sent and the raw response received.
- Token Usage & Cost: Observability isn't just for debugging logic; it tracks how many tokens were sent (input) and generated (output) for every single call, allowing you to monitor and control API costs.
Dropsolid Video¶
Here’s a good visual example of how you can leverage Langfuse to improve your Drupal application:
https://www.youtube.com/watch?v=EU3XTuRKZC8
Platform Availability¶
- Enterprise Tier: As per our AI Tiers page - only Enterprise Tiers have Langfuse included as a part of the offering. If you’re interested in this, please request a demo and we’ll get in touch.
- Demo Access: Note that non-Enterprise clients who want to explore these debugging capabilities can open a ticket in the technical support portal to request a temporary Demo tier setup.