AI Agents with LangChain & Autonomous Workflows · Lesson

Sequential & Simple Chains

Learn to construct basic chains for ordered execution of tasks, passing outputs from one step as inputs to the next.

Sequential & Simple Chains is a free AI Agents with LangChain & Autonomous Workflows lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the AI Agents with LangChain & Autonomous Workflows learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Chains: Steps in Order

In LangChain, chains allow you to combine multiple Large Language Model (LLM) calls and other utilities into a single, coherent application.

Think of them as a series of steps where the output of one step becomes the input for the next. This creates a powerful, automated workflow.

Sequential Chains are a specific type designed for tasks that require a strict, ordered execution of steps.

Meet the LLMChain

Before we build complex sequential chains, let's look at the basic building block: the LLMChain.

An LLMChain combines an LLM (like GPT-4) with a PromptTemplate. It takes an input, formats it using the template, sends it to the LLM, and returns the LLM's response.

LLM: The language model that generates text.
PromptTemplate: Defines how user input is structured for the LLM.

Running a Single LLMChain

Here's how you can create and run a simple LLMChain. We'll ask it to suggest a catchy name for a new tech product.

Notice how the PromptTemplate defines what we expect the LLM to do, and the chain executes it.

import os
from langchain.chains import LLMChain
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

# IMPORTANT: Set your OpenAI API key as an environment variable
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY_HERE"
# For local testing, ensure it's set before running.

def main():
    # 1. Define the LLM
    llm = ChatOpenAI(temperature=0.7)

    # 2. Define the Prompt Template
    prompt_template = PromptTemplate(
        input_variables=["product_type"],
        template="Suggest a catchy name for a new {product_type}."
    )

    # 3. Create the LLMChain
    name_chain = LLMChain(llm=llm, prompt=prompt_template)

    # 4. Run the chain
    result = name_chain.invoke({"product_type": "AI assistant"})
    print(f"Suggested Name: {result['text']}")

if __name__ == "__main__":
    main()

Introducing SimpleSequentialChain

What if you need to perform multiple steps, where each step builds on the previous one? That's where SimpleSequentialChain comes in.

It takes a list of chains and executes them in order. The single output from the first chain becomes the single input for the second chain, and so on.

It's ideal for straightforward, linear workflows.

Input-Output Flow

SimpleSequentialChain manages the flow automatically:

You provide an initial input to the first chain.
The first chain processes it and produces an output.
This output automatically becomes the input for the second chain.
This continues until the last chain, whose output is the final result of the SimpleSequentialChain.

It's like an assembly line for AI tasks!

First Step: Name Generation

Let's build a two-step sequential chain. Our first step will be to generate a product name, similar to our previous LLMChain example.

We define an LLMChain for this purpose. We'll make sure its output is clearly defined using output_key for the next step.

import os
from langchain.chains import LLMChain
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

# IMPORTANT: Set your OpenAI API key as an environment variable
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY_HERE"

def main():
    llm = ChatOpenAI(temperature=0.7)

    # Chain 1: Generate a product name
    prompt_name = PromptTemplate(
        input_variables=["product_type"],
        template="Suggest a catchy, short name for a new {product_type}. Response should only be the name."
    )
    chain_name = LLMChain(llm=llm, prompt=prompt_name, output_key="product_name")

    # This chain will output a dictionary like {'product_type': '...', 'product_name': '...'}
    # The 'product_name' will be passed to the next chain.
    result = chain_name.invoke({"product_type": "smartwatch"})
    print(f"Input: {result['product_type']}")
    print(f"Output (product_name): {result['product_name']}")

if __name__ == "__main__":
    main()

Second Step: Slogan Generation

Now, let's create the second LLMChain. This chain will take the product_name generated by the first chain and create a slogan for it.

Notice how its input_variables matches the output_key from the previous chain. This is how SimpleSequentialChain knows how to connect them.

import os
from langchain.chains import LLMChain
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

# IMPORTANT: Set your OpenAI API key as an environment variable
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY_HERE"

