	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Prompt Engineering > ReAct Prompting Pattern

ReAct Prompting Pattern

Author: Venkata Sudhakar

ReAct (Reasoning + Acting) is a prompting pattern where the LLM alternates between Thought (reasoning what to do next), Action (calling a tool), and Observation (reading the result). This loop continues until the model has enough information for a final Answer. ReAct dramatically improves accuracy on multi-step questions because the model externalises its reasoning and grounds each step in real data instead of hallucinating an answer upfront.

Without ReAct, an LLM asked "Are we ready to cut over - are row counts matching and is CDC caught up?" might guess. With ReAct, it reasons: I need to check source row count, then target row count, then CDC lag - each step is explicit and uses real tool results. ReAct is the foundation of all modern AI agent frameworks. LangChain agents, LangGraph, and CrewAI all implement variations of this Thought/Action/Observation loop under the hood.

The below example implements the ReAct loop manually with the OpenAI function calling API to answer a multi-step migration readiness question.

from openai import OpenAI
import json

client = OpenAI(api_key="your-api-key")

# Simulated tools
def count_rows(table: str, database: str) -> int:
    data = {"source": {"customers": 125000, "orders": 890000},
            "target": {"customers": 124998, "orders": 890000}}
    return data.get(database, {}).get(table, 0)

def check_cdc_lag(consumer_group: str) -> dict:
    return {"lag_seconds": 2, "pending_messages": 150}

tools = [
    {"type": "function", "function": {
        "name": "count_rows",
        "description": "Count rows in a table in either source or target database",
        "parameters": {"type": "object",
            "properties": {
                "table":    {"type": "string"},
                "database": {"type": "string", "enum": ["source","target"]}
            }, "required": ["table","database"]}}},
    {"type": "function", "function": {
        "name": "check_cdc_lag",
        "description": "Check CDC replication lag seconds for a consumer group",
        "parameters": {"type": "object",
            "properties": {"consumer_group": {"type": "string"}},
            "required": ["consumer_group"]}}}
]

messages = [
    {"role": "system", "content": "You are a migration validator. Use tools step by step to answer accurately. Do not guess."},
    {"role": "user",   "content": "Is the customers table fully migrated and is CDC caught up for group migration-cdc?"}
]

# ReAct loop
while True:
    resp = client.chat.completions.create(
        model="gpt-4o-mini", messages=messages, tools=tools, temperature=0)
    msg = resp.choices[0].message
    messages.append(msg)

if not msg.tool_calls:         # Final answer reached
        print("Answer:", msg.content)
        break

for call in msg.tool_calls:    # Execute tool (Action step)
        args = json.loads(call.function.arguments)
        print(f"Action: {call.function.name}({args})")
        result = count_rows(**args) if call.function.name=="count_rows" \
                 else check_cdc_lag(**args)
        print(f"Observation: {result}")
        messages.append({"role":"tool","tool_call_id":call.id,"content":str(result)})

It gives the following output showing the full Thought/Action/Observation loop,

Action: count_rows({"table": "customers", "database": "source"})
Observation: 125000

Action: count_rows({"table": "customers", "database": "target"})
Observation: 124998

Action: check_cdc_lag({"consumer_group": "migration-cdc"})
Observation: {"lag_seconds": 2, "pending_messages": 150}

Answer: The customers table is NOT fully migrated - source has 125,000 rows
but target only has 124,998 (2 rows missing). CDC lag is 2 seconds with
150 pending messages. Wait for CDC to catch up before cutover.

# 3 tool calls -> grounded answer, not a hallucination

ReAct gives you traceability (every reasoning step is visible), correctability (if a tool errors the model adapts), and accuracy (answers grounded in real data). In production you rarely implement this loop manually - LangChain agents and LangGraph do it for you. But understanding the Thought/Action/Observation cycle helps you design better agent prompts and debug why an agent took a wrong turn.

Send your comments, suggestions or queries regarding this site to [email protected].