AI Agents with LangChain & Autonomous Workflows · Ders

Sıralı ve Basit Zincirler

Görevleri sırayla yürütmek ve bir adımın çıktılarını sonraki adıma girdi olarak aktarmak için temel zincirler oluşturmayı öğrenin.

Sıralı ve Basit Zincirler, CoddyKit'te ücretsiz bir AI Agents with LangChain & Autonomous Workflows dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, AI Agents with LangChain & Autonomous Workflows öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. AI Agents with LangChain & Autonomous Workflows kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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!

Sıkça Sorulan Sorular

“Sıralı ve Basit Zincirler” dersi ücretsiz mi?

Evet — “Sıralı ve Basit Zincirler” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve AI Agents with LangChain & Autonomous Workflows kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. AI Agents with LangChain & Autonomous Workflows kursu toplamda 4 dersten oluşur.

“Sıralı ve Basit Zincirler” dersinde ne öğreneceğim?

Görevleri sırayla yürütmek ve bir adımın çıktılarını sonraki adıma girdi olarak aktarmak için temel zincirler oluşturmayı öğrenin. AI Agents with LangChain & Autonomous Workflows ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

AI Agents with LangChain & Autonomous Workflows öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te AI Agents with LangChain & Autonomous Workflows, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Sıralı ve Basit Zincirler” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu AI Agents with LangChain & Autonomous Workflows dersinde kod yazıp çalıştırabilir miyim?

Evet. Her AI Agents with LangChain & Autonomous Workflows dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← AI Agents with LangChain & Autonomous Workflows Sayfasına Dön