ReAct- en Plan-and-Execute-agents
Begrijp en implementeer geavanceerde agentarchitecturen die redeneren en handelen combineren om complexe taken te voltooien
ReAct- en Plan-and-Execute-agents is een gratis AI-agents met LangChain en autonome werkstromen-les op CoddyKit. Dit is les 1 van 6. 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 6 lessen.
Verder dan eenvoudige AI-agents
Welkom bij Geavanceerde agentarchitecturen! Tot nu toe heb je kennisgemaakt met eenvoudige agents en ketens in LangChain. Die zijn uitstekend geschikt voor rechttoe rechtaan taken.
Problemen uit de praktijk kunnen echter complex zijn. Vaak moeten agents redeneren, beslissingen nemen en meerdere stappen uitvoeren om een doel te bereiken. Daar komen geavanceerde architecturen van pas.
Kennismaken met ReAct-agents
Een krachtige geavanceerde architectuur is ReAct, een afkorting van Reasoning and Acting. Deze architectuur is geïnspireerd op de manier waarop mensen problemen oplossen.
- Redeneren: de agent denkt na over het probleem, de huidige toestand en wat de volgende stap moet zijn.
- Handelen: de agent voert vervolgens een actie uit, vaak door een hulpmiddel te gebruiken.
Dankzij deze cyclus kunnen agents zich dynamisch aanpassen en complexe taken oplossen.
De ReAct-lus: gedachte, actie, observatie
ReAct-agents werken in een herhalende lus:
- Gedachte: de agent genereert een gedachte waarin hij zijn redenering en geplande actie uitlegt.
- Actie: op basis van de gedachte kiest de agent een hulpmiddel en de invoer daarvoor (bijvoorbeeld 'zoeken' of 'rekenmachine').
- Observatie: de agent ontvangt het resultaat van de uitvoering van het hulpmiddel.
Deze lus gaat door totdat de agent denkt genoeg informatie te hebben om een definitief antwoord te geven.
ReAct in actie: een eenvoudige stroom
We bekijken een vereenvoudigd Python-voorbeeld van het mogelijke verloop van de logica van een ReAct-agent. Let erop hoe de agent denkt, handelt en observeert om tot een conclusie te komen.
def run_react_agent(query):
print(f"User Query: {query}")
print("Thought: I need to find the population of London. I will use a search tool.")
print("Action: Use 'search_tool' with query 'population of London'")
# Simulate tool output
observation = "Observation: The population of London is ~9 million (2023 est.)."
print(observation)
print("Thought: I have the information. I can now answer the user.")
print("Action: Respond with the observed information.")
return observation.replace("Observation: ", "")
if __name__ == "__main__":
result = run_react_agent("What is the population of London?")
print(f"\nFinal Answer: {result}")Plan-and-Execute begrijpen
Een andere krachtige architectuur is Plan-and-Execute. In tegenstelling tot ReAct, dat reactiever is, maken Plan-and-Execute-agents eerst een uitgebreid plan.
Ze zijn vooral effectief voor taken die complex zijn, uit meerdere stappen bestaan en waarbij vooraf een duidelijke volgorde van acties kan worden bepaald.
De onderdelen Planner en Executor
Plan-and-Execute-agents bestaan doorgaans uit twee hoofdonderdelen:
- De planner: dit onderdeel neemt het oorspronkelijke doel en splitst het op in een reeks kleinere, beheersbare stappen. De focus ligt op strategie.
- De uitvoerder: dit onderdeel neemt vervolgens elke stap uit het plan en voert die uit, vaak met behulp van specifieke hulpmiddelen. De focus ligt op uitvoering.
Door deze scheiding wordt complexiteit beter beheersbaar en is de aanpak gestructureerd.
Plan-and-Execute: een gestructureerde werkwijze
Hier ziet u een vereenvoudigd Python-voorbeeld dat de werkwijze van Plan-and-Execute laat zien. Let erop dat het doel eerst wordt gepland en dat daarna elke stap in de juiste volgorde wordt uitgevoerd.
def planner(goal):
print(f"Goal: {goal}")
print("Planner: Breaking down the goal into steps...")
plan = [
"Step 1: Find today's date.",
"Step 2: Get the weather forecast for New York City for today.",
"Step 3: Summarize the date and weather information."
]
print(f"Plan created: {plan}")
return plan
def executor(step):
print(f"Executing: {step}")
if "date" in step:
return "Observation: Today's date is October 26, 2023."
elif "weather" in step:
return "Observation: New York weather: Sunny, 60°F."
elif "summarize" in step:
return "Observation: Summary: Oct 26, 2023, NYC is Sunny, 60°F."
return "Observation: Step completed."
if __name__ == "__main__":
my_goal = "Tell me today's date and weather in New York City."
plan_steps = planner(my_goal)
print("\n--- Execution Phase ---")
for step in plan_steps:
res = executor(step)
print(res)ReAct versus Plan-and-Execute
Beide zijn krachtig, maar ze zijn geschikt voor verschillende situaties:
- ReAct: dynamischer en reactiever. Het meest geschikt voor taken waarvan de aanpak vooraf niet duidelijk is en waarbij verkenning en iteratieve besluitvorming nodig zijn, zoals complexe onderzoeksvragen.
- Plan-and-Execute: gestructureerder en systematischer. Het meest geschikt voor taken waarvoor een duidelijke reeks stappen kan worden vastgesteld, zoals het boeken van een vlucht met bekende stappen: zoeken, selecteren en bevestigen.
De juiste architectuur kiezen
Houd bij de keuze tussen ReAct en Plan-and-Execute rekening met het volgende:
- Taakcomplexiteit: gaat het om een duidelijke, opeenvolgende taak (Plan-and-Execute) of om een verkennende taak waarbij problemen moeten worden opgelost (ReAct)?
- Voorspelbaarheid: kunt u de benodigde stappen eenvoudig voorspellen (Plan-and-Execute), of moet de agent zich dynamisch aanpassen (ReAct)?
- Foutafhandeling: Plan-and-Execute is soms gemakkelijker te debuggen dankzij de vastgelegde stappen, terwijl het door de dynamische aard van ReAct moeilijker kan zijn om het verloop te traceren.
Korte controle: agentarchitecturen
Een AI-agent moet een complex probleem met meerdere stappen oplossen, waarbij de exacte volgorde van acties vooraf niet bekend is. De agent moet mogelijk verschillende opties verkennen en reageren op tussentijdse resultaten.
Samenvatting: geavanceerde agentarchitecturen
Goed gedaan! In deze les hebt u twee geavanceerde agentarchitecturen verkend:
- ReAct (Reasoning and Acting): agents die iteratief nadenken, handelen en observeren, en geschikt zijn voor dynamische, verkennende taken.
- Plan-and-Execute: agents die eerst een gedetailleerd plan maken en daarna elke stap uitvoeren, ideaal voor gestructureerde workflows met meerdere stappen.
Als u deze patronen begrijpt, kunt u robuustere en intelligentere AI-agents bouwen voor complexe uitdagingen. Hierna bekijken we agents die zichzelf kunnen corrigeren!
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 “ReAct- en Plan-and-Execute-agents” gratis?
Ja — de volledige tekst van “ReAct- en Plan-and-Execute-agents” 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 6 lessen.
Wat leer ik in “ReAct- en Plan-and-Execute-agents”?
Begrijp en implementeer geavanceerde agentarchitecturen die redeneren en handelen combineren om complexe taken te voltooien 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 1 van 6.
Hoe lang duurt de les “ReAct- en Plan-and-Execute-agents”?
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
- ReAct- en Plan-and-Execute-agents
- Hiërarchische agentontwerpen
- Zelfcorrigerende en reflecterende agents
- Cognitieve architecturen voor agents
- Patronen voor samenwerking tussen meerdere agents
- Hybride agentsystemen