Viewing trace details and latency in LangChain - Step-by-Step Execution

Concept Flow - Viewing trace details and latency

Start LangChain Call

↓

Initialize Trace

↓

Execute Chain Step

↓

Record Step Details & Latency

↓

Check More Steps?

Yes→Execute Chain Step

No↓

Compile Trace Summary

↓

Return Trace Data & Latency Info

↓

End

Shows how LangChain starts a call, records each step's details and latency, then compiles and returns the full trace.

Execution Sample

LangChain

from langchain.chains import LLMChain
from langchain.callbacks import get_openai_callback

chain = LLMChain(...)  # Initialize your chain here

with get_openai_callback() as cb:
    result = chain.run("Hello")
    print(cb)

Runs a LangChain chain with a callback that tracks and prints trace details and latency.

Execution Table

Step	Action	Trace Detail Recorded	Latency (ms)	Notes
1	Start chain run	Trace initialized	0	Begin tracking
2	Call LLM with input 'Hello'	Input recorded	120	LLM processing time
3	Receive LLM output	Output recorded	5	Output received
4	Post-process output	Post-processing step recorded	10	Formatting output
5	End chain run	Total latency calculated	135	Sum of all steps
6	Print callback info	Trace summary printed	0	Shows tokens used and latency

💡 Chain run completes after all steps, total latency 135 ms recorded

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
trace_details	{}	{"input": "Hello"}	{"output": "Hi!"}	{"post_process": "Formatted"}	{"input": "Hello", "output": "Hi!", "post_process": "Formatted"}
latency_ms	0	120	125	135	135

Key Moments - 2 Insights

Why does latency increase after each step in the execution_table?

Each step adds its processing time to the total latency, as shown in rows 2 to 5 where times accumulate.

What does the trace_details variable hold after step 4?

It holds all recorded data from input, output, and post-processing steps, as seen in variable_tracker after step 4.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what trace detail is recorded?

A Input to the LLM

B Post-processing details

C Output from the LLM

D Total latency

💡 Hint

Check the 'Trace Detail Recorded' column at step 3 in execution_table

At which step does the total latency get calculated?

A Step 3

B Step 5

C Step 2

D Step 6

💡 Hint

Look for 'Total latency calculated' in the 'Trace Detail Recorded' column

If the LLM call latency increased to 200 ms, how would latency_ms change after step 2?

A It would increase to 200 ms

B It would decrease

C It would stay 120 ms

D It would reset to 0

💡 Hint

Refer to latency_ms values in variable_tracker after step 2

Concept Snapshot

LangChain tracing captures each step's input, output, and processing time.
Use callbacks like get_openai_callback() to record trace details.
Latency accumulates as each step runs.
Trace data helps debug and optimize chain performance.
Print callback info to see tokens used and total latency.

Full Transcript

This visual trace shows how LangChain records detailed trace information and latency during a chain run. The process starts by initializing the trace, then executing each step such as calling the language model, receiving output, and post-processing. Each step's details and latency are recorded and accumulated. After all steps complete, the total latency is calculated and the trace summary is printed. Variables like trace_details hold the input, output, and processing info, while latency_ms tracks the time spent. This helps learners see how LangChain tracks performance and data flow step-by-step.

Practice

1. What is the main purpose of viewing trace details in a LangChain application?

easy

A. To change the output format of the application

B. To understand the internal steps and flow of the application

C. To increase the speed of the application automatically

D. To add new features without coding

Solution

1. Step 1: Understand what trace details represent

   Trace details show the internal steps and flow of the LangChain app during execution.

2. Step 2: Identify the purpose of viewing these details

   Viewing trace details helps developers see what happens inside, making debugging and optimization easier.

3. Final Answer:

   To understand the internal steps and flow of the application -> Option B

4. Quick Check:

   Trace details = internal flow insight [OK]

Hint: Trace details show what happens inside your app [OK]

Common Mistakes:

• Thinking trace changes output format
• Believing trace speeds up app automatically
• Confusing trace with adding features

