LangChain Explained: The Framework Behind Production GenAI Applications

LangChain is an open-source framework for building applications on top of large language models. It gives you a standard interface to models, tools, retrieval and memory, so you can swap providers without rewriting your application, plus a configurable agent harness called create_agent that runs a model in a tool-calling loop until a task is done. It is used most often for RAG systems, tool-using agents, document processing pipelines and chatbots that need to reach real data. As of August 2026 the current version is LangChain 1.3.x, which requires Python 3.10 or higher and deprecates most patterns taught in pre-2026 tutorials.

That last sentence is the reason this article exists. LangChain is the most widely used and most badly documented framework in the GenAI stack, because the open web is full of tutorials teaching APIs that no longer exist.

Key Takeaways

• LangChain is a standard interface plus an agent harness, not a magic layer that makes LLMs smarter.
• Current version is 1.3.x and requires Python 3.10+. Pre-v1 tutorials teach deprecated APIs.
• create_agent is the one agent abstraction now. Everything else you read about is legacy.
• Middleware is how you customise agent behaviour in v1: retries, summarisation, PII redaction, human approval.
• The framework’s biggest risk is using it when a direct API call would do.

What LangChain Actually Is

Strip away the marketing and LangChain does three things.

• It standardises model access. You write model=”openai:gpt-5.5″ or model=”anthropic:claude-sonnet-4-6″ and the rest of your code does not change. This sounds minor until you have to switch providers under cost pressure or an outage.
• It supplies the components LLM apps repeatedly need. Tools, retrievers, document loaders, text splitters, vector store integrations, output parsers, message types. None of these are conceptually difficult. All of them are tedious to write and maintain across providers.
• It provides an agent harness. This is the part that matters most now. LangChain’s own framing is “Agent = Model + Harness”, where the harness is everything around the model loop: the prompt, the tools, and the middleware that shapes behaviour.
• What LangChain is not: a model, a hosting platform, or something that improves output quality on its own. A badly specified prompt inside LangChain produces the same bad output it would produce anywhere else.

The three-layer picture

LangChain now ships as three layers, and knowing which one you are in prevents most confusion:

Layer	What it is	Reach for it when
Deep Agents	Batteries-included harness with planning, virtual filesystem, subagents and memory pre-assembled	You want a capable agent fast and the defaults suit you
LangChain (create_agent)	Configurable harness you assemble yourself	You want control over the loop without writing graph code
LangGraph	Low-level orchestration runtime with explicit state graphs	Your flow needs custom topology, durability or human checkpoints

The relationship in one line: create_agent compiles down to a LangGraph graph, and Deep Agents is built on create_agent. You are always using LangGraph underneath. For the full argument about when to drop down a layer, the  LangChain vs LangGraph comparison covers the decision in depth, and this article stays at the LangChain layer.

What Is LangChain Used For?

The honest answer to “what is langchain used for” is narrower than the marketing suggests, and the narrowness is useful.

Retrieval-augmented generation. The dominant use case by a wide margin. You have documents the model was never trained on, and you need answers grounded in them. LangChain supplies loaders, splitters, embeddings interfaces and vector store integrations, which is most of a RAG pipeline’s plumbing. This  guide to RAG covers the retrieval architecture itself.

Tool-using agents. The model needs to check inventory, query a database, call an internal API, or search the web. LangChain turns Python functions into tools the model can call and runs the loop that decides when to call them.

Document processing pipelines. Extracting structured data from unstructured input at volume: invoices, contracts, resumes, support tickets. This is where structured output and validation matter more than conversational ability.

Assistants over live systems. Internal support bots, sales assistants, ops copilots. The distinguishing requirement is reaching real data rather than answering from training.

Where LangChain is the wrong choice, stated plainly because most articles will not:

• You are making one or two LLM calls behind a function. Use the provider SDK. Adding a framework here is pure overhead and experienced reviewers notice.
• Your flow is a fixed sequence with no model-driven decisions. That is a script, not an agent.
• Retrieval quality is the entire product and you need deep control over indexing strategy. Specialised retrieval libraries fit better.
• You need something with a tiny dependency footprint. LangChain is not small.

How LangChain Agents Work

