A summary of different LangChain Versions (pre 0.1 / 0.1-0.3 / 1.x)

langchain-versions-summary.md

LangChain Versions: Evolution, Terminology, and Key Differences

LangChain has evolved significantly since its initial release. Rather than thinking in terms of dozens of individual releases, it's more useful to understand its development as three major eras.

Era	Common name	Approx. timeframe	Main characteristics
Pre-0.1	Early LangChain	2023	Experimental framework centred around chains
0.1–0.3	LangChain v0 / LCEL LangChain	2024–2025	Introduction of LCEL and the Runnable architecture
1.x	LangChain v1	2025–present	Agent-first framework built on top of LangGraph

The current stable generation is LangChain v1, which introduced semantic versioning, a significantly simplified API, and a much stronger focus on production-ready AI agents.

---

Evolution of LangChain

Era 1 — Early LangChain (2023)

This is the version that became popular during the GPT-3.5 boom.

Typical code looked like:

LLMChain(...)
ConversationChain(...)
SequentialChain(...)
AgentExecutor(...)

Core concepts introduced

• Chains
• Prompt templates
• Memory
• Output parsers
• Tool calling
• RetrievalQA

Characteristics

Advantages

• Introduced many of the concepts that remain important today.
• Enabled rapid experimentation.

Limitations

• APIs changed frequently.
• Numerous overlapping abstractions.
• Multiple ways to solve the same problem.
• Significant "magic" behaviour that could make debugging difficult.

Today, this era is primarily useful for understanding the historical evolution of the framework.

---

Era 2 — LangChain v0 (approximately versions 0.1–0.3)

This remains the version used by many blog posts, GitHub repositories, tutorials, and courses.

When people casually refer to "LangChain", they are often referring to this generation.

The defining feature of this era was the introduction of LCEL.

---

LangChain Expression Language (LCEL)

LCEL (LangChain Expression Language) fundamentally changed how applications were composed.

Instead of:

chain = LLMChain(...)

applications became pipelines of components:

chain = prompt | model | parser

Everything became a Runnable, enabling components to be composed together.

Example:

chain = prompt | model | StrOutputParser()

Benefits

• Composable pipelines
• Native streaming
• Batching
• Async execution
• Retry mechanisms
• Reusable components

LCEL is arguably the most significant architectural improvement introduced before LangChain v1.

---

Modular package structure

Originally, everything lived inside a single package:

langchain

The ecosystem was later split into multiple packages:

langchain-core
langchain-community
langchain-openai
langchain-anthropic
langchain-google-genai
...

Benefits

• Smaller dependencies
• Faster installation
• Clear separation between core functionality and integrations
• Easier maintenance

---

Runnable Architecture

A major design improvement was the introduction of the Runnable abstraction.

Everything became a Runnable, including:

• prompts
• models
• retrievers
• parsers
• chains

This unified the API and allowed every component to support:

• streaming
• async execution
• batching
• retries
• composition

---

Era 3 — LangChain v1 (Current)

LangChain v1 represents a major redesign rather than a typical version upgrade.

The framework shifted from being primarily focused on building chains to becoming a framework for building AI agents.

The public API became substantially smaller and more consistent.

---

Agent-first architecture

The conceptual model changed.

Previous approach

Prompt
    ↓
Chain
    ↓
Model
    ↓
Parser

Modern approach

Agent
    ↓
Tools
    ↓
Middleware
    ↓
LangGraph Runtime

Agents became the primary abstraction rather than chains.

---

create_agent

Older versions included numerous agent constructors such as:

initialize_agent(...)
create_openai_functions_agent(...)
AgentExecutor(...)

In LangChain v1, these are largely replaced by a single entry point:

create_agent(...)

This significantly simplifies agent creation.

---

LangGraph as the runtime

One of the most important architectural changes is that LangChain is now built on top of LangGraph.

The stack now looks like:

Your Application
        ↓
    LangChain
        ↓
    LangGraph
        ↓
      LLM

LangGraph provides capabilities such as:

• durable execution
• checkpointing
• persistence
• streaming
• resumable workflows
• human-in-the-loop interactions

Simple applications benefit from these capabilities automatically, while more advanced applications can directly use LangGraph when greater control is required.

---

Middleware

LangChain v1 introduces middleware as a first-class concept.

Middleware can be used for:

• logging
• authentication
• guardrails
• human approval
• rate limiting
• cost tracking

This provides a structured way to customise agent behaviour.

---

Standard Content Blocks

Different model providers expose different message formats.

LangChain v1 introduces standard content blocks, creating a provider-independent representation of model inputs and outputs.

This makes switching between providers significantly easier.

---

langchain-classic

Many APIs from previous versions still exist.

Rather than remaining inside the main package, they were moved into:

langchain-classic

This package contains many legacy components, including:

• legacy chains
• older retrievers
• indexing APIs
• deprecated modules

Existing applications can continue using these APIs while new development focuses on the simplified v1 architecture.

---

Common Terminology

Term	Meaning
LCEL	LangChain Expression Language
Runnable	Standard abstraction introduced in v0 for composable components
Chain	Traditional workflow abstraction used heavily in earlier versions
AgentExecutor	Legacy agent execution API
create_agent	Primary agent creation API in LangChain v1
LangGraph	Low-level runtime that powers LangChain agents
LangSmith	Separate platform for tracing, evaluation, debugging, and observability
langchain-core	Core abstractions and interfaces
langchain-community	Community-maintained integrations
langchain-openai	OpenAI integration package

---

Version Comparison

Feature	Early LangChain	LangChain v0	LangChain v1
Primary abstraction	Chains	Runnables + Chains	Agents
Architecture	Chain-based	LCEL pipelines	Agent-first
Composition	Limited	Excellent	Excellent
Streaming	Basic	Native	Native
Async support	Limited	Built in	Built in
Package structure	Single package	Modular	Modular
Runtime	Internal	Runnable architecture	LangGraph
Middleware	No	No	Yes
API stability	Low	Moderate	High

---

Migration Summary

From	To	Main change
Early LangChain	v0	Replace Chain classes with LCEL pipelines (Runnables).
v0	v1	Move from chain-centric applications towards agent-based applications built on LangGraph.

---

Key Takeaways

• LangChain has evolved through three major generations.
• Early LangChain introduced the foundational concepts but was highly experimental.
• LangChain v0 introduced LCEL, the Runnable architecture, and modular packages.
• LangChain v1 shifts the framework towards an agent-first architecture.
• LangGraph is now the execution runtime underneath LangChain.
• Legacy APIs remain available through langchain-classic.
• Modern applications typically use create_agent() rather than older agent constructors.
• Understanding LCEL remains valuable because a large amount of existing code and documentation still uses it.

---

Resources

What's new in LangChain v1 (LangChain Documentation):

• https://docs.langchain.com/oss/python/releases/langchain-v1

LangChain v1 migration guide (LangChain Documentation):

• https://docs.langchain.com/oss/python/migrate/langchain-v1