ReAct: Revolutionizing Problem-Solving in AI with a Synergistic Approach

Intro with OpenAI API

Jomsborg Lab
7 min readJan 17, 2024

In the realm of artificial intelligence (AI), the conventional approach has often seen reasoning and action as two separate processes. Reasoning was about thinking through problems, while actions were about executing solutions. But what if these two processes could not just coexist but actually synergize to create a more dynamic and effective problem-solving approach? This is where the innovative ReAct method comes into play, marking a significant leap in the capabilities of large language models (LLMs).

Understanding ReAct

ReAct, short for “Reasoning and Acting,” is a groundbreaking approach that intertwines reasoning (the AI’s thought process) with action (the AI’s execution of tasks). Unlike traditional AI models that treat these processes separately, ReAct integrates them into a cohesive workflow. This integration ensures that every action the AI takes is informed by its reasoning, and every piece of reasoning potentially leads to a meaningful action. The result? A more adaptive, responsive, and effective AI model.

How ReAct Works

ReAct operates on a simple yet powerful cycle that mirrors human problem-solving behavior: Think, Act, Observe, and Adapt.

  1. Think (Reasoning): Every task begins with the AI thinking through the problem. It uses its language understanding capabilities to dissect the question, understand the requirements, and devise a strategy. This step sets the stage for informed action planning.
  2. Act (Action Planning and Execution): Based on its reasoning, the AI plans and then executes specific actions. These actions could involve fetching data from external sources, interacting with databases, or even modifying the environment. This step is crucial as it transforms thought into tangible steps towards the solution.
  3. Observe (Feedback Integration): Post-action, the AI observes the outcome and integrates this new data into its thought process. This feedback loop allows the AI to learn from its actions, understand the consequences, and refine its future strategies.
  4. Adapt (Iterative Refinement): The process is inherently iterative. The AI continuously cycles through thinking, acting, and observing, adapting its approach with each iteration. This adaptability allows the AI to handle complex and dynamic problems effectively.

Case Study

Our GPTBot is implemented with a clear structure, holding the conversation history and systematically processing each user query. Its execute function interfaces with the OpenAI API, ensuring that every interaction is contextually informed. Notably, GPTBot can handle various actions such as fetching summaries from Wikipedia (wikipedia), retrieving current weather information (weather), and providing details about countries (country_info).

class GPTBot:
def __init__(self, system=""):
self.system = system
self.history = [] # Store the full conversation history

def __call__(self, message):
# Clear history for each new query to start fresh
self.history = []

if self.system:
self.history.append({"role": "system", "content": self.system})

self.history.append({"role": "user", "content": message})
return self.execute()

def execute(self):
completion =
response = completion.choices[0].message.content
self.history.append({"role": "assistant", "content": response})
return response
except Exception as e:
logging.error("Error during API call: %s", e)
return "Sorry, I encountered an error."

def extract_final_response(self, response):
# Extract the final response
if "degrees Celsius" in response or "temperature in" in response:
sentences = response.split('.')
for sentence in reversed(sentences):
if "degrees Celsius" in sentence or "temperature in" in sentence:
return sentence.strip() + '.'
return "I couldn't find the information."

def reset(self):
# Reset the conversation history
self.history = []

To illustrate the ReAct method in action, let’s consider a scenario where a user asks GPTBot, “What is the temperature in the capital of Denmark?”

  1. Initialization: GPTBot starts with a clean slate for each new query. For this scenario, the chatbot initializes its history and prepares to process the query.
  2. Reasoning and Action Planning: Upon receiving the query, GPTBot identifies the need to first determine the capital of Denmark. It plans to fetch this information using the wikipedia action.
  3. Executing Actions and Observing: GPTBot executes the planned action and fetches the necessary information from Wikipedia. It learns that the capital of Denmark is Copenhagen.
  4. Further Reasoning and Action Planning: With the capital identified, GPTBot now plans to fetch the current weather information for Copenhagen using the weather action.
  5. Final Execution and Observation: GPTBot executes the weather action, retrieving the current temperature in Copenhagen. The chatbot then formats this information into a coherent and user-friendly response.
  6. Output: The user receives a clear and informative answer: “The current temperature in Copenhagen, the capital of Denmark, is X°C.”
Image by Author, Copenhagen, June 2023

The prompt serves as a blueprint for the chatbot, outlining the operational framework and setting expectations for its behavior. It’s essentially a set of instructions that the chatbot uses to understand how it should process queries and interact with users. In our case, the prompt provides a clear description of the ReAct method, emphasizing the importance of interleaving reasoning (thinking) and action (doing).

