LangChain

LangChain is an MIT-licensed framework for building agents and LLM-powered applications. Its official documentation frames the current product around `create_agent`: a minimal harness that combines a model, tools, a system prompt, and optional middleware. The harness is the loop around the model, and LangChain's abstractions are meant to let developers compose that loop without writing every integration and control-flow primitive from scratch.

LangChain is not a single product. The ecosystem splits into distinct layers with different licenses and cost structures. The framework (`langchain`, `langchain-core`) and the orchestration runtime (`langgraph`) are open source and MIT-licensed. LangSmith—tracing, evaluation, datasets, and managed deployment—is a separate, closed-source product with its own pricing. Deep Agents and Managed Deep Agents sit further up the stack, offering a batteries-included harness and a hosted runtime respectively. Confusing “LangChain” with “LangSmith” is the most common source of sticker shock: the framework costs nothing, while the observability layer can become a material operating expense.

The framework is model-agnostic. Official examples cover OpenAI, Anthropic, Google, and OpenRouter, and the integration surface extends across model providers, vector stores, document loaders, and tools. The trade-off of that breadth is abstraction depth: LangChain adds layers over the provider APIs, and when those layers do not match the task, developers must debug through them.

A minimal LangChain application starts with `create_agent`, passing a model identifier, a list of tools, and a system prompt. The agent receives a message list, selects tools when the model decides to, executes them, and returns the final message content. Tools are ordinary Python functions decorated with `@tool`; the model sees their names and descriptions and decides when to call them.

For workflows that need deterministic branching, persistence, checkpointing, or human-in-the-loop pauses, the agent can be backed by LangGraph, LangChain's low-level orchestration runtime. LangGraph represents execution as a graph of nodes and edges, allowing developers to combine agentic steps with fixed control flow. LangSmith, when enabled, records traces of each step—model calls, tool calls, and intermediate state—so developers can inspect what happened and evaluate agent trajectories over time.

The workflow from the user's perspective is code-first: you write Python or TypeScript, install the framework and provider-specific integration packages, and run the application in your own environment or a deployment target. LangChain does not impose a visual builder or a hosted workspace; those are separate products in the ecosystem.

• Building a single-agent application with tool calling, where the model decides which functions to invoke and in what order
• Adding persistence, checkpointing, and human-in-the-loop approval to an agent workflow via LangGraph
• Composing RAG pipelines with document loaders, text splitters, embeddings, vector stores, and retrievers behind a standardized interface
• Prototyping across multiple model providers without rewriting application code when switching from one API to another
• Instrumenting an agent with tracing and evaluation before moving it toward production