Purpose
This guide explains how to inspect the trace of a request made to Giotto, whether the request was sent through the Chat interface or through the Python client.
By the end of this guide, you will understand:
- how a chat or API request flows through the system
- how Giotto may call tools during execution
- how to open Jaeger and find the request trace
- how to read the timeline and inspect more detailed information
Overview
When a user sends a request to Giotto, the system may do much more than simply generate a direct answer.
For example, a request may involve:
- receiving the user prompt
- orchestrating the model call
- invoking one or more tools
- going online to fetch information
- collecting tool results
- generating the final answer
All of these steps can be traced through Jaeger.
This gives users and operators visibility into:
- what happened during the request
- which services were involved
- how long each step took
- where the time was spent
- what happened before the final answer was returned
In simple terms, Jaeger lets you inspect the full execution path of a chat or API call.
When to use tracing
Tracing is useful whenever you want to understand what happened during a request.
Typical situations include:
- verifying how a request was processed
- understanding whether tools were used
- checking how long each step took
- diagnosing why a request was slow
- understanding how the final answer was produced
Tracing is especially helpful for agentic workflows, where the model may call tools or perform multiple steps before answering.
Example scenario
A typical flow looks like this:
- a user sends a request in the Chat interface or through the Python client
- the request reaches Giotto
- the deployed model (for example
giotto-model) starts processing it - if needed, the model calls tools
- the tools may fetch external information or perform actions
- the model receives the tool results
- the system produces the final answer
All of these operations can appear in Jaeger as part of the same trace.
Step 1 — Start from a chat or API request
Begin by sending a request to Giotto.
This can happen in one of two main ways:
Option 1 — Through the Chat interface
A user opens the Chat interface and sends a message.
Option 2 — Through the Python client
A developer or application sends a request through the Giotto Python client.
For example, the Python client may send a request like:
response = client.responses.create(
model="giotto-model",
input="please find the latest news about iran war
and send an email to m.bonotto@giotto.ai with a summary.",
)In either case, the system processes the request in the same general way: a trace is produced and can later be inspected in Jaeger.
Step 2 — Let the model process the request
Once the request is received, the model starts processing it.
If the request is simple, the model may generate a direct response.
If the request requires external information or actions, the model may instead:
- decide to call a tool
- go online and fetch information
- use tool outputs to build the final answer
For example, the model may:
- search for the latest information
- retrieve a web page
- process the results
- then produce the final answer
These steps are what make the workflow agentic.
Step 3 — Wait for the final answer
After the tool calls and reasoning steps complete, Giotto returns the final response to the user.
From the user perspective, this may simply appear as the final answer in:
- the chat window
- the Python client response object
But internally, the request may have gone through several stages, and Jaeger captures that timeline. Here is an example of the final answer looks like with another user question.
Step 4 — Open Jaeger
To inspect the trace, open the Jaeger interface from the platform.
Jaeger is the tracing system used by Giotto to record the execution of requests across the platform.
Once in Jaeger, you can search for recent traces and open the one corresponding to your request.
Step 5 — Find the request trace
In Jaeger, locate the trace corresponding to the request you just made.
Depending on your setup, you may use:
- time range
- service name
- operation name
- recent traces
- request-specific metadata
Once you find the correct entry, open the trace.
What you are looking for
You want the trace that corresponds to:
- the specific chat request you sent
- or the specific Python-client request you executed
Step 6 — Inspect the timeline
Once the trace is open, Jaeger shows the timeline of the request (an example is shown in the picture above).
This timeline helps you understand:
- the order of the operations
- which components were involved
- the duration of each step
- the parent/child relationships between operations
For example, you may see:
- the initial request arriving
- the model invocation
- one or more tool calls
- return of tool results
- final answer completion
This is often the most useful high-level view of the trace.
Why the timeline matters
The timeline gives a structured view of the whole request.
Instead of only knowing that “the model answered,” you can see:
- what happened before the answer
- whether tools were used
- how much time each phase consumed
Step 7 — Inspect detailed trace information
Besides the timeline, Jaeger also lets you inspect more detailed information for each span or step.
Depending on the trace and the instrumented services, you may be able to inspect:
- span names
- timing information
- service names
- parent-child relationships
- tags or metadata
- logs or events attached to a span
This deeper level is useful when you want to understand the precise behavior of the system.
What tracing helps you understand
Tracing helps answer practical questions such as:
Did the model use tools?
If the request required tools, the trace can show the corresponding spans.
Did the model go online?
If the workflow involved online retrieval or external access, that part of the execution may appear in the trace.
Why was the request slow?
The timeline makes it easier to see whether time was spent:
- in the model
- in a tool
- in an external request
- in multiple chained operations
How was the final answer produced?
Tracing gives a structured picture of the journey from user request to final answer.
Example interpretation
Suppose a user asks Giotto to retrieve recent information and summarize it.
The trace might show a sequence such as:
- incoming user request
- orchestration or model processing
- tool invocation for retrieval
- retrieval result
- model synthesis of the answer
- final response returned
This gives a much clearer picture of system behavior than the final answer alone.
What you have accomplished
At this point, you have learned how to:
- start from a chat or API request
- understand that the request may trigger tool use
- open Jaeger
- locate the relevant trace
- inspect the timeline
- inspect the detailed trace information
This is one of the most useful ways to understand how Giotto is processing a request internally.
Troubleshooting tips
I cannot find the trace
Check:
- that the request was actually sent
- that you are searching in the correct time range
- that you are looking at the right service or environment
The trace is hard to read
Start from the timeline first. Then expand individual spans only after you identify the main steps.
I only see a simple trace
That may be normal if the request was simple and did not require any tool use.
I expect tool usage but do not see it
Make sure the deployed system actually had access to the relevant tools and that the model chose to use them.
Best practices
Start from a concrete request
Tracing is easiest to understand when you begin with a request you just made yourself.
Use the timeline first
The timeline is the best high-level entry point into a trace.
Use details only when needed
Once the main sequence is clear, use span details to go deeper.
Compare final answer and trace
Looking at both together helps connect the user-visible result to the internal execution.
Comments
0 comments
Article is closed for comments.