A field guide for product managers · about 20 minutes
Engineers often mention these three tools in the same breath. They do three different jobs. We'll use one example throughout: a research assistant that takes a question, searches the web, reads the results and writes a short report.
Words with a dotted underline, like , are technical terms. Tap one for a plain-English definition.
1 · The big picture
Think of building an as running a restaurant kitchen. You need ingredients and utensils, a recipe that says what to do and when, and a camera that records how each dish was actually made.
The ingredients and utensils
Ready-made parts for talking to an , writing prompts and connecting tools such as web search.
The recipe card, with decisions
"If the sauce is too thin, reduce it again." "Chef tastes before it goes out." It sets the order of steps, the loops and the checks.
The kitchen camera and the receipts
A record of every step: what went in, what came out, how long it took and what it cost. You use it to find out why a dish went wrong.
LangChain builds the parts, LangGraph runs them in the right order, and Langfuse shows you what actually happened.
Interactive demo
Each click runs one step of the graph. Watch the active step light up, the state change, and the trace grow on the right. Then pick a failure to see how the graph retries or changes route.
2 · LangChain · build
LangChain is an framework, available for Python and JavaScript. It gives developers standard parts for common LLM tasks, so they don't have to build each one from scratch.
One standard way to call many LLM providers. Switching providers can be a one-line change instead of a rewrite.
Ours: a large model writes the report, a small, cheap one grades search results.
A is a reusable prompt with blanks to fill in, such as {question} and {notes}.
Ours: "Write a 150-word report answering {question} using only these notes: {notes}"
Wrappers that let the model ask for actions, like searching. LangChain has ready-made for hundreds of services.
Ours: web_search and fetch_page.
Ways to keep the conversation and earlier results so later steps can use them. In recent versions, this is mostly handled by LangGraph's saved state.
Ours: the question, search results and notes carried from step to step.
A links parts in a fixed line: prompt, then model, then clean up the output.
Ours: the "write the report" step is a small chain.
Document loaders, text splitters, and for searching your own documents, plus parsers that turn model output into structured data.
# Simplified. The "|" symbol means "then". model = init_chat_model("provider:large-model") # change this line to switch provider prompt = ChatPromptTemplate.from_template( "Write a 150-word report answering {question} using only these notes: {notes}") write_report = prompt | model | StrOutputParser() report = write_report.invoke({"question": q, "notes": notes})
Four lines replace a lot of hand-written code for building the request, calling the provider's and reading the reply.
LangChain speeds up building the parts. Ask whether you need the speed or whether the parts are simple enough to write directly.
3 · LangGraph · orchestrate
LangGraph is an open-source library from the same company as LangChain. You describe your agent as a : boxes for steps and arrows for what can come next. It can be used with or without LangChain.
create_agent builds exactly that.A is one step, such as search or write. Inside, it can use LangChain parts or any other code.
An is an arrow to the next step. A picks the route based on results: good results go to read, poor ones to rewrite_query.
The is a shared notebook passed between steps: the question, results, notes and draft. Every node reads it and updates it.
Arrows can point backwards to try again. A re-runs a step automatically when it errors, for example a search that times out.
A saves the state after every step. If the server crashes, the run picks up where it stopped instead of starting over.
An pauses the run so a person can approve, edit or reject. It can wait minutes or days, then resume.
# Simplified. This is the same graph you clicked through in the demo. graph = StateGraph(ResearchState) # state: question, query, results, notes, draft… graph.add_node("plan", plan) graph.add_node("search", search, retry_policy=RetryPolicy(max_attempts=3)) graph.add_node("grade", grade) graph.add_node("rewrite_query", rewrite_query) graph.add_node("human_review", human_review) # calls interrupt() to wait for a person # …read, write, no_sources graph.add_edge(START, "plan") graph.add_edge("plan", "search") graph.add_edge("search", "grade") graph.add_conditional_edges("grade", route_after_grade) # good → read · poor → rewrite_query · 2 tries → no_sources graph.add_edge("rewrite_query", "search") # the loop app = graph.compile(checkpointer=saver) # checkpoints let a paused run resume later
| Your flow needs… | LangChain alone | Add LangGraph |
|---|---|---|
| A fixed sequence (prompt → model → answer) | Enough | Not needed |
| Different routes depending on results | Possible, but gets messy | Built in |
| Loops ("try again until good enough") | Hand-written | Built in, with limits |
| Pausing for human approval | Hand-written | Built in (interrupts) |
| Surviving crashes and long waits | Hand-written | Built in (checkpoints) |
| Several agents handing work to each other | Hard | Designed for it |
In recent versions, LangChain's own "create an agent" helper runs on LangGraph underneath. Teams often start there and drop down to a custom graph when they need more control.
Check your understanding · LangGraph
The search returns junk results. In the stack described here, which part decides to rewrite the query and search again?
If your agent needs to loop, branch, retry or wait for a person, it needs a graph. LangGraph is one well-used way to build one.
4 · Langfuse · observe
Langfuse is an open-source platform for of LLM apps. It has three main jobs: tracing, prompt management and evaluation. Your team can use Langfuse's cloud version or it.
A is the full record of one run. Inside it are nested pieces called observations.
Filter traces by cost and see which step and which model spends the most. For example, a loop that searched 5 times instead of once.
The timeline bars show where time goes. is often one slow tool, or steps that could run at the same time but don't.
Open the trace for a bad report. Check what the search returned, what the model was given, and the exact step where it went wrong.
Prompts are stored and versioned in Langfuse rather than in the code. A PM or engineer can change the report prompt, label it "production" and roll it back if it's worse, without a code release. Each trace shows which prompt version produced it.
Score traces automatically (citation check, LLM-as-judge), collect user feedback, and run a saved set of test questions, called a dataset, against a new prompt or model before it ships. An turns "it seems better" into a number.
# Simplified. With LangChain/LangGraph: pass one handler. handler = CallbackHandler() app.invoke({"question": q}, config={"callbacks": [handler]}) # Without them: mark your own functions to be traced. @observe() def research(question): ...
A handler is a listener that LangChain notifies at every step, so Langfuse can record it.
Check your understanding · Langfuse
A client says Tuesday's report cited a dodgy source. What do you need to find out why, quickly?
Without tracing you're guessing about quality, cost and speed. Langfuse gives you the evidence, whichever framework you use.
5 · How they work together
"Before" is a plain script written by a good engineer. "After" splits the work between the three tools. Everything on the right can be built by hand. The real question is whether you want to build and maintain it yourself.
| Situation | Before: a plain script, done well | After: all three tools |
|---|---|---|
| Switch to another model provider | Write and keep up your own small wrapper around each provider's SDK | Change one line LangChain |
| Search returns junk | Add a grading call, an if-statement and a loop counter | Grade step and a conditional edge, drawn on the map LangGraph |
| Search tool times out | Write a retry with back-off around the call | A retry policy on the step LangGraph |
| Report needs sign-off | Save progress to a database and write your own resume logic | Interrupt and checkpoint, resume any time LangGraph |
| "Why was Tuesday's report wrong?" | Log every prompt, reply and tool call yourself, then build a way to search the logs | Open that trace and see every step Langfuse |
| "What does one report cost?" | Record token counts and keep a price table up to date | Cost per run, per step, per model Langfuse |
| Improve the report prompt | Code change and release, or build your own prompt store | New prompt version, compare with an eval, roll back in a click Langfuse |
The model calls in plan, grade and write, the prompt templates, and the web_search and fetch_page tools.
The order of steps, the poor-results loop, the retry on timeout, the human approval pause and the saved state.
Records every run as a trace, adds scores, stores the prompts and powers the cost and quality dashboards.
The "after" version isn't smarter. It saves you building and maintaining the plumbing that production needs. If you only need one or two rows of this table, plain code may still be the better choice.
6 · Decision guide
| Tool | Use it when… | Skip it when… |
|---|---|---|
| LangChain | You want to try several model providers, need ready-made integrations (search, databases, documents), or want a fast prototype. | It's one or two model calls, the team prefers the provider's own SDK, or you want the fewest dependencies possible. |
| LangGraph | Your agent loops, branches, retries, waits for human approval, runs for a long time, or involves several agents. | The flow is a straight line, or a simpler agent toolkit already covers what you need. |
| Langfuse | Anything LLM-based going to real users: you need cost per feature, debugging, prompt versions or evals. Self-hosting helps when data must stay in your own systems. | It's a throwaway prototype, or the company already uses another LLM tracing tool, such as LangSmith. |
These three tools are popular, not the only choice. Each row below can replace one of them.
| Instead of… | Option | Best when… | Trade-off |
|---|---|---|---|
| LangChain | The provider's own SDK | One provider, a simple flow, and you want the newest features on day one | You write the glue. Switching providers means rewriting calls. |
| LangChain | LlamaIndex | The product is mostly about your own documents: parsing, indexing and RAG | Overlaps with LangChain. Different building blocks to learn. |
| LangGraph | Provider agent SDKs: OpenAI Agents SDK, Claude Agent SDK, Google ADK | You want a lighter agent loop with tools, handoffs and guardrails built in | Often tuned to one provider. Less control over the exact flow. |
| LangGraph | Other agent frameworks, such as CrewAI or Pydantic AI | The team prefers their style: role-based crews, or strictly typed Python | Smaller ecosystems. Check how they handle checkpoints and approvals. |
| LangGraph | A durable workflow engine, such as Temporal | Long-running jobs where retries and resume must be rock solid, and you already run one | Not built for LLMs. You write the agent logic yourself. |
| Langfuse | LangSmith | The team is all-in on LangChain and LangGraph and wants one vendor | Commercial. Self-hosting only on enterprise plans. |
| Langfuse | Arize Phoenix, Braintrust, Helicone, W&B Weave | You want a different balance of open source, evals and set-up effort | Each has different strengths. Compare on your own traces. |
| Langfuse | Your existing monitoring tool, such as Datadog | The company already runs it and wants one place for all monitoring | Usually lighter on prompt management and evals. |
This space changes quickly. Treat these as examples, not a ranking, and check each project's current docs and pricing.
"Open source" means no licence fee, not no cost. Ask for the total: licences, hosting, the people to run it, and model usage.
| Tool | Licence | What you pay for |
|---|---|---|
| LangChain | Open source (MIT) | Engineering time, and keeping versions and dependencies up to date |
| LangGraph | Open source (MIT) | Your own servers and checkpoint database, or a paid managed service from LangChain Inc. |
| Langfuse | Open source (MIT core; a few enterprise features need a paid key) | A Langfuse Cloud plan, or the servers and people to self-host it: a database, an analytics store, a cache and file storage |
| LangSmith | Commercial | Seats and usage-based plans |
| Model provider | Commercial | Tokens. Usually the biggest bill, whichever framework you pick. |
Check your understanding · Decision guide
A new feature is one prompt and one model call, going to real users next month. What does it need from this stack?
Choose the smallest stack that handles your flow's real needs, and plan tracing from the first day.
Keep this
Learn from others