Sequentiële en eenvoudige chains
Leer basischains bouwen voor het geordend uitvoeren van taken, waarbij u uitvoer van de ene stap als invoer voor de volgende doorgeeft
Sequentiële en eenvoudige chains is een gratis AI-agents met LangChain en autonome werkstromen-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-agents met LangChain en autonome werkstromen. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-agents met LangChain en autonome werkstromen bevat in totaal 4 lessen.
Ketens: stappen in volgorde
In LangChain kun je met ketens meerdere aanroepen van Large Language Models (LLM's) en andere hulpmiddelen combineren tot één samenhangende toepassing.
Zie ze als een reeks stappen waarbij de uitvoer van de ene stap de invoer voor de volgende wordt. Zo ontstaat een krachtige, geautomatiseerde werkstroom.
Opeenvolgende ketens zijn een specifiek type dat is ontworpen voor taken waarvoor stappen strikt in een vaste volgorde moeten worden uitgevoerd.
Maak kennis met LLMChain
Voordat we complexe sequentiële ketens bouwen, bekijken we eerst het basisbouwblok: de LLMChain.
Een LLMChain combineert een LLM (zoals GPT-4) met een PromptTemplate. De keten neemt invoer aan, formatteert die met behulp van de sjabloon, stuurt die naar de LLM en retourneert de reactie van de LLM.
- LLM: Het taalmodel dat tekst genereert.
- PromptTemplate: Bepaalt hoe invoer van de gebruiker voor de LLM wordt gestructureerd.
Eén <code>LLMChain</code> uitvoeren
Zo maak en voer je een eenvoudige LLMChain uit. We vragen de keten om een pakkende naam voor een nieuw technologieproduct te bedenken.
Let op hoe de PromptTemplate bepaalt wat we van de LLM verwachten en hoe de keten dit uitvoert.
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()Kennismaken met <code>SimpleSequentialChain</code>
Wat doe je als je meerdere stappen moet uitvoeren, waarbij elke stap voortbouwt op de vorige? Daar komt SimpleSequentialChain van pas.
Deze neemt een lijst met ketens aan en voert ze in de juiste volgorde uit. De enkele uitvoer van de eerste keten wordt de enkele invoer voor de tweede keten, enzovoort.
Dit is ideaal voor eenvoudige, lineaire werkstromen.
Stroom van invoer en uitvoer
SimpleSequentialChain beheert de stroom automatisch:
- Je geeft een initiële invoer aan de eerste keten.
- De eerste keten verwerkt die en produceert uitvoer.
- Deze uitvoer wordt automatisch de invoer voor de tweede keten.
- Dit gaat door tot de laatste keten, waarvan de uitvoer het eindresultaat van
SimpleSequentialChainis.
Het lijkt op een lopende band voor AI-taken!
Eerste stap: naam genereren
We bouwen een sequentiële keten met twee stappen. In onze eerste stap genereren we een productnaam, vergelijkbaar met ons vorige voorbeeld met LLMChain.
Hiervoor definiëren we een LLMChain. We zorgen ervoor dat de uitvoer duidelijk wordt vastgelegd met output_key voor de volgende stap.
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()Tweede stap: slogan genereren
Nu maken we de tweede LLMChain. Deze keten neemt de product_name die door de eerste keten is gegenereerd en maakt daar een slogan voor.
Let op hoe de input_variables overeenkomen met de output_key van de vorige keten. Zo weet SimpleSequentialChain hoe de ketens met elkaar moeten worden verbonden.
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()Ketens samenvoegen
Tot slot combineren we onze twee LLMChain-objecten in een SimpleSequentialChain. We geven de initiële invoer door aan de volledige sequentiële keten en die handelt de rest af!
We stellen ook verbose=True in om de tussenstappen te bekijken. Dat is handig voor foutopsporing.
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()Uitvoering van een keten traceren
Wanneer verbose=True is ingesteld, drukt LangChain de stappen af die je keten uitvoert. Dit is bijzonder nuttig voor:
- Begrijpen hoe invoer en uitvoer door de keten stromen.
- Foutopsporing bij onverwachte resultaten.
- Bekijken welke prompts naar de LLM worden gestuurd.
Zo kun je de 'lopende band' in actie visualiseren en controleren of elke stap werkt zoals verwacht.
Snelle controle van de keten
Bekijk een SimpleSequentialChain met drie LLMChain-objecten: Chain A, Chain B en Chain C, in die volgorde.
Chain A heeft output_key='topic'.
Chain B heeft input_variables=['topic'] en output_key='outline'.
Chain C heeft input_variables=['outline'].
Als SimpleSequentialChain wordt aangeroepen met {'initial_input': 'AI agents'}, welke bewering is dan juist?
Samenvatting: eenvoudige sequentiële ketens
Goed gedaan! In deze les heb je geleerd over:
- De basis-
LLMChainals bouwblok. - Hoe
SimpleSequentialChainmeerdere ketens met elkaar verbindt. - Uitvoer van de ene stap doorgeven als invoer voor de volgende.
output_keyeninput_variablesgebruiken voor de gegevensstroom.- Ketens foutopsporen met
verbose=True.
Vervolgens ontdek je hoe je ketenlogica aanpast en je eigen Python-functies integreert in LangChain-werkstromen!
Leer AI-agents met LangChain en autonome werkstromen met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 50
Veelgestelde vragen
Is de les “Sequentiële en eenvoudige chains” gratis?
Ja — de volledige tekst van “Sequentiële en eenvoudige chains” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus AI-agents met LangChain en autonome werkstromen wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus AI-agents met LangChain en autonome werkstromen bevat in totaal 4 lessen.
Wat leer ik in “Sequentiële en eenvoudige chains”?
Leer basischains bouwen voor het geordend uitvoeren van taken, waarbij u uitvoer van de ene stap als invoer voor de volgende doorgeeft Je oefent met AI-agents met LangChain en autonome werkstromen door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met AI-agents met LangChain en autonome werkstromen te beginnen?
Ervaring vooraf is niet nodig. AI-agents met LangChain en autonome werkstromen op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Sequentiële en eenvoudige chains”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over AI-agents met LangChain en autonome werkstromen?
Ja. Elke les over AI-agents met LangChain en autonome werkstromen bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Inleiding tot LangChain Chains
- Sequentiële en eenvoudige chains
- Chainlogica aanpassen
- Routing en conditionele chains