LangChain

LangChain is the most widely adopted framework for building LLM-powered applications and agents. Maintained by LangChain Inc., it was first released in 2022 under the MIT license and is available as a mixed (polyglot) library with mature Python and TypeScript SDKs. With over 136,000 GitHub stars, 3,600+ contributors, and more than 240 million monthly downloads on PyPI, it dominates the ecosystem as the default starting point for teams building retrieval-augmented generation (RAG) pipelines, tool-using agents, and multi-step LLM workflows.

LangChain solves a fundamental problem: connecting LLMs to the rest of your stack. It provides a unified interface for hundreds of model providers, vector stores, retrievers, and external tools, letting developers compose these components without rewriting glue code for each integration. The framework is opinionated about modularity but flexible enough to accommodate everything from a single chain to a heterogeneous multi-agent system. Its design philosophy prioritizes composability and rapid prototyping, making it the go-to choice for teams that need to move fast and iterate on LLM application logic.

LangChain is code-first and declarative by default, though it supports imperative control flow when needed. The core abstractions are:

• Models: Chat models and LLMs from any provider (OpenAI, Anthropic, Google, Ollama, AWS Bedrock, etc.) accessed through a uniform interface.
• Messages: Structured input/output with system, user, assistant, and tool message types.
• Tools: Functions that an LLM can call, defined with schemas and optional execution logic.
• Chains: Composable sequences of calls (model + tool + retriever) built using LangChain Expression Language (LCEL).
• Agents: Loops where an LLM decides which tool to call next, with built-in memory and short-term context.
• Retrievers: Document retrievers that connect to vector stores (Pinecone, Chroma, Weaviate, etc.) and implement search strategies.
• Memory: Short-term and long-term memory stores for multi-turn conversations.

LCEL is the framework’s declarative composition layer. You pipe components together using | (similar to Unix pipes) to define a processing pipeline. For example, a RAG chain might look like: retriever | prompt | model | output_parser. This approach makes the data flow explicit and easy to debug. For more complex agent logic (branching, loops, human-in-the-loop), LangChain provides an agent executor that runs a tool-calling loop until a stop condition is met.

Control flow is largely deterministic in chains and probabilistic in agents (the LLM decides the next step). LangChain handles the orchestration of tool calls, error handling, and retries. The framework also supports streaming at the model and chain level, so you can stream tokens as they are generated.

LangChain ships a massive integration surface. Out of the box, it supports hundreds of model providers, vector stores, document loaders, text splitters, and tools. This is its strongest differentiator: you rarely need to write a custom wrapper.

LCEL composition lets you build pipelines declaratively. It is not just syntactic sugar; LCEL includes built-in support for streaming, async execution, and batch processing. You can also attach callbacks for logging and tracing.

LangSmith integration is first-class. LangSmith provides observability, evaluation, and debugging for LangChain applications. You can trace every step of a chain or agent, annotate runs, run LLM-as-judge evals, and compare iterations. This closes the development loop: prototype in LangChain, observe in LangSmith, iterate.

Confirmed capabilities include:

• Multi-agent: You can spawn multiple agents that share tools and memory, coordinated via LangGraph or custom orchestration.
• Streaming: Token-by-token streaming from models and chains, critical for chat UX.
• Tool use: Structured tool calling with schema validation and error handling.
• Human in the loop: Pause agent execution, request human approval, then resume.
• Memory: Short-term (conversation buffer) and long-term (vector store-backed) memory.
• Tracing and evaluations: Full observability via LangSmith.
• Self-hostable and cloud-hosted: LangChain itself is a library; LangSmith can be self-hosted or used as a cloud service.

Where it excels: Rapid prototyping of RAG pipelines, heterogeneous model routing (switch between providers with one line of code), and building standard tool-calling agents. The framework is battle-tested in production by thousands of teams.

Teams deploy LangChain primarily for three workload types:

• RAG over documents: Connect a vector store (Pinecone, Weaviate, Qdrant) to an LLM, add a retrieval chain, and build a document Q&A system. LangChain’s catalogue of retrievers and document loaders (PDF, HTML, Notion, Confluence, etc.) makes this a one-afternoon project.
• Prototype LLM features fast: Product teams use LangChain to wire up a model, a tool (e.g., web search, calculator, SQL query), and a prompt in under 20 lines of code. This is ideal for internal copilots, customer support triage bots, and code generation pipelines.
• Heterogeneous model routing: Use LangChain to call GPT-4 for reasoning, Claude for long context, and a local model for sensitive data, all behind the same interface. This pattern is common in regulated industries.

LangChain is a poor fit for highly complex, long-running agent workflows with nested subgraphs, persistent state, and fine-grained control over execution. For those, the maintainers recommend LangGraphcars. It also struggles with extremely low-latency requirements if you need to avoid the overhead of LCEL’s abstraction layer.

Install LangChain for Python:

1pip install langchain

For TypeScript/Node.js:

1npm install @langchain/core @langchain/community

The smallest meaningful example (Python):

1from langchain.chat_models import init_chat_model
2from langchain_core.messages import HumanMessage
3
4model = init_chat_model("openai:gpt-4o")
5response = model.invoke([HumanMessage("Hello, world!")])
6print(response.content)

To build a RAG pipeline, you will need:

• An LLM provider API key (OpenAI, Anthropic, etc.)
• A vector store (local with Chroma or cloud with Pinecone)
• Documents to ingest (LangChain provides loaders for almost every format)

Start with the official docs at [python.langchain.com](https://python.langchain.com) or [js.langchain.com](https://js.langchain.com). The community is large and active on GitHub Discussions, Discord, and X (@langchain_oss).

LangChain vs. LangGraph: LangChain is the higher-level framework for quick prototyping. LangGraph is the low-level orchestration framework from the same team, designed for production-grade agent workflows with persistent state, branching, and human-in-the-loop. If you need full control over agent execution, use LangGraph. If you want to build a simple chain or agent in minutes, start with LangChain.

LangChain vs. CrewAI: CrewAI focuses on multi-agent collaboration with role-based agents and tasks. LangChain is more general-purpose; it gives you the primitives to build multi-agent systems but does not prescribe a specific collaboration model. Choose CrewAI if you want a opinionated multi-agent framework out of the box. Choose LangChain if you need maximum flexibility and a larger integration ecosystem.

LangChain vs. LlamaIndex: LlamaIndex specializes in data indexing and retrieval for RAG. LangChain also does RAG well, but its strength is broader LLM application composition. If your primary workload is advanced indexing, chunking, and querying over structured/unstructured data, LlamaIndex may be a better fit. If you need to combine RAG with tool use, agents, and multi-model routing, LangChain is the more complete choice.

When to choose LangChain: You are prototyping an LLM feature, building a RAG system with multiple data sources, or need to switch between model providers without rewriting code. Its vast integration surface and mature community make it the safest bet for most teams starting out.

When to avoid LangChain: You need fine-grained control over agent loop internals, or you are building a high-throughput system where every millisecond of overhead matters. In those cases, consider LangGraph or a custom solution with a minimal abstraction layer.