2. Which of the following is the correct way to enable LangChainTracer to view trace details?

easy

A. from langchain.callbacks import tracer\ntracer = tracer()

B. import LangChainTracer from langchain.callbacks\ntracer = LangChainTracer()

C. from langchain import LangChainTracer\ntracer = LangChainTracer()

D. from langchain.callbacks import LangChainTracer\ntracer = LangChainTracer()

Solution

1. Step 1: Recall the correct import path for LangChainTracer

   LangChainTracer is imported from langchain.callbacks module.

2. Step 2: Check the correct instantiation syntax

   The correct way is to import LangChainTracer and then create an instance with LangChainTracer().

3. Final Answer:

   from langchain.callbacks import LangChainTracer\ntracer = LangChainTracer() -> Option D

4. Quick Check:

   Correct import and instantiation = from langchain.callbacks import LangChainTracer\ntracer = LangChainTracer() [OK]

Hint: Import from langchain.callbacks and instantiate with () [OK]

Common Mistakes:

• Wrong import path
• Using incorrect import syntax
• Calling a non-existent function

3. Given this code snippet using LangChainTracer, what will be the output regarding latency?

from langchain.callbacks import LangChainTracer
tracer = LangChainTracer()

with tracer:
    result = chain.run("Hello")

print(tracer.get_trace())

medium

A. A detailed trace including each step's latency in milliseconds

B. Only the final output without any timing information

C. An error because get_trace() is not a valid method

D. An empty trace because tracer was not started

Solution

1. Step 1: Understand what LangChainTracer does inside a with block

   LangChainTracer collects detailed trace info including latency for each step during the with block execution.

2. Step 2: Check the output of get_trace()

   get_trace() returns the collected trace data, which includes latency details for each step.

3. Final Answer:

   A detailed trace including each step's latency in milliseconds -> Option A

4. Quick Check:

   Tracer with block + get_trace() = detailed latency trace [OK]

Hint: Tracer inside with block captures latency info [OK]

Common Mistakes:

• Assuming get_trace() does not exist
• Expecting output without timing info
• Forgetting to use with block for tracing

4. You added LangChainTracer but see no trace output after running your chain. What is the most likely cause?

medium

A. The chain.run() method does not support tracing

B. You did not import LangChainTracer correctly

C. You forgot to wrap the chain execution inside the tracer's with block

D. You need to call tracer.start() before running the chain

Solution

1. Step 1: Check how LangChainTracer collects trace data

   LangChainTracer collects trace only when chain execution is inside its with block context.

2. Step 2: Identify the missing step causing no trace output

   If chain.run() is outside the with block, no trace is recorded, so output is empty.

3. Final Answer:

   You forgot to wrap the chain execution inside the tracer's with block -> Option C

4. Quick Check:

   Tracing requires with block wrapping chain run [OK]

Hint: Always run chain inside tracer's with block [OK]

Common Mistakes:

• Assuming import error causes no trace
• Thinking chain.run() disables tracing
• Trying to call non-existent start() method

5. You want to find the slowest step in your LangChain app using LangChainTracer. Which approach correctly identifies it?

hard

A. Extract latency from each trace step and find the maximum value

B. Check the total runtime of the app without step details

C. Use print statements inside the chain to guess slow parts

D. Restart the app multiple times to see when it feels slow

Solution

1. Step 1: Understand what latency data LangChainTracer provides

   LangChainTracer records latency for each individual step in the trace details.

2. Step 2: Identify how to find the slowest step

   By extracting latency values from each step and comparing them, you can find the maximum latency which indicates the slowest step.

3. Final Answer:

   Extract latency from each trace step and find the maximum value -> Option A

4. Quick Check:

   Find max latency in trace steps = slowest step [OK]

Hint: Find max latency value in trace steps to spot slowest [OK]

Common Mistakes:

• Ignoring step-level latency and checking only total time
• Using print statements instead of trace data
• Guessing speed without data