LangGraph Core Concepts | Agentic AI using LangGraph | Video 4 | CampusX

Summary of technological concepts & key features (LangGraph Core Concepts – Video 4)

LangGraph is an orchestration framework for building intelligent, stateful, multi-step LLM workflows. It represents an LLM workflow as a graph:

• Nodes = tasks/subtasks (e.g., call an LLM, call a tool, make a decision)
• Edges = execution flow control (what runs next after a node)

Additional built-in capabilities highlighted

• Parallel execution: multiple nodes can run at the same time.
• Loops: return to previous nodes for iterative behavior.
• Branching / conditional routing: execution can go down different paths based on conditions.
• Memory/state support: records tasks and conversation/data produced during the run.
• Resumability: if a workflow breaks mid-way, it can resume from the failure point.

Core concept 1: LLM Workflows

An LLM workflow is a sequence of tasks aimed at a goal, where some tasks depend on LLMs. Typical workflow steps include:

• prompting
• reasoning
• tool calling
• memory access
• decision making

Workflow structure can be:

• Linear
• Parallel
• Branched
• Looped

This makes it suitable for behaviors like:

• multi-agent communication
• tool-augmented reasoning

Common LLM workflow patterns covered (with examples)

1. Prompt/Process Chaining

   • Call the LLM multiple times in sequence
   • Example: generate an outline first, then generate a detailed report from that outline
   • Includes intermediate validation checks (e.g., stop if the report exceeds 5000 words)

2. Routing

   • An LLM acts as a decision maker to select the most suitable specialized LLM
   • Example: a customer support bot routes by query type (refund vs technical vs sales)

3. Parallelization

   • Split a task into multiple subtasks, run them concurrently, then merge results
   • Example: YouTube-style content moderation
     • check community guidelines, misinformation, and sexual content in parallel
     • aggregate outcomes to decide publish vs flag

4. Orchestrator-Worker

   • Similar to parallelization, but the subtasks are chosen dynamically
   • Example: a research assistant selects workers/tasks depending on:
     • scientific queries → Google Scholar
     • news/politics → Google News

5. Evaluator-Optimizer

   • Iterative generation using:
     • a generator LLM
     • an evaluator LLM
   • The evaluator checks output against explicit criteria:
     • accept (stop loop) or reject with feedback
   • The generator uses feedback to create a new draft; repeat until accepted
   • Mentioned: loops are covered later and this workflow is demonstrated after.

Core concept 2: Graphs, Vertices, and Edges

LangGraph models workflows as graphs:

• Nodes represent Python functions implementing tasks
• Edges define execution order/type:
  • sequential
  • parallel
  • conditional
  • looped connections

Example used: UPSC essay practice workflow

A workflow might include:

• generate topic → collect essay
• evaluate via multiple criteria → compute normalized score
• compare score to a threshold:
  • if above: congratulate and end
  • else: provide feedback and optionally let the user rewrite (loop)

Core concept 3: State

State is shared, evolving data used during workflow execution. It typically contains key-value pairs such as:

• user/essay text
• topic
• per-criterion scores (e.g., clarity, depth, language/grammar)
• overall score

Key properties:

• accessible to every node during execution
• mutable (nodes can update it)

In code, state is defined as a Python Typed Dictionary (or optionally via Pydantic objects), acting as a typed container for workflow data.

Core concept 4: Reducers (how state updates are applied)

Because state is mutable and shared, multiple nodes may update the same keys. Reducers define how those updates are merged, such as:

• replace vs add vs merge

Why reducers matter (example)

• In simple arithmetic, overwriting a result key is usually safe.
• In a chatbot, overwriting the message state would erase prior context and break conversation continuity.
• The correct approach is to use reducer logic to accumulate/append messages over time.

Reducers for iteration/history

Example: a student writes multiple essay drafts.

• Replacing the essay text would lose earlier drafts.
• A reducer could append each new draft so progress/history is preserved.

Reducers become especially important for parallel workflows, where merging rules strongly affect correctness.

Execution model (how LangGraph runs workflows internally)

The execution model is inspired by Google Prolog (described as the basis for its graph processing execution model).

Workflow lifecycle

1. Graph definition
   • define nodes, edges, and typed state
2. Compile
   • validates graph structure (e.g., checks for inconsistencies like “orphan” nodes)
3. Execution (invocation)
   • pass initial state to the first node
   • nodes execute their Python functions, produce partial state updates
   • updated state is propagated via message passing

Supersteps and termination

Execution proceeds in rounds called supersteps:

• a superstep can include parallel node executions
• hence “superstep” instead of “step”

Termination occurs when there are:

• no active nodes
• no messages being passed along edges

Main speaker/source

• Nitesh (creator/host), explaining LangGraph concepts in the “CampusX” style tutorial/podcast series.