def main():
    llm = ChatOpenAI(temperature=0.7)

    # Chain 2: Generate a slogan based on the product name
    prompt_slogan = PromptTemplate(
        input_variables=["product_name"],
        template="Write a creative slogan for a product named {product_name}. Response should only be the slogan."
    )
    chain_slogan = LLMChain(llm=llm, prompt=prompt_slogan, output_key="slogan")

    # Example of running this chain independently
    result = chain_slogan.invoke({"product_name": "ChronoMind"})
    print(f"Input: {result['product_name']}")
    print(f"Output (slogan): {result['slogan']}")

if __name__ == "__main__":
    main()

Putting Chains Together

Finally, we combine our two LLMChains into a SimpleSequentialChain. We pass the initial input to the overall sequential chain, and it handles the rest!

We'll also set verbose=True to see the intermediate steps, which is great for debugging.

import os
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

# IMPORTANT: Set your OpenAI API key as an environment variable
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY_HERE"

def main():
    llm = ChatOpenAI(temperature=0.7)

    # Chain 1: Generate a product name
    prompt_name = PromptTemplate(
        input_variables=["product_type"],
        template="Suggest a catchy, short name for a new {product_type}. Response should only be the name."
    )
    chain_name = LLMChain(llm=llm, prompt=prompt_name, output_key="product_name")

    # Chain 2: Generate a slogan
    prompt_slogan = PromptTemplate(
        input_variables=["product_name"],
        template="Write a creative slogan for a product named {product_name}. Response should only be the slogan."
    )
    chain_slogan = LLMChain(llm=llm, prompt=prompt_slogan, output_key="slogan")

    # Combine into a SimpleSequentialChain
    overall_chain = SimpleSequentialChain(
        chains=[chain_name, chain_slogan],
        verbose=True # Set to True to see intermediate steps
    )

    # Run the overall chain with the initial input
    final_result = overall_chain.invoke({"product_type": "AI-powered coffee maker"})
    print("\n--- Final Result ---")
    print(f"Product Slogan: {final_result['slogan']}")

if __name__ == "__main__":
    main()

Tracing Chain Execution

When verbose=True, LangChain prints out the steps taken by your chain. This is incredibly useful for:

Understanding how inputs and outputs flow.
Debugging unexpected results.
Seeing which prompts are sent to the LLM.

It helps you visualize the 'assembly line' in action and ensures each step performs as expected.

Quick Chain Check

Consider a SimpleSequentialChain with three LLMChains: Chain A, Chain B, and Chain C, in that order.

Chain A has output_key='topic'.
Chain B has input_variables=['topic'] and output_key='outline'.
Chain C has input_variables=['outline'].

If the SimpleSequentialChain is invoked with {'initial_input': 'AI agents'}, which statement is true?

Recap: Simple Sequential Chains

Great job! In this lesson, you learned about:

The basic LLMChain as a building block.
How SimpleSequentialChain links multiple chains together.
Passing outputs from one step as inputs to the next.
Using output_key and input_variables for flow.
Debugging chains with verbose=True.

Next, you'll discover how to customize chain logic and integrate your own Python functions within LangChain workflows!

Frequently asked questions

Is the “Sequential & Simple Chains” lesson free?

Yes — the full text of “Sequential & Simple Chains” is free to read here on the web, and the AI Agents with LangChain & Autonomous Workflows course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the AI Agents with LangChain & Autonomous Workflows course, upgrade to CoddyKit PRO.

What will I learn in “Sequential & Simple Chains”?

Learn to construct basic chains for ordered execution of tasks, passing outputs from one step as inputs to the next. You practise AI Agents with LangChain & Autonomous Workflows with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start AI Agents with LangChain & Autonomous Workflows?

No prior experience is required. AI Agents with LangChain & Autonomous Workflows on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Sequential & Simple Chains” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this AI Agents with LangChain & Autonomous Workflows lesson?

Yes. Every AI Agents with LangChain & Autonomous Workflows lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to AI Agents with LangChain & Autonomous Workflows