```
## Set up tracing
Import `configure_pipecat` and call it once before building your pipeline. Enable tracing on the `PipelineTask`:
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
from langsmith.integrations.pipecat import configure_pipecat
from pipecat.pipeline.task import PipelineParams, PipelineTask
# Install the tracer and the LangSmith span processor.
configure_pipecat()
task = PipelineTask(
pipeline,
params=PipelineParams(enable_metrics=True),
enable_tracing=True,
enable_turn_tracking=True,
conversation_id=conversation_id,
)
```
Set `enable_tracing=True`, `enable_turn_tracking=True`, and `enable_metrics=True`. Turn tracking is required for tracing, and metrics drive the latency and token data on each span.
### Use a LangGraph or LangChain agent as the LLM
If your LLM stage is an in-process [LangGraph or LangChain](/oss/python/langgraph/overview) agent, its model and tool runs should nest inside Pipecat's `llm` span rather than forming a separate trace. To achieve this:
* Pass `configure_pipecat(llm_span_kind="chain")`. This avoids nested `llm` spans that don't actually represent inference requests.
* Set `LANGSMITH_TRACING_MODE=otel` in the environment. Without it, those runs post to LangSmith directly and form a separate trace instead of nesting.
### Use your own tracer provider
`configure_pipecat()` builds a `TracerProvider`, registers the LangSmith span processor, and wires it into Pipecat. To send spans through a `TracerProvider` you already manage (for example, one that also exports to another OpenTelemetry backend), skip `configure_pipecat` and add the processor to your provider directly:
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
from langsmith.integrations.pipecat import PipecatLangSmithSpanProcessor
provider.add_span_processor(PipecatLangSmithSpanProcessor())
```
## Group a conversation into a thread
To group a conversation's runs into a LangSmith [thread](/langsmith/threads) for thread-level views and token and cost aggregation, call `set_thread_id` once per conversation before its spans are emitted:
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
from langsmith.integrations.pipecat import configure_pipecat, set_thread_id
configure_pipecat()
set_thread_id(conversation_id)
```
## Record the conversation audio
Attach the conversation audio to the trace using Pipecat's [`AudioBufferProcessor`](https://docs.pipecat.ai/server/utilities/audio/audio-recording). Place it after `transport.output()` so it captures what was actually played (after any barge-in truncation), hand it to the integration, and start it once the session is running:
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
from pipecat.processors.audio.audio_buffer_processor import AudioBufferProcessor
span_processor = configure_pipecat()
# Stereo: user on the left channel, agent on the right.
audiobuffer = AudioBufferProcessor(num_channels=2, buffer_size=32_000)
span_processor.attach_audio_buffer(audiobuffer, conversation_id=conversation_id)
pipeline = Pipeline([
transport.input(),
stt,
context_aggregator.user(),
llm,
tts,
transport.output(),
audiobuffer, # after output(): records what was heard
context_aggregator.assistant(),
])
await audiobuffer.start_recording()
```
The integration attaches the recording to the conversation root when it ends. For the underlying attachment API, see [Upload files with traces](/langsmith/upload-files-with-traces).
## Next steps
Core conventions for tracing voice agents.
Attach the conversation audio recording to your trace.
***
[Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.
[Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/langsmith/trace-with-pipecat.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).