prompt = """
You are a chatbot that responds to queries by thinking, acting, and observing. In response to a query, first think about the best action, then perform it and observe the result.

Available actions:
- wikipedia: Fetches a summary from Wikipedia.
- weather: Retrieves current weather information.
- country_info: Provides details about a country.

For the query 'What is the temperature in the capital of France?':
1. Think: Identify the capital of France using Wikipedia.
2. Act: Fetch capital info using wikipedia: France.
3. Observe: Learn that the capital is Paris.
4. Think: Get Paris's weather.
5. Act: Fetch weather information using weather: Paris.
6. Observe and respond with the temperature in Paris.

You aim to provide accurate, concise answers.

When GPTBot receives a query, it refers to the prompt to determine how to proceed. The prompt’s structure ensures that GPTBot follows a logical and systematic approach to problem-solving. For example, when asked about the temperature in the capital of Denmark:

  1. Guided by the Prompt: GPTBot refers to the prompt’s instructions and starts the Think-Act-Observe cycle.
  2. Action Execution: The prompt indicates that GPTBot can use actions like wikipedia or weather to gather information. GPTBot plans its actions accordingly – first, it uses wikipedia to find the capital of Denmark, and then, it uses weather to get the temperature in Copenhagen.
  3. Observation and Adaptation: After performing each action, GPTBot observes the outcomes, as suggested by the prompt. It then adapts its next steps based on this new information, ensuring a coherent and contextually informed response.

In essence, the prompt in GPTBot serves as the foundational guide that structures the chatbot’s reasoning and actions. It ensures that the chatbot’s interactions are not just reactions to user queries but are part of a thoughtful and deliberate process, embodying the principles of the ReAct method. This results in interactions that are not only accurate and informative but also context-aware and transparent, aligning with the goals of improved interpretability and trustworthiness in AI systems.

Available acions go here:

action_re = re.compile('^Action: (\w+): (.*)$')

def query(bot, question, max_turns=5):
i = 0
next_prompt = question
final_response = ""
while i < max_turns:
i += 1
result = bot(next_prompt)

# Process for next action
actions = [action_re.match(a) for a in result.split('\n') if action_re.match(a)]
if actions:
action, action_input = actions[0].groups()
observation = known_actions[action](action_input)
next_prompt = "Observation: {}".format(observation)
# Assuming the last response without any action is the final response
final_response = result
except Exception as e:
print("An error occurred:", str(e))

return final_response

def wikipedia(q):
return httpx.get("", params={
"action": "query",
"list": "search",
"srsearch": q,
"format": "json"

def get_country_info(country_name):
url = f"{country_name}"
response = httpx.get(url)
data = response.json()
if data:
country = data[0]
capital = country['capital'][0]
population = country['population']
languages = ', '.join([lang for lang in country['languages'].values()])
return f"{country_name}: Capital is {capital}, Population: {population}, Languages: {languages}"
return f"No information found for {country_name}"
except Exception as e:
return f"An error occurred: {str(e)}"

def get_weather(city):
api_key = pogoda # Replace with your actual API key
url = f"{city}&appid={api_key}&units=metric"
response = httpx.get(url)
if response.status_code == 200:
data = response.json()
weather = data['weather'][0]['description']
temp = data['main']['temp']
return f"The current weather in {city} is {weather} with a temperature of {temp}°C."
return f"Failed to retrieve weather data: HTTP {response.status_code}"
except Exception as e:
return f"An error occurred: {str(e)}"

known_actions = {
"wikipedia": wikipedia,
"weather": get_weather,
"country_info": get_country_info

Finally main() goes here:

def main():
# Bot instantiation
bot = GPTBot(prompt)

# Question
question = "What is the temperature in the capital of Denmark?"

# Call the query function with the bot instance and the question
response = query(bot, question)

# Print the response
print("Final response:\n", response)


if __name__ == "__main__":

Our bot generates the following final response:

Final response:

Think: Identify the capital of Denmark using Wikipedia.

Act: Fetch capital info using wikipedia: Denmark.

Observe: Copenhagen is the capital of Denmark.

Think: Get Copenhagen's weather.

Act: Fetch weather information using weather: Copenhagen.

Observe: The current temperature in Copenhagen is -1°C.

The temperature in the capital of Denmark, Copenhagen, is -1°C.

The Impact of ReAct

The implications of ReAct are profound, especially in tasks that require nuanced understanding and interaction with the real world. For instance, in question-answering systems, ReAct reduces common issues like error propagation and hallucinations by verifying information through external sources. In interactive decision-making scenarios, such as virtual shopping or navigation, ReAct demonstrates superior performance by actively seeking information and adapting to new inputs.

ReAct’s approach also significantly improves the interpretability and trustworthiness of AI models. By generating human-like, interpretable task-solving trajectories, ReAct allows users to understand the AI’s thought process, fostering trust and transparency.


ReAct is not just a method; it’s a paradigm shift in how we view and build AI models. By synergizing reasoning and action, ReAct paves the way for more intelligent, adaptable, and trustworthy AI systems. As we continue to explore its potential, ReAct stands as a testament to the continuous evolution and ingenuity in the field of artificial intelligence.


REACT: SYNERGIZING REASONING AND ACTING IN LANGUAGE MODELS, Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, Yuan Cao, joint team of Department of Computer Science, Princeton University, Google Research, Brain team