+ P Evaluate for LangChain agents
Capture every LangChain run as it actually executes — via LangChain's own callback system, not a network proxy — with the full chain → tool → retriever call tree reconstructed from real run IDs.
Prefactor evaluates your LangChain agents — score outcome quality against the captured spans, track drift by comparing custom spans across versions and environments, and classify every run's risk on two axes: data sensitivity and action consequence.
How to add evaluate to LangChain
Install the package
Add prefactor-langchain to your project.
Create the middleware
Build it from your config — API URL, token, and agent.
Spans flow to Prefactor
LLM calls, tool invocations, and agent spans arrive as trace data.
# pip install prefactor-langchain
import os
from prefactor_langchain import PrefactorMiddleware
middleware = PrefactorMiddleware.from_config(
api_url="https://app.prefactorai.com",
api_token=os.environ["PREFACTOR_API_TOKEN"], # never hardcode tokens
agent_id="my-agent",
agent_name="My Agent",
)How the LangChain integration actually works
- Attaches via the prefactor-langchain middleware, which registers as a LangChain BaseCallbackHandler — no gateway in your request path, no change to how your chains run.
- LangChain fires every callback with a run_id and parent_run_id; Prefactor uses that parent/child relationship to reconstruct the full call tree — a chain's sub-chains, tool calls, and retriever lookups nested under the run that triggered them, not a flat list of events.
- Capture and sampling are controlled by PREFACTOR_CAPTURE_INPUTS / _OUTPUTS / PREFACTOR_SAMPLE_RATE.
- LangChain runs synchronous callback handlers inline and swallows any exception a handler raises unless that handler sets raise_error — the middleware sets it, so a policy violation raised from on_tool_start genuinely blocks the tool call before it executes, not just logs it afterward.
What Prefactor captures for LangChain agents
Outcome quality
Score agent outputs against your own criteria, task by task, using the continuous run history as the record to measure against.
Drift detection
Compare custom spans for the same operation across versions and environments — a model update or prompt change shows up as a difference between spans, before it shows up as a quality drop.
Risk classification
Every run scored on data sensitivity and action consequence, weighted into a Low / Medium / High / Critical classification.
Data tagging
Tag PII and other sensitive fields once in the schema; every run carrying that tag becomes searchable — the record enforcement acts on.
Trace anything — not just LLM calls
The SDK captures LLM, tool, and agent spans automatically. With withSpan you wrap any operation in your own span type — an API call, a database query, a quality check, a business action — each with its own payload and schema. It all flows into the same Observe, Evaluate, and cost views.
import { withSpan } from "@prefactor/core";
// Wrap ANY operation in a span you define — an API call, a quality
// check, a business action — with its own spanType, inputs and schema
await withSpan(
{
name: "research competitor",
spanType: "research_competitor",
inputs: { competitor },
},
async () => {
const results = await search(competitor); // your tool / API calls
return summarize(results); // captured as one span
},
);Nest spans to capture business-level actions, and start with permissive schemas you tighten over time. Instrumentation strategy →
An example run, span by span
Illustrative — a single LangChain run as nested spans.
Illustrative example.
Manual logging vs DIY vs Prefactor
| Capability | Manual | DIY OpenTelemetry | Prefactor |
|---|---|---|---|
| LLM / tool / agent spans | Hand-rolled | ✓ build it | ✓ via the SDK |
| Token usage captured per call | — | Build it | ✓ |
| Configurable capture & sampling | — | Partial | ✓ |
| Hosted Admin UI (agents, instances) | — | — | ✓ |
| Risk profiles & audit trail | — | — | ✓ |
LangChain evaluate — FAQ
Does evaluation reuse the same LangChain integration?+
Yes — evaluation runs on the spans the SDK already records for LangChain, so there is one integration, not a separate one for evaluation.
What is quality drift and how is it detected for LangChain agents?+
Drift is a change in behaviour over time — after a model update, a prompt change, or a data shift. Because a custom span records the same LangChain operation every time it runs, this week's spans can be compared directly against last week's, or against a different version or environment.
How is risk scored for LangChain runs?+
On two axes — data sensitivity (what kind of data the run touched) and action consequence (what the agent did with it) — combined via configurable weights into a Low/Medium/High/Critical classification per run.
Can I tag and find PII across LangChain runs?+
Yes — tag the fields that matter once in your agent's data schema, and every run carrying that tag becomes searchable across your whole LangChain deployment, not just the run it was tagged in.
How do I add Prefactor to a LangChain app?+
Install prefactor-langchain, create the middleware with PrefactorMiddleware.from_config(...) using your API URL, token, and agent, and add it to your LangChain agent — it registers as a standard LangChain callback handler.
What does Prefactor capture from LangChain?+
Prefactor hooks LangChain's own callback events — on_chain_start/end, on_tool_start/end, on_retriever_start/end, on_llm_start/on_chat_model_start/on_llm_end, and agent actions — and uses each event's run_id and parent_run_id to reconstruct the full call tree as structured, timestamped spans, so every LangChain run is captured as trace data you can reconstruct, search and export end to end.
Does Prefactor add latency or change how LangChain runs?+
No. Observability capture is designed to stay off your agent's critical path, so it doesn't alter your LangChain logic or your users' responses. The only part that acts inline is the optional runtime guardrails you enable per agent — by design, so a high-risk or low-confidence action can be held for human approval before it executes.
Can I evaluate agents built with LangChain and catch regressions?+
Yes. Once runs are captured, eval suites score quality and groundedness on real traffic, drift detection flags behaviour changes after deployment, and versioned eval history catches regressions before they ship — the observe → evaluate → improve loop applied to your LangChain agents.
Keep going
Evaluate for other frameworks
CrewAI →LangGraph →OpenAI Agents SDK →Claude Agent SDK →Microsoft AutoGen →LlamaIndex →See it on your LangChain agents
Book a 15-minute setup and our team gets you evaluate in production.