```
## Raw connection
Use this when you open the WebSocket yourself with `client.realtime.connect()` and drive the event loop.
### Set up tracing
`wrap_realtime` returns a transparent proxy of your connection. Your existing `async for event in connection` loop, `session.update`, and tool handling stay the same:
```python theme={null}
from langsmith.integrations.openai_realtime import wrap_realtime
from openai import AsyncOpenAI
client = AsyncOpenAI()
async with client.realtime.connect(model="gpt-realtime") as raw, wrap_realtime(
raw,
thread_id=thread_id,
project_name="openai-realtime-voice",
) as connection:
await connection.session.update(session={...}) # your existing config
async for event in connection:
... # your existing handling: play audio, run tools, update UI
```
A stable `thread_id` you generate per conversation (for example, a UUID) groups the trace into a LangSmith [thread](/langsmith/threads). Any [`@traceable`](/langsmith/annotate-code) tools you run while handling an event nest under that event automatically.
Enable `input_audio_transcription` (and the agent transcript) in your `session.update`, or the transcription events that make the trace readable never arrive.
### Record the conversation audio
Feed the proxy your microphone and playback audio, and it attaches a single stereo recording (user left, agent right) to the trace. Pass `is_agent_speaking` so barge-ins are flagged:
```python theme={null}
async with client.realtime.connect(model="gpt-realtime") as raw, wrap_realtime(
raw,
thread_id=thread_id,
is_agent_speaking=lambda: speaker.buffered_bytes() > 0,
) as connection:
async for event in connection:
if event.type == "input_audio_buffer.append":
connection.record_user_audio(mic_chunk) # user mic PCM16
elif event.type == "response.output_audio.delta":
connection.record_agent_audio(played_chunk) # agent PCM16 as played
```
## OpenAI Agents SDK
Use this when you build the agent with the [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/realtime/guide/) (`RealtimeAgent` / `RealtimeRunner`), which owns the turn and tool-call loop.
The Agents SDK's built-in realtime tracing uploads to OpenAI's own dashboard. Call `agents.set_tracing_disabled(True)` to avoid a second, separate upload path.
### Set up tracing
`wrap_realtime_session` wraps the `RealtimeSession` and enters it for you. Iterate it as you would the original; the SDK runs tools and manages turns:
```python theme={null}
from agents import set_tracing_disabled
from agents.realtime import RealtimeAgent, RealtimeRunner
from langsmith.integrations.openai_realtime import wrap_realtime_session
set_tracing_disabled(True)
runner = RealtimeRunner(
starting_agent=RealtimeAgent(name="assistant", instructions="...", tools=[...]),
)
session = await runner.run()
async with wrap_realtime_session(
session,
thread_id=thread_id,
project_name="openai-realtime-voice",
) as conn:
async for event in conn:
... # your handling: play audio, update UI
```
The conversation transcript is reconstructed from the session's `history` snapshots, so messages appear even though the SDK streams them as partials.
### Record the conversation audio
Feed the proxy your microphone and playback audio:
```python theme={null}
async for event in conn:
if event.type == "audio":
conn.record_agent_audio(event.audio.data) # agent PCM16 as played
# feed user mic PCM16 as you send it to the session:
# conn.record_user_audio(mic_chunk)
```
## 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-openai-realtime.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).