Multi-Agents with LangChain & LangGraph: Build 4 Projects

Explore the react agent pattern in LangChain and LangGraph, a thought-action-observation loop where agents understand tasks, use tools, observe results, and refine toward a final answer.

Learn to build single-purpose agents with the create_agent function in LangGraph, configuring model, tools, system prompts, structured outputs, contexts, memory, and middleware for a financial assistant.

Learn to deliver tiered services by dynamically swapping models and prompts with middleware in LangChain and LangGraph, using basic, premium, and platinum user tiers.

Design and implement a middleware to gracefully undo tool errors in LangChain. Build a robust transfer money tool with validation and error handling to demonstrate resilient multi-agent workflows.

Configure multi-agent systems to emit structured outputs with a Pydantic schema and LangChain tool strategy, delivering concise summaries, details, action items, warnings, and confidence levels for deterministic results.

Add memory to an agent with a check pointer (e-memory saver) to maintain conversation context across turns, enabling session memory with a thread like Alice; production may use Postgres saver.

Stream agent outputs to provide real-time updates and chunked data processing for long-running tasks. Explore streaming modes, raw LLM outputs, and handling tool calls in LangChain multi-agent projects.

Understand multi-agent systems with LangChain and LangGraph, and apply these tools to build 4 projects.

Apply the subagents design pattern to orchestrate multiple agents using LangChain and LangGraph, building four practical projects.

Explore the hand-off pattern to coordinate agents in LangChain and LangGraph, enabling seamless task delegation and state transfer across multiple agents.

Set up the multi-agent project scaffold by configuring a virtual environment, installing LangChain and LangGraph with OpenAI or Anthropic, and creating a .env workflow and source package.

Define the agent state by building a state schema that tracks conversation history and skills loaded with progressive disclosure, using typed dicts with LandGraph and an append-only messages list.

Create four agent skills, front-end, back-end, network, and database, with name and description loaded into the system prompt at startup, then load full content on demand.

Create a central skills registry with helper functions to query and list skills, export them, and implement a loadSkill tool to load full skill content for a multi-agent LangChain system.

Define a middleware to inject each skill's front matter into the system prompt and build a base-plus-skills system prompt, exporting load_skill and get_tools functions for multi-agent workflows.

Create an LLM interface for a LangChain and LangGraph agent that supports OpenAI and Antropic, loading environment variables, selecting providers, and configuring models.

Define and assemble the agent graph for a web troubleshooting multi-agent system by creating the agent node, tool node, and conditional edges, binding the LLM to tools and managing state.

Build a polished command-line interface for a multi-agent system using the rich library, developing interactive display functions with markdown, tables, and panels for a delightful UI.

Learn to implement a command-line interface skill-loading display that tracks loaded skills from tool calls, notifies on loading, and shows current and previous skill sets for a multi-agent system.

Build the main interactive cli loop that initializes the agent, handles user commands, processes messages, and updates and displays loaded skills for responsive agent interactions.

Create the main entry point for an agentic command-line interface app by adding source/main.py with argpass parsing, a run cli function, and a version flag for the Web Troubleshooting Assistant.

Practice end-to-end web app testing with a multi-agent setup, using progressive disclosure to load front-end, back-end, network, and database skills while diagnosing production issues.

Read the project plan, create the job interview pipeline folder in VS Code, set up a Python virtual environment, and install dependencies from a requirements.txt including langchain, langgraph, and OpenAI.

Define state variables for a multi-agent system. Create a state.py to manage intake, assessment, and decision data for HR, technical assessor, and hiring manager handoffs.

Craft recruiter tools that record applicant intake data in state, perform a handoff to the technical assessment agent, and update the conversation using LangChain and LangGraph patterns.

Create a tool to record technical assessments, score candidates from 1 to 10, capture assessment notes, and hand off results to the IRA manager, while updating conversation history for traceability.

Build two hiring manager tools for the decision stage: a make decision tool recording hire, reject, or hold with feedback, and a reassessment tool returning candidates to assessment.

Define the end-to-end handoff configuration for multi-agent interviews by building step configs with intake, assessment, and decision agents, each with prompts and tools, enabling swaps via state changes.

Build a dynamic job interview pipeline by swapping prompts and tools through middleware, launching agents, and validating required fields to adapt the interview flow in real time.

Implement guardrails for the handoff process by adding a before model middleware that ends turns when any handoff tool is called, and update prompts in config.py to enforce strict handoffs.

Learn to build a command-line interface for a multi-agent interview system, differentiating agents with icons, managing intake to decision steps, handoffs, and Sam's feedback in an interactive CLI.

Test the multi-agent job interview pipeline with three interviewers and HTML fundamentals. We verify accessibility and form validation, ending with an 8/10 hire decision and potential UI improvements.

Set up a smart travel planner project by configuring a virtual environment, installing dependencies, creating mock data for flights, hotels, activities, and restaurants, and organizing sub-agents.

Build the flights sub-agent to search flights and compare prices using two tools, handling natural language queries, destination, budget, and stop preferences to surface best deals.

Learn to build a hotels sub-agent with LangChain, featuring search hotels and get hotel recommendation tools, filtering by destination, budget, traveler type, and amenities.

Discover how to build an activity sub-agent within a multi-agent setup using LangChain and LangGraph to complete four projects.

Create the itinerary sub-agent to organize flights, activities, and hotels into a day-to-day schedule. Apply daily schedule, route optimization, and trip summary tools to optimize timing.

Learn to build a supervisor agent that coordinates four sub-agents—flights, hotels, activities, and itinerary—wrapped as tools, with a shared model and an in-memory store for short-term memory.

Orchestrate a memory-enabled, command-line, chat-based multi-agent system with a supervisor guiding sub-agents, using UUID thread IDs for persistent context in a smart travel planner.

Configure llm provider keys, run a multi-agent system with LangChain and LangGraph, and generate a complete Tokyo trip plan using sub-agents for itinerary and hotels.