This section covers the langchain agents keyword and it is the part most worth your attention, because the agent abstraction is where v1 changed most.

An agent is a model calling tools in a loop until the task is complete. That is the whole concept. The model receives a task and a list of available tools, decides whether to call one, receives the result, and decides again. The loop ends when the model stops calling tools and returns an answer.

The minimal agent

From the current official documentation:

from langchain.agents import create_agent

def get_weather(city: str) -> str:

    """Get weather for a given city."""

    return f"It's always sunny in {city}!"

agent = create_agent(

    model="openai:gpt-5.5",

    tools=[get_weather],

    system_prompt="You are a helpful assistant",

)

result = agent.invoke(

    {"messages": [{"role": "user", "content": "What's the weather in San Francisco?"}]}

)

print(result["messages"][-1].content_blocks)

Three things deserve attention here.

The tool is a plain Python function. The docstring is not decoration: it becomes the tool description the model reads when deciding whether to call it. Vague docstrings produce agents that call the wrong tool, and this is one of the most common causes of bad agent behaviour.

The model is a string identifier. Swap “openai:gpt-5.5” for “anthropic:claude-sonnet-4-6” and nothing else changes.

Underneath those three arguments is a compiled graph with a model node, a tool node, and a conditional edge that loops until the model stops requesting tools.

Tools with the decorator

For anything beyond a trivial function, use the @tool decorator:

from langchain.agents import create_agent

from langchain.tools import tool

@tool

def search(query: str) -> str:

    """Search for information."""

    return f"Results for: {query}"

