GuideIntermediate
LangChain & LangGraph: From Chains to Agents
Learn to build production-ready AI agents and workflows with LangChain and LangGraph. This guide takes you from connecting models and creating tools, to designing multi-agent systems with persistent memory, human-in-the-loop supervision, and full observability. Ideal for developers who already know Python and want to build AI applications that go beyond a simple chatbot — with full control over the execution flow, error handling, and the best practices for taking agents to production.
- 96
- lessons
- 12
- modules
- English · Spanish
- available in
- Yes
- certificate
- Included in the Club
- access
Outcomes
What you'll be able to do
- Connect to any LLM provider (OpenAI, Anthropic, Google, Ollama) with a unified interface
- Build tools, implement tool calling, and handle structured output
- Create autonomous agents with create_agent and the ReAct pattern
- Customize agent behavior with middleware (dynamic models, tools, prompts)
- Design stateful workflows with LangGraph's StateGraph and Functional API
- Implement advanced patterns: cycles, retries, branching, subgraphs, map-reduce
- Add persistent memory with checkpointing and cross-session storage
- Build human-in-the-loop systems with interrupts, approvals, and editable state
- Architect multi-agent systems with supervisors, handoffs, and shared state
- Monitor and debug agents with LangSmith tracing, evaluation, and token tracking
Before you start
What you need to bring
It's for you if...
- Python developers who want to build AI agents and workflows beyond simple API calls
- Backend engineers looking to integrate LLM-powered features into production systems
- AI engineers who have used basic LangChain and want to master LangGraph for complex workflows
- Developers who have built chatbots and want to level up to autonomous, stateful multi-agent systems
- Engineers preparing for AI Engineering roles that require production-grade agent development
Requirements and materials
- Intermediate Python (functions, classes, decorators, async/await)
- Familiarity with REST APIs and HTTP concepts
- Basic experience calling LLM APIs (OpenAI, Anthropic, or similar)
- At least one LLM API key (OpenAI or Anthropic recommended)
- Python 3.11+ installed
Content
The syllabus, module by module
Open any of them to see its lessons.
- Introduction: The Modern LangChain Ecosystem
- init_chat_model and Providers
- Parameters and Configuration
- Invoke, Stream and Batch
- Structured Output
- Multimodal and Reasoning
- Local Models, Caching and Rate Limiting
- Project: Multi-Provider Chat with Fallback
- Introduction: why models need tools
- Creating Tools with @tool
- bind_tools and the Tool Calling Flow
- Tool Execution Loop
- Parallel Tool Calls and Streaming
- Structured Output with Tools
- Error Handling and Troubleshooting
- Project: An Assistant with External Tools
- Introduction: From Manual Tools to Autonomous Agents
- create_agent and the ReAct Loop
- Static and Dynamic System Prompts
- Agent State and Memory
- Streaming Agents
- Structured Output in Agents
- Legacy vs Modern: API Mapping
- Project: Research Agent with Tools
- Introduction: Customizing Agents Without Rewriting Them
- Your First Middleware: Logging and Monitoring
- @wrap_model_call: Intercepting Model Calls
- @wrap_tool_call: Customizing Tool Execution
- Dynamic Models: Smart Selection
- Dynamic Tools and Dynamic Prompts
- The AgentMiddleware Class: Composed Middleware
- Project: An Agent with Dynamic Model Routing
- Introduction: From Linear Agents to Workflows as Graphs
- StateGraph: Your First Graph
- Nodes: Functions That Transform State
- Edges and Conditional Edges
- Typed State with TypedDict and Annotated
- Compilation and Execution
- create_agent vs StateGraph: When to Use Each One
- Project: Chatbot with State and Conditional Routing
- Introduction: Another Way to Build Agents
- @entrypoint: Defining an Agent as a Function
- @task: The Units That Make Up the Agent
- Native Control Flow
- Graph API vs Functional API: A Deep Comparison
- Patterns with the Functional API
- Combining the Graph and Functional APIs
- Evolving Project: Research Agent Baseline (v1)
- Introduction: Real-World Complex Workflows
- Cycles and Loops: Retry Patterns
- Branching and Merging
- Subgraphs: Modular Composition
- Map-Reduce and Deferred Nodes
- Advanced Error Handling
- Production Patterns
- Evolving Project: Retry Logic and Branching (v2)
- Introduction: Why Agents Need Memory
- Short-term Memory: Conversation History
- Checkpointing with MemorySaver
- Persistence with PostgresSaver and Redis
- Durable Execution
- Time-Travel Debugging
- Long-term Memory: Store and Cross-Session
- Evolving Project: Persistence and Memory (v3)
- Introduction: Agents with Human Oversight
- Interrupts: Pausing Execution
- Breakpoints and Approvals
- Editable State: Modifying State During a Pause
- User Feedback Loops
- HITL Patterns in Production
- When to Automate vs When to Pause
- Evolving Project: Human Approvals (v4)
- Introduction: From One Agent to Many
- Pattern Supervisor
- Pattern Handoffs
- Pattern Subagents
- Pattern Router
- Shared vs Isolated State
- Advanced Orchestration
- Evolving Project: Multi-Agent System (v5)
- Introduction: The Highest Level of Abstraction
- Planning with write_todos
- Virtual Filesystem
- Subagent Spawning and Delegation
- Long-term Memory and Pluggable Backends
- Deep Agents CLI
- create_agent vs LangGraph vs Deep Agents: The Decision Tree
- Evolving Project: The Deep Agent Version (v6)
- Introduction: From Prototype to Production
- Tracing and Observability
- Visual Agent Debugging
- Evaluation: Datasets and Evaluators
- Token Usage Tracking and Prompt Caching
- Rate Limiting and Cost Control
- Production Checklist and Deployment
- Evolving Project: Complete System with Observability (v7 — Final)
Where it fits
This guide is part of something bigger
It's studied inside these programs, with support and dates.
Common questions
What people usually ask
As long as your Club subscription is active. If you cancel and come back later, you get the access and your progress back.
No. Modules run from easier to harder, but you can jump to the one you need. Progress is saved per lesson.
Whatever is needed is listed under “What you need to bring”, above. If nothing is listed there, you can start from zero.
In the Club's WhatsApp group, and every two weeks there's a live with an instructor where questions get worked through.
Yes. It's issued automatically once you finish every lesson, with a verifiable code you can share on LinkedIn.
No. This guide is self-paced with no dates. The bootcamp is live, by cohort, with work someone reviews.
Start whenever you like
What students say
These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.
No approved reviews yet.
Be the first to share your experience!