Summary of "Sequential Workflows in LangGraph | Agentic AI using LangGraph | Video 5 | CampusX"

High-level purpose

Transition from theory to hands-on coding in the “Agentic AI Using LangGraph” playlist.
Two teaching goals:
1. Show basic LangGraph coding so beginners can run their first graph.
2. Enable viewers to create arbitrary sequential (linear) workflows in LangGraph.

Environment:
- Create and activate a virtualenv.
- Install packages used in the demo:
  - langgraph
  - langchain
  - langchain-openai (LangChain’s OpenAI integration)
  - python-dotenv (or equivalent) to load environment variables / API keys
  - ipykernel for running Jupyter notebooks
Use Jupyter Notebook for coding and graph visualization (LangGraph visualizations render in notebooks).
Load OpenAI API key via a .env file.
Use ChatOpenAI from LangChain for LLM calls.

State
- Represented by a Python TypedDict class (the persistent graph state).
- Each workflow passes and returns the state object across nodes.
StateGraph
- Construct a StateGraph with the TypedDict as the state type.
Nodes
- Added with graph.add_node("node_name", function_reference).
- Nodes are plain Python functions that receive state and return (possibly modified) state.
Start/End pseudo-nodes
- Imported from LangGraph to mark graph entry and exit.
Edges
- Use graph.add_edge(source, target) to create flow between nodes.
Compile and invoke
- graph.compile() returns a runnable workflow object.
- workflow.invoke(initial_state) executes nodes in order and returns final state.
Visualization
- Use LangGraph sample code (from docs) to render the graph in Jupyter for design/debugging.

State: BMIState TypedDict with weight (float), height (float), bmi (float).
Node: calculate_bmi(state) computes bmi = weight / height**2, rounds it, updates state, and returns state.
Graph edges: start → calculate_bmi → end.
Execution: workflow.invoke(initial_state) returns final state with bmi.
Extended example: add label_bmi node to categorize BMI (underweight, normal, overweight, obese) and update state with category.
- Edges: start → calculate_bmi → label_bmi → end.

State: LLMState with question_body (string) and answer_body (string).
Node: llm_qa(state) builds a prompt from the question, calls ChatOpenAI (via LangChain), extracts response.content, stores it in state.answer_body, and returns state.
Graph: start → llm_qa → end.
Demonstrates invoking an LLM from inside a LangGraph node and combining LangChain models with LangGraph workflow structure.

Motivation: show chaining multiple LLM interactions inside a workflow (decomposition across nodes).
State: BlogState with title, outline, content (strings).
Nodes:
- CreateOutline: reads title, asks the LLM for a detailed outline, stores outline in state.
- CreateBlog: uses title + outline, asks the LLM to write the full blog, stores content in state.
Graph: start → CreateOutline → CreateBlog → end.
Benefit: Persistent state retains intermediate artifacts (outline, title, content) making inspection and downstream use easier than ad-hoc LangChain chains.

Use type hinting for states and node functions: functions accept and return the TypedDict type.
Partial state updates: nodes mutate and return state so it evolves across nodes.
Call graph.compile() to validate graph structure before running.
Visualize the graph in Jupyter for debugging and design.
LangGraph complements LangChain:
- LangChain supplies LLM primitives (models, prompts, loaders).
- LangGraph handles orchestration and workflow structure.

LangGraph can be overkill for trivial linear flows, but it scales well for complex workflows requiring orchestration, state tracking, and multiple LLM interactions.
The stateful model makes it easy to preserve and inspect intermediate results across multiple steps — a practical advantage for multi-step prompt chains.
LangChain and LangGraph are complementary: LangChain for models & prompt tooling, LangGraph for nodes & orchestration.

Extend the prompt-chaining blog workflow by adding an Evaluate node that rates the generated blog (based on the outline) and produces an integer score. Update the state and graph accordingly.

The author created a desktop folder and Jupyter notebooks for each example (BMI workflow, simple LLM QA, prompt chaining).
A GitHub repo with the folder and notebooks is promised in the video description.
Visualization code snippets are taken from the LangGraph docs.

Speaker: Nitesh (YouTuber, presenter of the CampusX playlist)
Primary referenced projects/documents:
- LangGraph documentation and API
- LangChain library (ChatOpenAI and other LangChain components)
- OpenAI models (via API key / ChatOpenAI)