Kurs Python · Moduł 10: AI i modele językowe

ReAct Agents - Reasoning and Acting

11 min czytania ·
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:

  1. Thought - analizuje sytuację, planuje
  2. Action - wykonuje akcję (np. wywołuje narzędzie)
  3. Observation - obserwuje wynik akcji
  4. 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, answer

Brak 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 kroki

Self-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. 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.

  1. PytanieReAct Pattern
  2. Ułóż w kolejnościReAct Loop
  3. Ułóż w kolejnościPętla ReAct
  4. Zadanie z kodemReAct Agent
  5. Kliknij w kolejnościReAct z LangChain
  6. Ułóż w kolejnościReAct with Reflection
  7. Zadanie z kodemProjekt: ReAct Safari Agent
  8. WideoAI z LLM - podsumowanie teorii
  9. Zadanie z kodemProjekt: Chatbot Safari
  10. Zadanie z kodemProjekt: AI z narzędziami
  11. Zadanie z kodemProjekt: API Safari AI
  12. Projekt do wysłaniaWyślij projekt AI do mentora
  13. WideoPodsumowanie modułu

Przydatne artykuły