LangChain is an open-source framework for building applications with large language models (LLMs), including applications that retrieve information or use tools. It provides reusable components and integrations—not a model, a vector database, or a guarantee that an agent will behave reliably. Its create_agent interface is the higher-level starting point for building a configurable tool-using agent.
What is LangChain?
LangChain gives developers a framework for connecting models to tools, data, and application logic. Its abstractions provide standard ways to work with models, embeddings, vector stores, and other components, while integrations connect an application to external systems and data. The framework does not replace the chosen model or its provider: check that provider’s capabilities, credentials, limits, and integration instructions before building around it. See the official LangChain overview for the current introduction.
For an agent, LangChain describes a harness around a model: prompts, available tools, and middleware shape the model’s loop. The create_agent entry point offers a minimal configurable start; developers can add capabilities such as retries, guardrails, routing, and custom tool policies when the application needs them. An agent can still make mistakes. Its behavior depends on the model and on how its tools, instructions, and controls are designed.
What can you build with LangChain?
LangChain’s components support several common application patterns. Models generate or embed content; tools let a model request operations such as API calls or database access; retrievers find relevant material; and document loaders and splitters prepare source documents. Vector stores support similarity search over embedded content.
Recommended Free Tools
#1 Best Overall
Retrieval-augmented generation
In retrieval-augmented generation (RAG), an application searches a source collection for relevant material and supplies it to a model as context for a response. A retriever and, commonly, a vector store can form part of that pipeline. RAG can help ground answers in private or changing reference material, but it does not guarantee accuracy: results depend on the source data, retrieval setup, model, prompts, and application logic.
Tool use
A tool-using agent can select from the operations an application makes available, receive a tool’s result, and continue toward a response. Keep each tool narrowly scoped, define its inputs clearly, and treat side effects—such as changing a record or running a query—as application-level risks to control. The model’s ability to request a tool is not, by itself, a safety or correctness check.
The official learning tutorials include semantic search over a PDF, a RAG agent, and an SQL agent with human review. These are useful starting examples; follow the current documentation for package names and APIs rather than assuming an older example still applies.
How do you get started with LangChain?
- Choose a language and model provider. Start with the official overview and quickstart, then follow the provider’s current setup instructions for credentials and model capabilities.
- Build a small agent. Use
create_agentwith a model and one narrowly scoped tool. Make tool inputs and side effects explicit. The overview’s custom weather tool is an example of the pattern, not a claim that LangChain supplies a live weather service. - Add retrieval if you need reference material. For private or frequently changing documents, work through the PDF semantic-search or RAG tutorial in the official learning catalog.
- Put review around consequential actions. The learning catalog includes an SQL agent with human-in-the-loop review. For workflows where state and intervention points must be explicit, consider whether LangGraph’s lower-level orchestration is a better fit.
- Inspect real runs. Use tracing and evaluation to examine traces, tool calls, state transitions, and failure modes. LangChain’s overview points to LangSmith for these tasks.
APIs, provider setup, package extras, and model names can change. Check the current documentation before publishing code, and pin compatible dependencies in your project environment.
Rank #3
LangChain vs. LangGraph: which should you use?
LangChain and LangGraph are related but serve different abstraction levels. Choose based on how much workflow structure you need to define and control.
| Question | LangChain | LangGraph |
|---|---|---|
| Abstraction level | Higher-level framework with ready-made agent abstractions and integrations. | Lower-level orchestration framework. |
| Workflow and state | Suitable when the higher-level agent harness fits the application. | For explicitly shaping stateful, long-running workflows, including deterministic code and model-driven steps. |
| How much architecture must you define? | More is provided as reusable abstractions; customize as needed. | More workflow orchestration is explicitly shaped by the developer. |
| Can it be used on its own? | Yes, as the higher-level framework described in the official overview. | Yes. The official docs state it can be used without LangChain. |
The LangGraph documentation summarizes its role this way: “LangGraph provides low-level supporting infrastructure for any long-running, stateful workflow or agent.” Read the LangGraph overview if you need to assess that approach.
Where do Deep Agents and LangSmith fit?
Deep Agents are described in the LangChain overview as a more batteries-included option, with features such as planning and subagents. LangSmith has a different purpose: tracing, evaluation, debugging, and related platform capabilities. These sit alongside LangChain and LangGraph in the ecosystem; they are not interchangeable names for the same library or role. Consult the current overview for how the documentation presents these options.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.How should you choose tutorials or books?
For code you plan to use now, begin with official documentation and tutorials, because framework APIs and provider integrations are volatile. When considering a book, check its publication date and edition, the language and package versions used in its examples, and whether its hands-on projects match your goal—such as RAG or agents. Treat older code examples as concepts to verify, not as authoritative instructions for current APIs.
Free tools Windows power users keep installed
One-click scans. No signup required.
Relevant titles include Learning LangChain by Mayo Oshin and Nuno Campos, which O’Reilly describes as a practical guide for developers who know Python or JavaScript, and Generative AI with LangChain, Second Edition, whose contents cover building blocks, RAG, agents, and software-development topics. Confirm that a book’s edition and examples suit your project before relying on it.
