	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > LangGraph > LangGraph Subgraphs and Modular Agent Design

LangGraph Subgraphs and Modular Agent Design

Author: Venkata Sudhakar

LangGraph subgraphs let you decompose a complex agent into self-contained modules, each with its own state and nodes. The parent graph treats each subgraph as a single node, calling it as a black box. For ShopMax India, you might build separate subgraphs for order lookup, product recommendation, and complaint handling, then wire them together in a routing parent graph.

A subgraph is simply a compiled StateGraph that is added to the parent graph using add_node. The parent passes its state into the subgraph, which processes it and returns an updated state. The key requirement is that the subgraph's input and output state schema must be compatible with the parent's state schema - shared keys are passed through automatically.

The following example shows a parent graph with two subgraphs: one that looks up order status and one that handles refund requests for ShopMax India customers.

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class SharedState(TypedDict):
    query: str
    result: str
    intent: str

# Subgraph 1: Order status lookup
def order_lookup_node(state: SharedState) -> SharedState:
    order_id = state["query"].split()[-1]
    return {"result": f"Order {order_id} is out for delivery in Bangalore. ETA: 2 hours."}

order_graph = StateGraph(SharedState)
order_graph.add_node("lookup", order_lookup_node)
order_graph.set_entry_point("lookup")
order_graph.add_edge("lookup", END)
order_subgraph = order_graph.compile()

# Subgraph 2: Refund handler
def refund_node(state: SharedState) -> SharedState:
    return {"result": "Refund of Rs 2,499 initiated. It will reflect in your account within 5-7 business days."}

refund_graph = StateGraph(SharedState)
refund_graph.add_node("process", refund_node)
refund_graph.set_entry_point("process")
refund_graph.add_edge("process", END)
refund_subgraph = refund_graph.compile()

# Parent graph with routing
def router(state: SharedState) -> str:
    if "refund" in state["query"].lower():
        return "refund"
    return "order"

parent = StateGraph(SharedState)
parent.add_node("order", order_subgraph)
parent.add_node("refund", refund_subgraph)
parent.set_conditional_entry_point(router, {"order": "order", "refund": "refund"})
parent.add_edge("order", END)
parent.add_edge("refund", END)
app = parent.compile()

result = app.invoke({"query": "Track my order SM-99021", "result": "", "intent": ""})
print(result["result"])

result2 = app.invoke({"query": "I want a refund for my damaged product", "result": "", "intent": ""})
print(result2["result"])

It gives the following output,

Order SM-99021 is out for delivery in Bangalore. ETA: 2 hours.
Refund of Rs 2,499 initiated. It will reflect in your account within 5-7 business days.

Subgraphs are reusable - you can include the same compiled subgraph in multiple parent graphs. Each subgraph can also have its own checkpointer for independent persistence. This modular design makes ShopMax India's agent system easier to test in isolation, update independently, and scale by running subgraphs in parallel when needed.

Send your comments, suggestions or queries regarding this site to [email protected].