Das ReAct-Framework: Denken, Handeln, Beobachten
Sie verstehen die ReAct-Schleife, in der das Modell einen Thought erzeugt, eine Action auswählt, eine Observation erhält und dies wiederholt, bis es eine Final Answer erreicht.
Das ReAct-Framework: Denken, Handeln, Beobachten ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
What Is the ReAct Framework?
ReAct (Reasoning + Acting) is a prompting framework that interleaves the model's internal reasoning with external actions. Instead of producing a final answer immediately, the model generates a Thought, chooses an Action, receives an Observation from executing that action, and repeats the cycle until it can give a Final Answer.
The Think-Act-Observe Loop
Each iteration of the ReAct loop has three phases:
- Thought: The model reasons about what it knows and what it needs to find out next.
- Action: The model calls a tool — such as a web search, a calculator, or a database lookup.
- Observation: The result of the tool call is returned and appended to the model's context.
The loop continues until the model emits Final Answer: with its conclusion.
ReAct Trace Example
Here is a concrete trace of a ReAct agent answering 'What is the population of Tokyo?' using a search tool. Notice how each step builds on the previous observation.
# ReAct trace (pseudocode showing the reasoning loop)
# Iteration 1
Thought_1 = 'I need to find the current population of Tokyo. I will search for it.'
Action_1 = 'search("Tokyo population 2024")'
Observation_1 = 'According to the 2023 census, Tokyo has approximately 13.96 million people in the city proper.'
# Iteration 2
Thought_2 = 'I have the population. I can now give a final answer.'
Final_Answer = 'The population of Tokyo is approximately 13.96 million people.'Why ReAct Outperforms Direct Prompting
Direct prompting asks the model to answer from memory, leading to hallucinations on factual questions. Chain-of-thought prompting improves reasoning but still cannot access external information. ReAct combines both: explicit reasoning traces like chain-of-thought plus the ability to gather fresh information through tool calls.
ReAct Prompt Structure
The ReAct system prompt teaches the model the exact format to use. It lists available tools with their descriptions and shows examples of the Thought/Action/Observation/Final Answer pattern. The model learns to follow this format precisely from the prompt.
REACT_SYSTEM_PROMPT = '''You are an AI assistant with access to these tools:
- search(query: str): Search the web for up-to-date information.
- calculator(expression: str): Evaluate a mathematical expression.
- lookup(topic: str): Look up a topic in the knowledge base.
Always follow this exact format:
Thought: [your reasoning about what to do next]
Action: tool_name(arguments)
Observation: [result of the action, provided by the system]
... (repeat as needed)
Final Answer: [your final response to the user]
Begin!'''Parsing Thought, Action, and Observation
Your application code acts as the runtime for the ReAct loop. After each model response, parse the output to extract the action name and arguments, execute the corresponding Python function, format the result as an observation, append it to the message history, and call the model again.
import re
def parse_react_output(text: str):
'''Extract action name and argument from a ReAct model output.'''
action_match = re.search(r'Action:\s*(\w+)\((.*)\)', text)
if action_match:
tool_name = action_match.group(1)
tool_input = action_match.group(2).strip('\"\' ')
return tool_name, tool_input
if 'Final Answer:' in text:
answer = text.split('Final Answer:')[-1].strip()
return 'final', answer
return None, NoneThe Agent Execution Loop
The execution loop calls the LLM, parses its output, dispatches the tool, appends the observation, and loops. A max_iterations guard prevents infinite loops when the model cannot resolve a task.
from openai import OpenAI
client = OpenAI()
def run_react_agent(user_query: str, tools: dict, max_iterations: int = 10) -> str:
messages = [
{'role': 'system', 'content': REACT_SYSTEM_PROMPT},
{'role': 'user', 'content': user_query}
]
for i in range(max_iterations):
resp = client.chat.completions.create(model='gpt-4o', messages=messages)
output = resp.choices[0].message.content
messages.append({'role': 'assistant', 'content': output})
tool_name, tool_input = parse_react_output(output)
if tool_name == 'final':
return tool_input
if tool_name and tool_name in tools:
observation = tools[tool_name](tool_input)
messages.append({'role': 'user', 'content': f'Observation: {observation}'})
else:
messages.append({'role': 'user', 'content': 'Observation: Tool not found.'})
return 'Max iterations reached without a final answer.'Registering Simple Tools
Tools are just Python functions. You register them in a dictionary mapping tool name to function. The functions receive a string argument and return a string result — this keeps the interface simple and consistent with what the model expects to see as observations.
import math
def calculator_tool(expression: str) -> str:
try:
# Restrict to safe math expressions
allowed_names = {k: v for k, v in math.__dict__.items() if not k.startswith('_')}
result = eval(expression, {'__builtins__': {}}, allowed_names)
return str(result)
except Exception as e:
return f'Error: {e}'
def search_tool(query: str) -> str:
# Stub — replace with real web search API
return f'Top result for "{query}": [placeholder result]'
# Register tools
tools = {
'calculator': calculator_tool,
'search': search_tool
}Multi-Hop Reasoning with ReAct
ReAct shines on multi-hop questions that require chaining multiple pieces of information. For example: 'Who is the CEO of the company that makes GPT-4, and what year was that company founded?' The agent first searches for the CEO, then uses that result to look up the company's founding year — two separate tool calls chained by reasoning.
ReAct vs. Pure Chain-of-Thought
Chain-of-Thought (CoT) improves reasoning by having the model think step by step, but it cannot access external information. ReAct adds actions to CoT, letting the model fetch real data, run computations, and verify facts. The trade-off: ReAct is slower (multiple API calls) but far more accurate on tasks requiring current or specialized knowledge.
Debugging ReAct with Traces
When a ReAct agent produces the wrong answer, inspect the full Thought/Action/Observation trace. Common failure patterns include: the model inventing an observation instead of calling the tool, parsing errors that skip tool execution, and incorrect reasoning in the Thought step that leads to a wrong action choice.
- Log every message appended to the context
- Check that tool output was actually appended before the next model call
- Verify the action regex matches the model's output format
Quick Check
Test your understanding of the ReAct framework.
Lesson Recap
In this lesson you learned: ReAct interleaves Thought, Action, and Observation in a loop, your application code acts as the runtime that executes tools and appends observations, and max_iterations guards prevent infinite agent loops. Next up we learn to define custom tools so your agent can do exactly what your application needs.
Häufig gestellte Fragen
Ist die Lektion „Das ReAct-Framework: Denken, Handeln, Beobachten“ kostenlos?
Ja — der vollständige Text von „Das ReAct-Framework: Denken, Handeln, Beobachten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Das ReAct-Framework: Denken, Handeln, Beobachten“?
Sie verstehen die ReAct-Schleife, in der das Modell einen Thought erzeugt, eine Action auswählt, eine Observation erhält und dies wiederholt, bis es eine Final Answer erreicht. Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Engineering Academy zu starten?
Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Das ReAct-Framework: Denken, Handeln, Beobachten“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?
Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Das ReAct-Framework: Denken, Handeln, Beobachten
- Tools für Ihren Agenten definieren
- Einen ReAct-Agenten mit LangChain erstellen
- Fehler und Endlosschleifen von Agents behandeln