I’m working with LangSmith to monitor my Claude AI integration. LangSmith has built-in support for tracking Claude events through OpenTelemetry, which is great. The problem I’m running into is that while it captures most telemetry data, it doesn’t seem to log the actual model responses.
I need to find a straightforward method to capture these responses and send them to LangSmith for complete monitoring. I know there are LLM proxy solutions that can intercept both requests and responses, but I’m not sure which approach would be the most simple to implement.
Has anyone dealt with this issue before? What would be the most efficient way to set this up without overcomplicating my current architecture?
Had this exact problem a few months ago with Claude monitoring. Skip the auto-instrumentation headaches and just use LangSmith’s @traceable decorators directly on your Claude API calls. I wrapped my Claude client in a simple function that grabs the response before returning it. Works perfectly and you control exactly what gets logged without adding infrastructure mess. The wrapper lets you filter or clean up data before it hits LangSmith too. I skipped proxy solutions - way too much overhead for something this simple. The decorator approach dropped right into my existing code without breaking anything.
Try LangSmith’s callback handlers if you’re using LangChain integration. I had the same problem - OpenTelemetry wasn’t capturing Claude responses properly. Skip the custom middleware and decorators. LangSmith’s callback system hooks right into the model execution lifecycle and automatically grabs input prompts and outputs without touching your existing Claude API calls. Just register the LangSmithCallbackHandler when you initialize your LLM chain and it logs responses automatically. Works way better than manual tracing since it’s built for LangSmith’s data pipeline and you don’t need to maintain wrapper code. Setup’s easy if you’re already running LangChain with Claude.
Manual decorators and custom wrappers are a pain. Every API update means you’re back to debugging your custom code.
I fixed this by setting up an automated pipeline that intercepts all AI calls without touching my app code. Works with any LLM provider, not just Claude.
I route all API calls through an automation workflow that captures requests, processes responses, and formats everything for LangSmith. No decorators to maintain, no wrapper functions breaking on updates.
The workflow handles response parsing, adds custom metadata, and does response filtering or data sanitization before sending to LangSmith. Want another monitoring service later? Just modify the workflow instead of digging through code.
I’ve run this setup for over a year across multiple projects. Zero maintenance headaches, complete monitoring coverage.
You can build this with Latenode. It handles the API orchestration and data transformation automatically: https://latenode.com
just use langfuse - don’t overcomplicate langsmith setup. I switched last month and langfuse has native claude support that captures responses automatically. no custom wrappers or middleware needed. drop in their python sdk and you’re done. way easier than dealing with custom integrations.
Been there with Claude monitoring at my company. Tried decorators and external routing - both sucked. The cleanest solution? A lightweight middleware pattern.
Build a thin wrapper around your Claude client that handles LangSmith trace context manually. Skip decorators on every function and make one central handler for all Claude interactions.
Use LangSmith’s create_run() method directly in your middleware. Start the run before calling Claude, grab the response, update the run with outputs. Way more control than auto-instrumentation, cleaner than decorators everywhere.
We handle 10k Claude calls daily this way. Middleware sits between our app and Claude’s API, so when Anthropic updates their client, our monitoring doesn’t break.
Bonus - you can add custom metrics or response validation in the same middleware without touching business logic. We track token usage and response latency alongside standard LangSmith data.
Took half a day to build, been rock solid for 8 months.