agent = create_agent(model="anthropic:claude-sonnet-4-6", tools=[search]

Middleware: the part that makes agents production-ready

Middleware is the defining feature of v1 agents and the thing most tutorials have not caught up with. It gives you hooks around each step of the loop, so you can change behaviour without rewriting the agent.

from langchain.agents import create_agent

from langchain.agents.middleware import SummarizationMiddleware, HumanInTheLoopMiddleware

agent = create_agent(

    model="gpt-5.5",

    tools=[...],

    middleware=[

        SummarizationMiddleware(...),

        HumanInTheLoopMiddleware(...)

    ],

What official middleware covers, per the docs: logging and analytics, prompt and tool-selection transformation, retries, model fallbacks, early termination, rate limiting, guardrails, and PII detection.

That list is essentially a checklist of the things that separate a demo from a system. An agent with no retry logic, no call limit and no PII handling is a prototype regardless of how well it performs.

One important detail: middleware is not a separate runtime. The hooks run inside the compiled LangGraph that create_agent returns, which means you can drop an entire agent, middleware included, into a larger StateGraph as a single node and every hook still runs.

Deep Agents, the newest layer

If you want the capable-agent defaults without assembling them, deepagents is a separate package built on create_agent:

from deepagents import create_deep_agent

agent = create_deep_agent(

    model="anthropic:claude-sonnet-4-6",

    tools=[get_weather],

    system_prompt="You are a helpful assistant",

)

It ships with a virtual filesystem for context management, subagent spawning with isolated context windows, long-term memory, context summarisation and offloading, and human-in-the-loop approval. The tradeoff is the usual one: less configuration, less control.

A LangChain Tutorial: Your First Working Agent

This covers the langchain tutorial intent. It is deliberately short, because the fastest way to understand LangChain is to build the smallest useful thing rather than read about it.

Prerequisites: Python 3.10 or higher. Version 1.x dropped 3.9 support. Comfort with Python functions and virtual environments is assumed.

• Step 1: Install. The provider comes as an extra.
• pip install -qU langchain “langchain[openai]”

• Step 2: Set your API key as an environment variable. Never hardcode it, and never commit it.

• Step 3: Write a tool that does something real. The weather example in the docs returns a hardcoded string, which is fine for checking your install and useless for learning. Replace it with a function that hits an actual API or reads an actual file. The interesting behaviour only appears when the tool can fail or return something unexpected.

• Step 4: Build the agent using the create_agent pattern above.

• Step 5: Break it deliberately. This is the step tutorials skip and it teaches more than the other four combined. Ask the agent something your tool cannot answer. Ask it something ambiguous enough that it should call two tools. Make the tool raise an exception. Watch what the loop does. You are learning the failure modes now, cheaply, instead of in production.

• Step 6: Add one piece of middleware. A call limit is the right first choice, because a runaway agent loop is the most expensive mistake in this space.

What to build next, in order: a RAG pipeline over your own documents, then an agent with three tools where choosing correctly between them matters, then the same agent with structured output validated against a schema. Those three cover most of what production work asks of you. The  GenAI project ideas has fuller specifications if you want something scoped.

Why Most LangChain Tutorials Are Wrong

Worth its own section, because this is the single biggest obstacle to learning LangChain and almost nobody says it directly.

LangChain 1.0 shipped in October 2025 and consolidated years of API sprawl. The older chain and agent constructs moved to a langchain-classic package, leaving the core namespace focused on agents, models, messages and tools. The current release is 1.3.15, published 11 August 2026.

The practical filter. If a tutorial contains any of these, it predates the reset:

Deprecated pattern	What replaced it
initialize_agent(…)	create_agent(…)
AgentExecutor	create_agent, which returns a runnable graph
LLMChain	Direct model invocation, or an agent
ConversationBufferMemory	Runtime state and checkpointers, or summarisation middleware
Bare from langchain.chains import …	Mostly moved to langchain-classic

Check the publication date on anything you read. Before November 2025, assume it needs verification against the official migration guide. This applies to video content too, and video is worse, because the date is less visible and the code is harder to search.

This matters for interviews as much as for building. A candidate who writes AgentExecutor on a whiteboard in 2026 has signalled that their knowledge is second-hand and stale.

What LangChain Does Not Solve

A framework that is oversold gets a backlash it does not deserve. Here is the honest boundary.

• It does not make a weak model strong. Retrieval and tools extend what a model can reach. Neither improves its reasoning.
• It does not give you evaluation. You still need a test set and a measurement harness. LangSmith provides tracing and evaluation tooling, but the judgment about what “correct” means for your task is yours. Teams that skip this ship agents they cannot tell are degrading.
• It does not control cost. An agent loop can call a model many times per user request. Without call limits, cost per request is unbounded by default. This is the most common source of bill shock in agent projects and middleware is where you fix it.
• It does not remove the need to understand the underlying model. Context windows, tokenisation, temperature and tool-calling reliability all still apply. Understanding how large language models work is what lets you debug an agent that is behaving strangely, because the answer is usually in the model’s behaviour rather than the framework’s.
• It does not survive being used as a substitute for design. The failure mode is reaching for an agent when a deterministic function would be correct, faster, cheaper and testable.

Where LangChain Fits in Your Skill Stack

For an engineer with a few years of experience deciding how much to invest here, the useful framing is that LangChain is a week, and the things around it are the career.

Learning the framework itself is genuinely fast. create_agent, tools, middleware, retrieval, structured output. If you build the three projects listed earlier you will be productive within a couple of weeks.

What takes longer and matters more: knowing when an agent is the wrong architecture, being able to evaluate whether your system works, understanding cost and latency behaviour under load, and designing the retrieval layer well. Those transfer to every framework, including the ones that will replace this one.

The sequencing that works is fundamentals first, framework second. You want to understand what agents are conceptually before learning one library’s way of expressing them, because the concepts persist while the APIs churn. LangChain’s own v1 reset is the proof: everyone who learned the concepts adapted in an afternoon, and everyone who learned the API had to relearn it. The AI engineer roadmap puts this in order against the rest of the stack.

Build one thing end to end, including the unglamorous parts: evaluation, cost tracking, a failure path when the model returns nonsense. One complete system teaches more than five demos and is far more convincing in an interview, where the follow-up question is always about what broke.

Conclusion

LangChain is a standard interface to models plus a configurable agent harness. That is a smaller claim than the ecosystem around it makes, and it is also genuinely useful, which is why the framework remains the default starting point for production GenAI work.

The main thing standing between you and using it well is not difficulty. It is that most of the material you will find is teaching a version that no longer exists. Read the official docs, check the date on everything else, and build something small that breaks in interesting ways.

Then spend your remaining effort on the parts LangChain does not do for you: knowing whether your system actually works, and knowing when not to build an agent at all.

Frequently Asked Questions