ReAct — Reasoning + Acting

from openai import OpenAI
import json
import re

client = OpenAI()

def search(query: str) -> str:
    """Заглушка для поиска. В продакшене — Tavily, Serper и т.д."""
    # В реальности: вызов поискового API
    return f"Результат поиска по запросу '{query}': [данные]"

def calculator(expression: str) -> str:
    """Безопасный калькулятор."""
    try:
        # В продакшене используйте ast.literal_eval или sympy
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"Ошибка: {e}"

TOOLS = {"search": search, "calculator": calculator}

def react_loop(
    question: str, max_steps: int = 5
) -> dict:
    """
    ReAct цикл: Thought → Action → Observation → ...
    """
    messages = [
        {
            "role": "system",
            "content": (
                "Ты — AI-ассистент с доступом к инструментам.\n"
                "На каждом шаге:\n"
                "1. Thought: рассуждай, что нужно сделать\n"
                "2. Action: вызови инструмент в формате "
                "action_name(argument)\n"
                "3. Дождись Observation\n"
                "4. Повторяй, пока не получишь ответ\n"
                "5. В конце напиши: ФИНАЛЬНЫЙ ОТВЕТ: ...\n\n"
                "Доступные инструменты:\n"
                "- search(запрос) — поиск информации\n"
                "- calculator(выражение) — калькулятор"
            ),
        },
        {"role": "user", "content": question},
    ]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            temperature=0,
        )

        text = response.choices[0].message.content
        messages.append({"role": "assistant", "content": text})

        # Проверяем, есть ли финальный ответ
        if "ФИНАЛЬНЫЙ ОТВЕТ:" in text:
            answer = text.split("ФИНАЛЬНЫЙ ОТВЕТ:")[-1].strip()
            return {
                "answer": answer,
                "steps": step + 1,
                "trace": messages,
            }

        # Ищем вызов инструмента
        action_match = re.search(
            r"Action:\s*(\w+)\((.+?)\)", text
        )
        if action_match:
            tool_name = action_match.group(1)
            tool_arg = action_match.group(2).strip("\"'")

            if tool_name in TOOLS:
                observation = TOOLS[tool_name](tool_arg)
            else:
                observation = f"Инструмент '{tool_name}' не найден"

            messages.append({
                "role": "user",
                "content": f"Observation: {observation}",
            })

    return {"answer": "Превышен лимит шагов", "steps": max_steps}


result = react_loop(
    "Какова площадь круга с диаметром равным "
    "высоте Эйфелевой башни в метрах?"
)
print(f"Ответ: {result['answer']}")
print(f"Шагов: {result['steps']}")

from openai import OpenAI
import json

client = OpenAI()

tools = [
    {
        "type": "function",
        "function": {
            "name": "search",
            "description": "Поиск информации в интернете",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Поисковый запрос",
                    }
                },
                "required": ["query"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "calculator",
            "description": "Математические вычисления",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "Математическое выражение",
                    }
                },
                "required": ["expression"],
            },
        },
    },
]


def react_function_calling(question: str, max_steps: int = 5):
    """ReAct через нативный Function Calling."""
    messages = [
        {
            "role": "system",
            "content": (
                "Рассуждай пошагово. Используй инструменты "
                "для получения данных и вычислений."
            ),
        },
        {"role": "user", "content": question},
    ]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            tool_choice="auto",
        )

        msg = response.choices[0].message
        messages.append(msg)

        # Если нет вызова инструмента — это финальный ответ
        if not msg.tool_calls:
            return {
                "answer": msg.content,
                "steps": step + 1,
            }

        # Обрабатываем вызовы инструментов
        for tool_call in msg.tool_calls:
            name = tool_call.function.name
            args = json.loads(tool_call.function.arguments)

            if name == "search":
                result = search(args["query"])
            elif name == "calculator":
                result = calculator(args["expression"])
            else:
                result = "Неизвестный инструмент"

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result,
            })

    return {"answer": "Лимит шагов", "steps": max_steps}

import anthropic
import json

client = anthropic.Anthropic()

claude_tools = [
    {
        "name": "search",
        "description": "Поиск информации в интернете",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "Поисковый запрос",
                }
            },
            "required": ["query"],
        },
    },
    {
        "name": "calculator",
        "description": "Математические вычисления",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "Математическое выражение",
                }
            },
            "required": ["expression"],
        },
    },
]


def react_claude(question: str, max_steps: int = 5):
    """ReAct через Anthropic Tool Use."""
    messages = [{"role": "user", "content": question}]

    for step in range(max_steps):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=(
                "Рассуждай пошагово. Используй инструменты "
                "для проверки фактов и вычислений."
            ),
            tools=claude_tools,
            messages=messages,
        )

        # Проверяем, закончил ли Claude
        if response.stop_reason == "end_turn":
            text_blocks = [
                b.text for b in response.content
                if b.type == "text"
            ]
            return {
                "answer": "\n".join(text_blocks),
                "steps": step + 1,
            }

        # Обрабатываем tool use
        messages.append({
            "role": "assistant",
            "content": response.content,
        })

        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                if block.name == "search":
                    result = search(block.input["query"])
                elif block.name == "calculator":
                    result = calculator(
                        block.input["expression"]
                    )
                else:
                    result = "Неизвестный инструмент"

                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })

        messages.append({
            "role": "user",
            "content": tool_results,
        })

    return {"answer": "Лимит шагов", "steps": max_steps}