LangChain, LangGraph, and LlamaIndex: How Do They Differ?

Introduction

LangChain, LangGraph, and LlamaIndex are often mentioned together because they all belong to the Python LLM ecosystem, yet each solves a distinct problem. Understanding their core positioning makes it easy to choose the right tool for a given AI project.

Core Positioning

LangChain addresses how to call models, manage prompts, and integrate tools .

LlamaIndex focuses on loading documents, building indexes, and performing precise retrieval .

LangGraph handles state management, looping logic, and fault recovery for complex agents .

LangChain

What It Is

LangChain is the earliest standardized framework for building LLM applications. It provides chain‑style abstractions, model and tool invocation, agent creation, and middleware. As of 2026 it has >95K GitHub stars and integrates hundreds of LLMs, vector stores, and tools.

Core Architecture

Code Example – Simple Question Answering

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage

model = ChatOpenAI(model="gpt-4")
response = model.invoke([HumanMessage(content="What is microservice architecture?")])
print(response.content)

Code Example – Adding RAG Retrieval

from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

loader = TextLoader("knowledge.txt")
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000)
docs = text_splitter.split_documents(documents)

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(docs, embeddings)
retriever = vectorstore.as_retriever()
relevant_docs = retriever.get_relevant_documents("What is microservice?")

Pros

Most complete ecosystem (hundreds of LLMs, tools, vector DBs).

Modular, Lego‑like design.

Low entry barrier for quick demos.

Cons

Steep learning curve due to many concepts.

Additional latency from abstraction layers.

Rapid version changes can cause instability.

Typical Scenarios

Rapid prototyping – ✅✅✅ (demo in days).

Multi‑model A/B testing – ✅✅✅ (swap models via config).

Projects needing rich integrations – ✅✅✅ (largest ecosystem).

High‑performance production – ⚠️ (evaluate performance overhead).

LangGraph

What It Is

LangGraph, developed by the LangChain team, provides a stateful graph runtime for complex LLM agents. It solves the problem of orchestrating loops, conditional branches, and multi‑step tool calls while keeping the workflow observable and recoverable.

Key Design – Checkpoint Mechanism

The checkpoint automatically saves the state after each step, allowing an agent that crashes at step 5 to resume from that point instead of restarting.

Code Example

from langgraph.graph import StateGraph, END
from typing import TypedDict, List

class AgentState(TypedDict):
    messages: List[dict]
    tool_results: List[str]
    done: bool

def llm_node(state: AgentState) -> AgentState:
    # call LLM, decide if tool is needed
    return state

def tool_node(state: AgentState) -> AgentState:
    # execute tool call
    return state

def should_continue(state: AgentState) -> str:
    if state["done"]:
        return "end"
    return "tool"

graph = StateGraph(AgentState)
graph.add_node("llm", llm_node)
graph.add_node("tool", tool_node)
graph.set_entry_point("llm")
graph.add_conditional_edges("llm", should_continue, {"tool": "tool", "end": END})
graph.add_edge("tool", "llm")  # loop!
app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "Check Beijing weather"}]})

Pros

State‑driven decisions are traceable and auditable.

Checkpoint + interrupt model enables long‑running, production‑grade agents.

Mixes deterministic logic with LLM steps in a single graph.

Cons

Steep learning curve.

Graph model not suitable for every workflow.

Typical Scenarios

Complex agent workflows (10+ steps) – ✅✅✅.

Finance/health applications requiring audit trails – ✅✅✅.

Systems needing error recovery and retry – ✅✅✅.

LlamaIndex

What It Is

LlamaIndex (formerly GPT Index) is a data‑centric framework designed specifically for Retrieval‑Augmented Generation (RAG). Its mission is to connect unstructured data with LLMs seamlessly.

As of 2026 it has >44K GitHub stars and offers >300 data connectors (Notion, Google Drive, Slack, PDFs, databases, etc.).

RAG Full‑Stack Pipeline

Code Example – Simple Index

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_parse import LlamaParse

documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("What is the company's leave policy?")

# Complex PDF with LlamaParse
parser = LlamaParse(result_type="markdown")
documents = parser.load_data("./complex_report.pdf")
index = VectorStoreIndex.from_documents(documents)

Pros

RAG capabilities are top‑of‑the‑line; strong ingestion and retrieval.

Out‑of‑the‑box; a few lines of code spin up an enterprise knowledge base.

Supports hybrid search, re‑ranking, and other advanced features.

Cons

Focused on RAG; general agent orchestration is weaker than LangChain.

Typical Scenarios

Enterprise internal knowledge bases – ✅✅✅.

Batch parsing of hundreds of financial‑report PDFs – ✅✅✅.

Applications needing hybrid search/re‑ranking – ✅✅✅.

Best‑Practice Combination

The most effective solution rarely picks a single framework; instead, they complement each other:

LlamaIndex as the data layer: ingest documents, build diverse indexes.

LangGraph as the orchestration layer: define state graphs, manage multi‑step reasoning and tool calls.

LangChain as the foundational layer: provide model calls, tool definitions, and prompt management.

Detailed Comparison

Core Positioning : LangChain – general LLM app framework; LangGraph – stateful agent runtime; LlamaIndex – RAG data framework.

Core Abstractions : Chain/Agent; StateGraph; Index/QueryEngine.

GitHub Stars : 95K+, 15K+, 44K+ respectively.

Ecosystem Scale : LangChain integrates >100 components; LangGraph lives within the LangChain ecosystem; LlamaIndex offers >300 connectors.

Main Advantages : LangChain – richest ecosystem, quick start; LangGraph – state management & observability; LlamaIndex – strongest RAG capabilities.

Main Disadvantages : LangChain – performance overhead, learning curve; LangGraph – steep learning curve; LlamaIndex – narrower focus.

Best Fit : LangChain – rapid prototyping, multi‑model integration; LangGraph – production‑grade complex agents; LlamaIndex – enterprise knowledge bases and RAG use cases.

License : All three use the MIT license.

Conclusion

LangChain supplies the building blocks, LangGraph assembles those blocks into a debuggable, recoverable pipeline, and LlamaIndex handles the data side of Retrieval‑Augmented Generation. Together they form a complementary stack rather than a three‑way competition.

Open‑source repositories:

LangChain – https://github.com/langchain-ai/langchain (95K+ stars)

LangGraph – https://github.com/langchain-ai/langgraph (15K+ stars)

LlamaIndex – https://github.com/run-llama/llama_index (44K+ stars)