Building Sequential Workflows with LangGraph

Sequential Workflows with LangGraph #

A sequential workflow is a linear architectural pattern where tasks are executed in a specific, one-after-another order. In LangGraph, these workflows are represented as a directed graph where control flows from a start point, through a series of nodes, to an end point without branching or parallel paths.

1. Prerequisites and Environment Setup #

To build a sequential workflow with LangGraph, you need LangGraph, LangChain, and an LLM provider. In this example, we will use Ollama with the Gemma 3 1B model, so you can run the LLM locally.

You can use different LLM providers such as OpenAI, Google Gemini, Anthropic, Ollama, and others. Just change the LLM configuration, model name, and required API or environment setup according to the provider you choose.

Install the required packages #

pip install langgraph langchain langchain-ollama

Make sure Ollama is installed and that the Gemma 3 1B model is available.

ollama pull gemma3:1b

2. The Five-Step Implementation Framework #

A basic LangGraph workflow can be understood through five fundamental steps:

1. Define the State
2. Create the Graph
3. Create and Add Nodes
4. Add Edges
5. Compile and Execute

Step 1: Define the State #

The State is the shared data structure that travels through the workflow. In Python, we can define it using TypedDict.

from typing import TypedDict

class State(TypedDict):
    topic: str
    explanation: str
    example: str
    summary: str

Here, the state contains four pieces of information:

• topic – The topic provided by the user.
• explanation – Explanation generated by the LLM.
• example – Example generated from the explanation.
• summary – Final summary generated by the LLM.

Step 2: Create the Graph #

We create a StateGraph using our state definition.

from langgraph.graph import StateGraph, START, END

graph = StateGraph(State)

Step 3: Create and Add Nodes #

A node is a Python function that performs a specific task. Each node receives the current state and returns an update to it.

In our example, we have three nodes:

• Explain – Explains the topic.
• Example – Generates a real-world example.
• Summary – Creates a final summary.

Step 4: Add Edges #

Edges determine the order in which nodes execute.

graph.add_edge(START, "explain")
graph.add_edge("explain", "example")
graph.add_edge("example", "summary")
graph.add_edge("summary", END)

Step 5: Compile and Execute #

After defining the graph, we compile it and execute it using invoke().

app = graph.compile()

result = app.invoke({
    "topic": "Machine Learning"
})

3. Practical Example: Sequential AI Workflow #

Now let’s build a complete sequential workflow using LangGraph + Ollama + Gemma 3.

Complete Code #

from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langchain_ollama import ChatOllama


# 1. Create LLM
llm = ChatOllama(model="gemma3:1b")


# 2. Define State
class State(TypedDict):
    topic: str
    explanation: str
    example: str
    summary: str


# 3. Node 1 - Explain topic
def explain_topic(state: State):

    topic = state["topic"]

    res = llm.invoke(
        f"Explain {topic} in very simple language."
    )

    return {
        "explanation": res.content
    }


# 4. Node 2 - Create example
def example(state: State):

    explanation = state["explanation"]

    res = llm.invoke(
        f"Give a simple real-world example of this explanation:\n{explanation}"
    )

    return {
        "example": res.content
    }


# 5. Node 3 - Create summary
def summary(state: State):

    explanation = state["explanation"]
    example_text = state["example"]

    res = llm.invoke(
        f"""
        Create a short summary using:

        Explanation:
        {explanation}

        Example:
        {example_text}
        """
    )

    return {
        "summary": res.content
    }


# 6. Create Graph
graph = StateGraph(State)


# 7. Add Nodes
graph.add_node("explain", explain_topic)
graph.add_node("example", example)
graph.add_node("summary", summary)


# 8. Connect Nodes
graph.add_edge(START, "explain")
graph.add_edge("explain", "example")
graph.add_edge("example", "summary")
graph.add_edge("summary", END)


# 9. Compile
app = graph.compile()


# 10. Run
result = app.invoke({
    "topic": "Machine Learning"
})


# 11. Print result
print(result["summary"])

4. How This Workflow Works #

When we execute the workflow, the input first enters the Explain node.

5. Understanding State Flow #

The most important concept in this example is how the state changes as it moves through each node.

{
    "topic": "Machine Learning"
}

{
    "topic": "Machine Learning",
    "explanation": "..."
}

{
    "topic": "Machine Learning",
    "explanation": "...",
    "example": "..."
}

{
    "topic": "Machine Learning",
    "explanation": "...",
    "example": "...",
    "summary": "..."
}

6. Graph Structure #

The final LangGraph workflow is a simple linear sequence:

7. Key Advantages of Sequential Workflows #

• Simple Flow: Tasks execute in a predictable order.
• Shared State: Every node can access information stored in the state.
• LLM Integration: Each node can use an LLM for a different task.
• Modular Design: Each task is separated into its own node.
• Easy to Extend: Additional nodes can be added to the workflow.

8. Important LangGraph Concepts #