LangChain

LangChain is one of the most widely used frameworks for building applications around large language models. It became popular because it packaged common agent patterns - prompts, tool calling, memory, retrieval, middleware, and orchestration - into reusable abstractions that developers could combine quickly.

How LangChain actually works

At a high level, LangChain standardizes the moving parts of an LLM application so you can swap models and tools without rewriting the whole app. You define a model, define tools or other components around it, and then let a LangChain agent handle the loop of model call, tool selection, tool execution, and continuation.

In the modern docs, LangChain positions itself as the easiest way to get started with custom agents, while LangGraph sits underneath as the lower-level runtime for more advanced orchestration. That means a lot of what people think of as "LangChain agents" are really built on top of LangGraph's durable execution, persistence, streaming, and human-in-the-loop support.

What it is good for

LangChain is often the first framework people reach for when they want to build:

• a research or browsing agent
• a retrieval-augmented generation system
• a tool-calling assistant
• a workflow that loops between reasoning and external actions
• a prototype that needs integrations across many providers quickly

Its ecosystem is one of its biggest strengths. LangChain has broad integrations for model providers, vector stores, databases, APIs, and observability tooling, which is why so many tutorials and first production prototypes are built on it.

Initialization and first steps

The current Python docs show a minimal setup that looks roughly like this:

• install the package, for example pip install -U langchain plus the provider integration you need
• define a tool as a normal Python function
• call create_agent(...) with a model and tool list
• invoke the agent with a message payload

The docs now emphasize that you can get a working agent running in under ten lines of code, which is part of LangChain's appeal: it gets you from model to runnable agent quickly.

Where the docs actually are

The official Python docs are at https://docs.langchain.com/oss/python/langchain/overview.

The most useful entry points are:

• LangChain overview: https://docs.langchain.com/oss/python/langchain/overview
• Deep Agents overview: https://docs.langchain.com/oss/python/
• context overview: https://docs.langchain.com/oss/python/concepts/context
• middleware overview: https://docs.langchain.com/oss/python/langchain/middleware/overview

Those pages matter because the LangChain ecosystem has evolved a lot. Older tutorials often describe earlier APIs, while the current docs reflect the newer split between LangChain, LangGraph, and Deep Agents.

Tradeoffs

The tradeoff is abstraction. LangChain can dramatically speed up development, but it can also make failures harder to debug because the framework sits between the developer and the raw model loop. That is why many experienced teams prototype with direct API calls first, then adopt LangChain once they understand the behavior they want to standardize.

In short: LangChain is excellent when you want to move quickly and benefit from a large integration ecosystem. It is less ideal when you need to understand every token-level step of the runtime or when your workflow is so custom that the abstraction becomes friction instead of leverage.