ReAct {ReWOO}

from langchain.agents import AgentExecutor
from langchain.agents.format_scratchpad import format_log_to_str
from langchain.agents.output_parsers import ReActSingleInputOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import chain
from langchain.tools import DuckDuckGoSearchRun
from langchain_openai import ChatOpenAI

# 1. Define Tools: In this simple example, we are using a search tool.
tools = [DuckDuckGoSearchRun()]

# 2. Construct the Prompt:
template = """Answer the following questions as best you can. You have
access to the following tools:

{tool_descriptions}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
{agent_scratchpad}"""

prompt = ChatPromptTemplate.from_template(template)
prompt = prompt.partial(
    tool_names=", ".join([t.name for t in tools]),
    tool_descriptions="\n".join([f"{t.name}: {t.description}" for t in tools]),
)

# 3. Instantiate the LLM:
llm = ChatOpenAI(temperature=0)
llm_with_stop = llm.bind(stop=["\nObservation:"])  # Configure it to stop when it sees '\nObservation:'

# 4. Construct the Agent Pipeline:
agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_log_to_str(x["intermediate_steps"]),
    }
    | prompt
    | llm_with_stop
    | ReActSingleInputOutputParser()
)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

sample_question = "Who is the current CEO of Microsoft and what is their age squared?"
response = agent_executor.invoke({"input": sample_question})
print(response)

import re
from typing import List
from typing_extensions import TypedDict
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.tools.tavily_search import TavilySearchResults
from langgraph.graph import END, StateGraph, START

# 1. Define state
class ReWOO(TypedDict):
    task: str
    plan_string: str
    steps: List
    results: dict
    result: str

# 2. Planner prompt and logic
model = ChatOpenAI(model="gpt-4o")

prompt = """For the following task, create a series of plans that can solve the problem step-by-step.
For each plan, specify which external tool and its corresponding input should be used to gather evidence.
You can store the evidence in a variable #E (e.g., #E1, #E2, #E3, etc.) that can be referenced by subsequent tools.
Note that all the variables are independent, so make sure to include all necessary information in each tool input.

Tools can be one of the following:

Google[input]: A search engine worker that retrieves results from Google.
Use this when you need concise answers or information about a specific topic.
The input should be a search query.

LLM[input]: A pretrained Large Language Model (like me).
Use this when you need to leverage general world knowledge, common sense, or perform complex reasoning.
Prioritize this tool when you are confident in solving the problem without external assistance.
The input can be any instruction or question.

Calculator[input]: A tool that can perform mathematical calculations.
Use this when you need to perform arithmetic operations.
The input should be a valid mathematical expression.

WolframAlpha[input]: A computational knowledge engine.
Use this when you need to solve equations, perform symbolic calculations, or get data-driven answers.
The input should be a query in Wolfram Language or natural language related to a math or science problem.

For example,

Task: Alice, Bob, and Carol earned a total of $540 from their part-time jobs last week.
Alice earned y dollars.
Bob earned $20 more than three times what Alice earned, and Carol earned $15 more than Bob.
How much money did Carol earn?

Plan: Given Alice earned y dollars, translate the problem into algebraic expressions and solve with Wolfram Alpha.
#E1 = WolframAlpha[Solve y + (3y + 20) + ((3y + 20) + 15) = 540]

Plan: Find out the amount of money Alice earned.
#E2 = LLM[What is y, given #E1]

Plan: Calculate the amount of money Carol earned.
#E3 = Calculator[((3 * #E2) + 20) + 15]

Begin!
Describe your plans with rich details.
Each Plan should be followed by only one #E.

Task: {task}"""

# 3. Node for planner
regex_pattern = r"Plan:\s*(.+)\s*(#E\d+)\s*=\s*(\w+)\s*\[([^\]]+)\]"
prompt_template = ChatPromptTemplate.from_messages([("user", prompt)])
planner = prompt_template | model

def get_plan(state: ReWOO):
    task = state["task"]
    result = planner.invoke({"task": task})
    matches = re.findall(regex_pattern, result.content)
    return {"steps": matches, "plan_string": result.content}

# 4. Define the tool execution logic
search = TavilySearchResults()

def _get_current_task(state: ReWOO):
    if "results" not in state or state["results"] is None:
        return 1
    if len(state["results"]) == len(state["steps"]):
        return None
    else:
        return len(state["results"]) + 1

def tool_execution(state: ReWOO):
    _step = _get_current_task(state)
    _, step_name, tool, tool_input = state["steps"][_step - 1]
    _results = (state["results"] or {}) if "results" in state else {}

    for k, v in _results.items():
        tool_input = tool_input.replace(k, v)

    if tool == "Google":
        result = search.invoke(tool_input)
    elif tool == "LLM":
        result = model.invoke(tool_input)
    else:
        raise ValueError

    _results[step_name] = str(result)
    return {"results": _results}

# 5. Solver prompt and logic
solve_prompt = """Solve the following task or problem.
To solve the problem, we have made step-by-step Plan and retrieved corresponding Evidence to each Plan.
Use them with caution since long evidence might contain irrelevant information.

{plan}

Now solve the question or task according to provided Evidence above.
Respond with the answer directly with no extra words.

Task: {task}
Response:"""

def solve(state: ReWOO):
    plan = ""

    for _plan, step_name, tool, tool_input in state["steps"]:
        _results = (state["results"] or {}) if "results" in state else {}

        for k, v in _results.items():
            tool_input = tool_input.replace(k, v)
            step_name = step_name.replace(k, v)

        plan += f"Plan: {_plan}\n{step_name} = {tool}[{tool_input}]\n"

    prompt = solve_prompt.format(plan=plan, task=state["task"])
    result = model.invoke(prompt)
    return {"result": result.content}

# 6. Build workflow
def _route(state):
    _step = _get_current_task(state)
    if _step is None:
        return "solve"
    else:
        return "tool"

graph = StateGraph(ReWOO)
graph.add_node("plan", get_plan)
graph.add_node("tool", tool_execution)
graph.add_node("solve", solve)
graph.add_edge("plan", "tool")
graph.add_edge("solve", END)
graph.add_conditional_edges("tool", _route)
graph.add_edge(START, "plan")

app = graph.compile()

# 7. Execution
task = "what is the exact hometown of the 2024 mens australian open winner"
for s in app.stream({"task": task}):
    print(s)
    print("---")