How can I retrieve the complete request and response history from LangChain's language model API interactions?

Other Questions langchain
1

I’m working with LangChain agents and need to track all API communications. When I set up an agent with a language model, it makes multiple API calls to handle user queries.

model = ChatOpenAI(temperature=0.2)

my_agent = create_agent(
    tools=[search_tool, calc_tool, web_tool],
    llm=model,
    agent_type='conversational-react-description',
    verbose=False
)

During execution, the agent sends several requests to the external service to process one user input.

I want to capture the full content of these API exchanges, not just token counts. I know there are methods to monitor token usage, but I specifically need the actual request payloads and response data.

Is there a built-in way to log or access this complete interaction history? I need both the outgoing requests and incoming responses for debugging purposes.

2

LangChain’s callback system gives you decent visibility into API calls, but you’ll need to do some setup. Custom callback handlers let you capture requests and responses while your agent runs.

I’ve used BaseCallbackHandler in production to intercept LLM calls. Build a custom handler that overrides on_llm_start and on_llm_end to log everything. The annoying part? Getting to the raw HTTP data since LangChain hides that layer.

What worked better for me was monkey-patching the HTTP client your model provider uses. With OpenAI, you can intercept requests at the httpx level before they hit the API. You get full control over logging without touching your agent code much.

Callbacks are cleaner, but HTTP interception grabs more details - headers, timing, all the stuff that saves you during debugging.

3

Been there with debugging agent workflows. Existing solutions give you fragments or need way too much setup.

I quit wrestling with LangChain’s callback system after wasting hours trying to get complete visibility. Built-in tracers miss important details, and custom handlers turn into maintenance nightmares.

What saved me was moving everything to Latenode. You get automatic logging of every API interaction without any config. Every request payload, response body, headers, timing data - it’s all there.

You can recreate your agent logic with visual workflows. Connect OpenAI nodes, add tools as HTTP requests or function calls, set up the same conversational flow. Difference is you see exactly what happens at each step.

No more guessing why an agent made weird decisions or where API calls failed. Execution logs show the complete conversation history with timestamps and full data.

Way cleaner than patching HTTP libraries or building custom monitoring. Plus you can modify agent behavior without touching code.

4

Check out LangSmith if you haven’t already - it’s built for exactly this kind of debugging. Much easier than rolling your own custom handlers, and you get the complete conversation flow without the setup pain that comes with other tools.

5

Turn on verbose logging with LangChain’s tracer - it catches way more API details than basic callbacks. Just set LANGCHAIN_TRACING_V2=true in your environment and hook up a tracer backend. For deeper digging, I wrap the model instance with a custom interceptor class that inherits from the model’s base class. Override _generate and _call methods to grab both input prompts and raw responses before processing kicks in. You can also use Python’s logging module at debug level for your model provider’s package. With OpenAI, set the openai logger to DEBUG - this shows HTTP request details including headers and payload structure. The trick is hitting the right abstraction layer. Go too high and you miss implementation details. Go too low and you’re stuck parsing raw HTTP.

6

LangChain doesn’t give you clean access to raw API interactions. You’ll end up patching HTTP libraries or wrestling with callback handlers that only show fragments.

I hit this exact issue debugging agent workflows last year. Standard logging misses context and doesn’t capture the full request-response cycle.

What worked better was moving the entire agent setup to Latenode. It has built-in logging for all API interactions, so you get complete visibility into what’s happening between your agent and the language model.

You can rebuild your LangChain agent logic using Latenode’s workflow builder. It handles OpenAI API calls, maintains full request/response logs, and gives you better control over agent execution.

Debugging becomes straightforward because every API call gets tracked automatically. No more guessing what broke in complex agent chains.

Check it out: https://latenode.com