LangChain & LangGraph Agentic Ebook

Hands‑on study guide for LangChain and LangGraph, taking you from basic LLM calls to production‑style RAG, multi‑agent systems, and advanced agentic AI workflows. The content is organized as an HTML ebook with phases and modules, plus runnable Python snippets you can drop into your own projects.

Repo: https://github.com/rahulkolekardev/langchain-langgraph-agentic-ebook

---

What’s Inside

• HTML ebook
  • index.html – entry point with navigation and usage notes.
  • phase0.html – prerequisites and setup.
  • phase1.html – LangChain core and LCEL.
  • phase2.html – LangGraph fundamentals.
  • phase3.html – real applications, deployment, evaluation.
  • phase4.html – advanced agentic systems and multi‑agent patterns.
• UI features
  • Clean, responsive layout with sidebar navigation.
  • Dark mode toggle (with preference persisted in localStorage).
  • Simple in‑page heading search for each chapter.
  • Code blocks with lightweight syntax highlighting.
• Code examples
  • Python snippets for:
    • Calling chat models with LangChain.
    • LCEL chains and RAG pipelines.
    • Tools, agents, and structured outputs.
    • LangGraph state graphs and agent graphs.
    • Multi‑agent flows, memory layers, and safety policies.

You can treat this repo as both a book and a playground for building your own LangChain/LangGraph projects.

---

Getting Started

1. Clone the repo

git clone https://github.com/rahulkolekardev/langchain-langgraph-agentic-ebook.git
cd langchain-langgraph-agentic-ebook

2. View the ebook

Open index.html in a browser:

• Double‑click the file, or
• Serve via a simple HTTP server:

python -m http.server 8000
# then visit http://localhost:8000/index.html

Use the sidebar to navigate phases and modules. Each chapter contains explanations plus inline code snippets.

3. (Optional) Set up Python to run examples

Create and activate a virtual environment, then install core dependencies:

python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\Activate.ps1

pip install \
  langchain langchain-core langchain-community \
  langchain-openai langgraph python-dotenv \
  faiss-cpu chromadb

Configure an LLM provider (e.g. OpenAI):

echo "OPENAI_API_KEY=sk-..." > .env

Then copy snippets from the ebook into a src/ directory (for example src/phase1/simple_rag_cli.py) and run them with python.

---

Ebook Table of Contents

Each phase builds on the last. You can read linearly or jump to the parts you need.

Phase 0 – Prerequisites & Setup (phase0.html)

Goals

• Be comfortable with Python development.
• Have your environment ready to run LangChain and LangGraph apps.
• Be able to call at least one model API.

Highlights

• Core Python skills (functions, classes, typing, asyncio, debugging).
• Virtual environments, project structure, and dependency management.
• LLM basics: prompts, tokens, temperature, chat vs completion.
• Environment setup with LangChain, LangGraph, and vector stores.
• Mini task: first LangChain chat script + CLI.

---

Phase 1 – LangChain Core & LCEL (phase1.html)

Goals

• Understand LangChain architecture and Runnables.
• Learn LCEL (LangChain Expression Language) for composing chains.
• Build basic RAG, tools, agents, memory, and structured outputs.

Modules

1. LangChain core concepts & LCEL
   • Runnables, | pipe operator, .invoke/.batch/.stream.
   • ChatPromptTemplate, StrOutputParser, configuration & fallbacks.
2. Working with data & simple RAG
   • Document loaders, splitters, embeddings, vector stores (FAISS/Chroma).
   • LCEL RAG pipeline and a CLI RAG app over your notes.
3. Tools, agents, memory & structured output
   • Tools via @tool, tool‑calling agents, and calculator/search tools.
   • Conversation memory and when to use it.
   • Pydantic / JSON schemas and with_structured_output.
   • Console chatbot that uses tools, memory, and structured responses.

---

Phase 2 – LangGraph Fundamentals (phase2.html)

Goals

• Understand LangGraph’s model: state, nodes, edges, compilation.
• Wrap LangChain pipelines (e.g. RAG) in LangGraph workflows.
• Add branching, loops, agent nodes, human‑in‑loop, and persistence concepts.

Modules

4. LangGraph basics: nodes, edges, state
   • StateGraph, typed state, node functions, and .invoke/.stream.
   • Simple RAG workflow graph: validate → rewrite → retrieve → answer.
5. Control flow, agents, human‑in‑loop & persistence
   • Conditional edges, router nodes, retries and loops.
   • Agent nodes that wrap LangChain agents inside a graph.
   • Human approval patterns and checkpointing concepts.

---

Phase 3 – Applications, Deployment & Evaluation (phase3.html)

Goals

• Combine LangChain + LangGraph into production‑style RAG assistants.
• Build multi‑agent systems and expose them via APIs.
• Learn configuration, testing, deployment, monitoring, and basic security.

Modules

6. Production‑style RAG assistant
   • Ingestion pipeline (load/split/embed/index).
   • LangGraph‑orchestrated RAG graph with logging and errors.
   • FastAPI backend, evaluation script, and streaming endpoints.
7. Multi‑agent systems with LangGraph
   • Planner, researcher, writer, reviewer, and moderation agents.
   • Multi‑agent graphs and shared state patterns.
8. Hardening & deployment
   • Central configuration and environment management.
   • Unit/golden/regression testing approaches.
   • Deployment patterns (API service, workers, containers).
   • Monitoring, observability, and basic security/guardrails.

---

Phase 4 – Advanced Agentic Systems (phase4.html)

Goals

• Go beyond simple agents into richer agentic AI systems.
• Explore advanced reasoning, planning, multimodal tools, memory, safety, and multi‑agent coordination at scale.

