Kurs Python · Moduł 10: AI i modele językowe
ReAct Agents - Reasoning and Acting
W tej lekcji7
Witaj! Darwin tutaj. Zapytaj zwykły model: "Jaka jest pogoda w Serengeti i jakie zwierzęta tam żyją?". Odpowie gładko, ale pogodę zmyśli, bo nie ma dostępu do żadnej stacji meteo. W poprzednich lekcjach daliśmy modelowi narzędzia. Teraz nauczymy go z nich korzystać krok po kroku, jak tropiciel, który najpierw myśli, potem idzie po śladach, a na końcu ocenia, co znalazł.
ReAct (Reasoning and Acting) to wzorzec projektowy dla agentów AI, który łączy rozumowanie z podejmowaniem akcji. Agent na przemian "myśli" (reasoning) i "działa" (acting), co prowadzi do lepszych rezultatów! Wzorzec opisali badacze z Princeton i Google w pracy "ReAct: Synergizing Reasoning and Acting in Language Models" z 2022 roku.
Czym jest ReAct?
ReAct to paradygmat, w którym agent AI:
- Thought - analizuje sytuację, planuje
- Action - wykonuje akcję (np. wywołuje narzędzie)
- Observation - obserwuje wynik akcji
- Repeat - powtarza cykl aż do rozwiązania
Pętla kręci się, aż agent uzna, że ma dość informacji. Na dole schematu widać zapis jednej wyprawy:
┌─────────────────────────────────────────────────────────┐
│ ReAct Loop │
├─────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌──────────┐ ┌─────────────┐ │
│ │ Thought │───▶│ Action │───▶│ Observation │ │
│ │ (Myśl) │ │ (Działaj)│ │ (Obserwuj) │ │
│ └──────────┘ └──────────┘ └──────┬──────┘ │
│ ▲ │ │
│ └──────────────────────────────────┘ │
│ (Repeat) │
│ │
│ Przykład: │
│ Thought: Muszę sprawdzić pogodę w Serengeti │
│ Action: get_weather("Serengeti") │
│ Observation: Temperatura 28°C, słonecznie │
│ Thought: Teraz mogę odpowiedzieć użytkownikowi │
│ Action: final_answer("Pogoda w Serengeti...") │
│ │
└─────────────────────────────────────────────────────────┘Kluczowa jest Observation: model nie zgaduje wyniku akcji, tylko dostaje prawdziwą odpowiedź narzędzia.
Podstawowa implementacja ReAct
Klasa ReActAgent przechowuje słownik narzędzi, limit iteracji i historię kroków. System prompt wstawia opisy narzędzi, biorąc je z docstringów funkcji (func.__doc__), i uczy model formatu Thought/Action/Answer:
from openai import OpenAI
from typing import Callable
import json
import re
client = OpenAI()
class ReActAgent:
"""Agent implementujący wzorzec ReAct."""
def __init__(self, tools: dict[str, Callable], max_iterations: int = 10):
self.tools = tools
self.max_iterations = max_iterations
self.history: list[str] = []
def _create_system_prompt(self) -> str:
"""Tworzy system prompt z opisem narzędzi."""
tool_descriptions = "\n".join([
f"- {name}: {func.__doc__}"
for name, func in self.tools.items()
])
return f"""Jesteś pomocnym asystentem Safari, który rozwiązuje problemy krok po kroku.
Dostępne narzędzia:
{tool_descriptions}
Używaj formatu:
Thought: [twoje rozumowanie o tym, co robić dalej]
Action: [nazwa_narzędzia(argumenty)]
Gdy masz wystarczające informacje, aby odpowiedzieć:
Thought: [rozumowanie końcowe]
Answer: [twoja odpowiedź dla użytkownika]
Zawsze myśl przed działaniem. Analizuj obserwacje zanim podejmiesz kolejny krok."""Limit max_iterations to bezpiecznik: bez niego agent, który się zapętli, zużywałby tokeny bez końca.
Parser wyciąga trzy fragmenty wyrażeniami regularnymi z modułu re. Flaga re.DOTALL pozwala kropce obejmować także znaki nowej linii:
def _parse_response(self, response: str) -> tuple[str, str, str]:
"""Parsuje odpowiedź na thought, action i answer."""
thought_match = re.search(r'Thought:\s*(.+?)(?=Action:|Answer:|$)', response, re.DOTALL)
action_match = re.search(r'Action:\s*(.+?)(?=Thought:|Observation:|Answer:|$)', response, re.DOTALL)
answer_match = re.search(r'Answer:\s*(.+)', response, re.DOTALL)
thought = thought_match.group(1).strip() if thought_match else ""
action = action_match.group(1).strip() if action_match else ""
answer = answer_match.group(1).strip() if answer_match else ""
return thought, action, answerBrak dopasowania nie rzuca wyjątku, tylko zwraca pusty napis.
Wykonanie akcji zamienia tekst w stylu get_weather("Serengeti") na wywołanie prawdziwej funkcji:
def _execute_action(self, action_str: str) -> str:
"""Wykonuje akcję i zwraca obserwację."""
# Parsuj nazwę funkcji i argumenty
match = re.match(r'(\w+)\((.*)\)', action_str)
if not match:
return f"Błąd: Nieprawidłowy format akcji: {action_str}"
func_name = match.group(1)
args_str = match.group(2)
if func_name not in self.tools:
return f"Błąd: Nieznane narzędzie: {func_name}"
try:
# Proste parsowanie argumentów
if args_str:
args = [arg.strip().strip('"').strip("'") for arg in args_str.split(',')]
result = self.tools[func_name](*args)
else:
result = self.tools[func_name]()
return str(result)
except Exception as e:
return f"Błąd wykonania: {str(e)}"Każdy błąd wraca do modelu jako tekst obserwacji, zamiast przerywać program. Parsowanie argumentów przez split(',') jest celowo proste i zepsuje się na przecinku wewnątrz napisu - w produkcji lepiej użyć natywnego function calling, który pokażę niżej.
Metoda run spina wszystko w pętlę:
def run(self, query: str) -> str:
"""Uruchamia agenta ReAct."""
self.history = [f"User: {query}"]
for i in range(self.max_iterations):
# Buduj kontekst
context = "\n".join(self.history)
# Wywołaj LLM
response = client.chat.completions.create(
model="gpt-4.1-mini",
messages=[
{"role": "system", "content": self._create_system_prompt()},
{"role": "user", "content": context}
],
temperature=0
)
llm_response = response.choices[0].message.content
thought, action, answer = self._parse_response(llm_response)
# Zapisz thought
if thought:
self.history.append(f"Thought: {thought}")
print(f"Thought: {thought}")
# Jeśli jest odpowiedź końcowa
if answer:
print(f"Answer: {answer}")
return answer
# Wykonaj akcję
if action:
self.history.append(f"Action: {action}")
print(f"Action: {action}")
observation = self._execute_action(action)
self.history.append(f"Observation: {observation}")
print(f"Observation: {observation}")
return "Przekroczono limit iteracji bez znalezienia odpowiedzi."Każdy obrót dopisuje myśl, akcję i obserwację do history, a przy następnym wywołaniu model dostaje całą historię. temperature=0 daje możliwie powtarzalne decyzje, dlatego wybrałem gpt-4.1-mini - modele rozumujące, takie jak gpt-5-mini, przyjmują tylko domyślną temperaturę.
Przykład użycia ReAct
Narzędzia to zwykłe funkcje z docstringami. Tu zwracają dane na sztywno, w prawdziwej aplikacji wywołałyby API pogodowe czy bazę gatunków:
# Definicja narzędzi
def get_weather(location: str) -> str:
"""Pobiera aktualną pogodę dla danej lokalizacji."""
weather_data = {
"Serengeti": "28°C, słonecznie, wilgotność 45%",
"Kilimandżaro": "5°C, pochmurnie, śnieg na szczycie",
"Nairobi": "22°C, częściowe zachmurzenie"
}
return weather_data.get(location, f"Brak danych pogodowych dla {location}")
def search_animals(query: str) -> str:
"""Wyszukuje informacje o zwierzętach Safari."""
animals = {
"lew": "Panthera leo - największy kot Afryki, żyje w stadach",
"słoń": "Loxodonta africana - największe zwierzę lądowe, żyje 60-70 lat",
"żyrafa": "Giraffa camelopardalis - najwyższe zwierzę świata, do 5.5m wysokości"
}
for key, value in animals.items():
if key in query.lower():
return value
return f"Nie znaleziono informacji o: {query}"
def calculate_distance(from_loc: str, to_loc: str) -> str:
"""Oblicza odległość między lokalizacjami Safari."""
distances = {
("Nairobi", "Serengeti"): 350,
("Serengeti", "Kilimandżaro"): 280,
("Nairobi", "Kilimandżaro"): 200
}
key = (from_loc, to_loc)
reverse_key = (to_loc, from_loc)
if key in distances:
return f"{distances[key]} km"
elif reverse_key in distances:
return f"{distances[reverse_key]} km"
return f"Nieznana odległość między {from_loc} a {to_loc}"Docstring nie jest ozdobą: trafia do system promptu i to na jego podstawie model decyduje, którego narzędzia użyć.
Teraz rejestrujemy narzędzia i wysyłamy agenta w teren:
# Utworzenie agenta
tools = {
"get_weather": get_weather,
"search_animals": search_animals,
"calculate_distance": calculate_distance
}
agent = ReActAgent(tools=tools)
# Uruchomienie
result = agent.run("Jaka jest pogoda w Serengeti i jakie zwierzęta tam żyją?")
print(f"\nKońcowa odpowiedź: {result}")Na to pytanie agent zwykle wykona dwie akcje - get_weather i search_animals - zanim zwróci Answer.
ReAct z LangChain
LangChain ma gotowego agenta ReAct, więc pętli nie piszesz sam: dekorator @tool zamienia funkcję w narzędzie, a opis bierze z docstringu:
from langchain.agents import create_react_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain.tools import tool
from langchain import hub
# Narzędzia jako tools LangChain
@tool
def safari_weather(location: str) -> str:
"""Pobiera pogodę dla lokalizacji na Safari."""
return f"Pogoda w {location}: 26°C, słonecznie"
@tool
def animal_info(animal_name: str) -> str:
"""Wyszukuje informacje o zwierzęciu Safari."""
return f"Informacje o {animal_name}: Wspaniałe zwierzę Afryki!"
@tool
def safari_distance(from_location: str, to_location: str) -> str:
"""Oblicza odległość między punktami Safari."""
return f"Odległość z {from_location} do {to_location}: 150 km"Teraz łączymy model, gotowy prompt ReAct z LangChain Hub i narzędzia, a AgentExecutor prowadzi całą pętlę:
# LLM i prompt
llm = ChatOpenAI(model="gpt-4.1-mini", temperature=0)
prompt = hub.pull("hwchase17/react")
# Agent ReAct
tools = [safari_weather, animal_info, safari_distance]
agent = create_react_agent(llm, tools, prompt)
# Executor
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True,
handle_parsing_errors=True,
max_iterations=10
)
# Uruchomienie
result = agent_executor.invoke({
"input": "Sprawdź pogodę w Serengeti i powiedz mi o lwach"
})
print(result["output"])handle_parsing_errors=True odsyła modelowi błąd formatu, zamiast przerywać działanie, a verbose=True wypisuje każdy krok. Uwaga na wersje: ten kod działa w LangChain 0.3. W LangChain 1.0 create_react_agent, AgentExecutor i hub przeniesiono do pakietu langchain-classic (importujesz je z langchain_classic), a zalecanym następcą jest create_agent z langchain.agents.
ReAct z OpenAI Function Calling
Nowoczesne modele mają wbudowane wywoływanie narzędzi, więc nie trzeba parsować tekstu. Narzędzie opisujemy schematem JSON, a funkcja wykonawcza dostaje gotowe argumenty:
from openai import OpenAI
import json
client = OpenAI()
# Definicja tools dla OpenAI
tools = [
{
"type": "function",
"function": {
"name": "get_safari_info",
"description": "Pobiera informacje o Safari",
"parameters": {
"type": "object",
"properties": {
"topic": {
"type": "string",
"description": "Temat: weather, animals, locations"
},
"query": {
"type": "string",
"description": "Szczegółowe zapytanie"
}
},
"required": ["topic", "query"]
}
}
}
]
def execute_safari_tool(topic: str, query: str) -> str:
"""Wykonuje narzędzie Safari."""
if topic == "weather":
return f"Pogoda dla {query}: 28°C, słonecznie"
elif topic == "animals":
return f"Informacje o {query}: Fascynujące zwierzę Safari!"
elif topic == "locations":
return f"Lokalizacja {query}: Popularne miejsce na Safari"
return "Nieznany temat"Pole description pełni tę samą rolę co docstring, a required mówi, których argumentów model nie może pominąć.
Pętla wygląda znajomo, tylko zamiast wyrażeń regularnych czytamy message.tool_calls:
def react_with_functions(query: str) -> str:
"""ReAct używając OpenAI function calling."""
messages = [
{
"role": "system",
"content": "Jesteś ekspertem Safari. Odpowiadaj krok po kroku, używając dostępnych narzędzi."
},
{"role": "user", "content": query}
]
for _ in range(5): # Max iterations
response = client.chat.completions.create(
model="gpt-5-mini",
messages=messages,
tools=tools,
tool_choice="auto"
)
message = response.choices[0].message
messages.append(message)
# Sprawdź czy są tool calls
if message.tool_calls:
for tool_call in message.tool_calls:
args = json.loads(tool_call.function.arguments)
result = execute_safari_tool(**args)
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": result
})
else:
# Brak tool calls = finalna odpowiedź
return message.content
return "Przekroczono limit iteracji"
# Użycie
answer = react_with_functions("Jaka pogoda panuje w Serengeti?")
print(answer)Odpowiedź modelu z tool_calls trzeba dopisać do messages przed wynikami, a każdy wynik łączy się z wywołaniem przez tool_call_id. tool_choice="auto" pozwala modelowi zdecydować, czy potrzebuje narzędzia. Myśl nie jest tu wypisywana jako Thought, ale cykl akcja i obserwacja pozostaje ten sam. Do nowych projektów polecam właśnie tę wersję, bo jest najodporniejsza na błędy formatu.
Zaawansowany ReAct z pamięcią
Agent może też oceniać własne postępy. Najpierw struktura na jeden krok - @dataclass generuje konstruktor, a field(default_factory=datetime.now) wstawia czas utworzenia:
from dataclasses import dataclass, field
from typing import Optional
from datetime import datetime
@dataclass
class ThoughtStep:
"""Krok rozumowania agenta."""
thought: str
action: Optional[str] = None
observation: Optional[str] = None
timestamp: datetime = field(default_factory=datetime.now)Optional[str] oznacza, że akcja i obserwacja mogą być puste, na przykład przy ostatniej myśli.
Agent z refleksją co kilka kroków prosi model o ocenę dotychczasowej trasy:
class AdvancedReActAgent:
"""Zaawansowany agent ReAct z pamięcią i refleksją."""
def __init__(self, tools: dict, model: str = "gpt-5-mini"):
self.tools = tools
self.model = model
self.client = OpenAI()
self.thought_history: list[ThoughtStep] = []
self.long_term_memory: list[str] = []
def reflect(self) -> str:
"""Refleksja nad dotychczasowymi krokami."""
if len(self.thought_history) < 2:
return ""
steps_summary = "\n".join([
f"- Thought: {s.thought}, Action: {s.action}, Result: {s.observation}"
for s in self.thought_history[-3:]
])
response = self.client.chat.completions.create(
model=self.model,
messages=[
{
"role": "system",
"content": "Przeanalizuj dotychczasowe kroki i zasugeruj ulepszenia."
},
{
"role": "user",
"content": f"Dotychczasowe kroki:\n{steps_summary}"
}
],
max_completion_tokens=1000
)
return response.choices[0].message.content
def should_reflect(self) -> bool:
"""Decyduje czy agent powinien przeprowadzić refleksję."""
# Refleksja co 3 kroki lub gdy ostatnia akcja nie powiodła się
if len(self.thought_history) % 3 == 0 and len(self.thought_history) > 0:
return True
if self.thought_history and "błąd" in (self.thought_history[-1].observation or "").lower():
return True
return False
def run(self, query: str) -> str:
"""Uruchamia agenta z refleksją."""
# ... implementacja podobna do podstawowej wersji
# ale z dodaną refleksją
for i in range(10):
if self.should_reflect():
reflection = self.reflect()
print(f"Refleksja: {reflection}")
# ... reszta logiki ReAct
return "Odpowiedź"Metoda run to szkielet do uzupełnienia w ćwiczeniu. W reflect użyłem max_completion_tokens: modele rozumujące nie przyjmują starszego max_tokens, a w nowym limicie mieszczą się też ukryte tokeny rozumowania, więc nie ustawiaj go zbyt nisko.
Wzorce ReAct
Podstawową pętlę rozbudowuje się na kilka sposobów. Docstring na górze to mapa wariantów, a klasa pod nim szkicuje wariant z planowaniem:
"""
Popularne wzorce używane w agentach ReAct:
1. BASIC ReAct
Thought -> Action -> Observation -> Repeat
2. ReAct with Reflection
Thought -> Action -> Observation -> Reflect -> Repeat
3. ReAct with Planning
Plan -> Thought -> Action -> Observation -> Replan -> Repeat
4. ReAct with Self-Consistency
Multiple ReAct traces -> Vote on best answer
5. ReAct with Retrieval (RAG-ReAct)
Thought -> Retrieve -> Augment -> Action -> Observation
"""
# Przykład ReAct with Planning
class PlanningReActAgent:
def __init__(self, tools: dict):
self.tools = tools
self.plan: list[str] = []
self.current_step = 0
def create_plan(self, query: str) -> list[str]:
"""Tworzy plan działania przed rozpoczęciem."""
# LLM tworzy plan kroków
response = client.chat.completions.create(
model="gpt-5-mini",
messages=[
{
"role": "system",
"content": "Stwórz plan kroków do rozwiązania zadania. Każdy krok w nowej linii."
},
{"role": "user", "content": query}
]
)
plan = response.choices[0].message.content.split("\n")
return [step.strip() for step in plan if step.strip()]
def replan(self, remaining_steps: list[str], new_info: str) -> list[str]:
"""Aktualizuje plan na podstawie nowych informacji."""
# LLM może zmodyfikować pozostałe kroki
return remaining_steps # lub zmodyfikowane krokiSelf-consistency uruchamia kilka niezależnych przebiegów i wybiera odpowiedź, na którą wskazuje większość. Moja rada: zaczynaj od podstawowego ReAct i dokładaj warianty dopiero wtedy, gdy widzisz konkretny problem.
ReAct to potężny wzorzec dla agentów AI. Łączy rozumowanie z działaniem, co prowadzi do bardziej przemyślanych i dokładnych odpowiedzi. W następnym module poznasz jeszcze bardziej zaawansowane techniki - RAG i systemy Multi-Agent!
Pamiętaj: dobry agent jak dobry tropiciel - najpierw myśli, potem sprawdza ślady, a odpowiada dopiero wtedy, gdy zobaczył je na własne oczy.
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Czym jest wzorzec ReAct w kontekście agentów AI?
Zadania praktyczne w grze
- Układanie w pionie
Ułóż kroki pętli ReAct w prawidłowej kolejności:
- Układanie w pionie
Ułóż kroki pętli ReAct w prawidłowej kolejności:
- Edytor kodu
Stwórz klasę ReActAgent z metodami run() i execute_action().
- Klikanie w kolejności
Kliknij w przyciski, aby stworzyć agenta ReAct z LangChain:
- Układanie w pionie
Ułóż kroki ReAct z refleksją:
- Edytor kodu
Zaimplementuj agenta z narzędziami: get_weather, search_animals, calculate_distance.
Zadania po tej lekcji
- PytanieReAct Pattern
- Ułóż w kolejnościReAct Loop
- Ułóż w kolejnościPętla ReAct
- Zadanie z kodemReAct Agent
- Kliknij w kolejnościReAct z LangChain
- Ułóż w kolejnościReAct with Reflection
- Zadanie z kodemProjekt: ReAct Safari Agent
- WideoAI z LLM - podsumowanie teorii
- Zadanie z kodemProjekt: Chatbot Safari
- Zadanie z kodemProjekt: AI z narzędziami
- Zadanie z kodemProjekt: API Safari AI
- Projekt do wysłaniaWyślij projekt AI do mentora
- WideoPodsumowanie modułu