Modules

10. Advanced agent reasoning patterns
    • ReAct‑style agents (Thought/Action/Observation loops).
    • Reflexion/self‑critique and answer revision.
    • Multi‑branch / Tree‑of‑Thought‑style reasoning.
11. Planning & hierarchical agents
    • Plan‑and‑Execute (planner + executor).
    • Hierarchical controllers and dynamic replanning.
    • Planner/executor wrapped in LangGraph.
12. Advanced tools, multimodal & code agents
    • Dynamic toolsets and tool pipelines.
    • Multimodal tools (image/document analysis sketches).
    • Safe Python “code interpreter” and database‑style tools.
13. Memory, safety, governance & evaluation
    • Vector‑store‑backed long‑term memory.
    • Tool policy layer and audit logging.
    • Agent evaluation and benchmarking ideas.
14. Multi‑agent coordination & scalable deployment
    • Debate/critique agents and multi‑agent graphs.
    • Concurrency and shared state considerations.
    • Scaling many agent sessions in production.

---

How to Use This Repo

• As a learner – read chapters in order, copy code into your own project, and adapt examples to your use cases.
• As a reference – jump directly to phases/modules relevant to your current work (e.g. Phase 2 for LangGraph, Phase 4 for advanced agentic patterns).
• As a starter kit – reuse the RAG, agent, and LangGraph patterns as a baseline for your own applications.

If you’d like, you can extend the ebook with your own Phase 5 (e.g. domain‑specific agents, research‑grade evaluation, or building a custom framework layer on top of LangChain/LangGraph). The structure is meant to be easy to modify and grow.

Goals

• Be comfortable with Python development.
• Have your environment ready to run LangChain and LangGraph apps.
• Be able to call at least one model API.

Topics

1. Core Python skills

   • Functions, classes, typing
   • Virtual environments, pip, project structure
   • Basic asyncio: async def, await, tasks
   • Basic debugging: print, logging, using an IDE debugger

2. LLM basics

   • Prompt, context window, temperature, tokens
   • Difference between chat models vs text completion models
   • At least one provider: OpenAI, Anthropic, or local (Ollama)
   • Basic concepts of rate limits, latency and cost

3. Environment setup

   • Create a new project folder

   • Set up a virtual env

   • Install:

     pip install \
       langchain langchain-core langchain-community \
       langchain-openai langgraph python-dotenv \
       faiss-cpu chromadb
     

   • Store keys in .env and load them with python-dotenv

   • Configure at least one model provider (e.g. OPENAI_API_KEY, ANTHROPIC_API_KEY, or local Ollama)

4. Read once, lightly

   • LangChain overview in the docs to see what components exist.
   • LangGraph overview to understand that it is a low level orchestration framework for long running, stateful agents.
   • Skim LangSmith / tracing docs to know they exist for later.

Mini task

• Write a tiny script that calls a chat model and prints the response.
• Wrap it in a CLI script that reads a question from input().

---

Phase 1. LangChain Core and LCEL

Module 1. LangChain core concepts and Expression Language (LCEL)

Goals

• Understand LangChain architecture.
• Learn the core interfaces and the idea of Runnables or LCEL.

Topics

1. What LangChain gives you

   • Models abstraction
   • Prompts
   • Output parsers
   • Document loaders and retrievers
   • Tools and agents

2. LCEL (LangChain Expression Language)

   • What Runnables are and why they matter.
   • Using the | pipe operator to connect components: chain = prompt | model | parser
   • Basic methods: .invoke, .batch, .stream, .astream
   • Common building blocks:
     • RunnableLambda, RunnableParallel, RunnableBranch, RunnablePassthrough
   • Configuration helpers:
     • .with_config (tags, run name, metadata)
     • .with_retry, .with_fallbacks, basic error handling

3. Basic prompt chaining

   • ChatPromptTemplate
   • System vs user messages
   • Simple chain: user input → prompt → model → string output
   • Using StrOutputParser and basic JSON/struct parsing

Practice

• Create a simple LCEL chain:
  • Input: topic string
  • Output: short explanation and a list of 3 bullet points
• Try the same chain with .stream to see tokens streaming.
• Add .batch to run the chain on a list of topics.

---

Module 2. Working with data: loaders, splitters, vector stores and simple RAG

Goals

• Learn how LangChain handles documents and retrieval.
• Build your first small RAG style question answering system.

Topics

1. Document handling

   • Document loaders: PDFs, web pages, text files
   • RecursiveCharacterTextSplitter and other splitters
   • Chunk size / overlap tradeoffs and metadata (source, page)

2. Vector stores and retrievers

   • Concept of embedding models and vector search.
   • Using common vector stores: FAISS or Chroma.
   • Creating a retriever object.
   • Metadata filters (e.g. by tag, date) and search parameters (k, score threshold).

3. RAG with LCEL

   • Typical pipeline:
     • Load and split docs
     • Embed and store
     • On user query: retrieve top k chunks
     • Feed retrieved context plus query into a prompt and model

4. LCEL composition for RAG

   • Use LCEL to compose retriever and model:
     • retriever | prompt | model | parser
   • Use RunnableParallel to fetch docs and do light pre‑processing in parallel.

5. Beyond the basics (optional preview)

   • Rerankers and hybrid search (BM25 + dense).
   • Specialized retrievers (parent‑document, multi‑vector) and when they help.

Practice

• Index a small set of markdown or PDF notes.
• Build a CLI app:
  • User types a question.
  • System performs RAG over your notes and answers.

---

Module 3. Tools, agents, memory and structured outp