2장: ReAct 패턴 - 추론과 행동의 결합

import anthropic
import json
import httpx
 
client = anthropic.Anthropic()
 
# 도구 정의
tools = [
    {
        "name": "web_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": "계산할 수학 표현식 (예: '2 + 3 * 4')"
                }
            },
            "required": ["expression"]
        }
    }
]

def execute_tool(name: str, input_data: dict) -> str:
    if name == "web_search":
        return web_search(input_data["query"])
    elif name == "calculator":
        return calculator(input_data["expression"])
    else:
        return f"알 수 없는 도구: {name}"
 
def web_search(query: str) -> str:
    # 실제 구현에서는 검색 API를 호출합니다
    # 여기서는 예시 데이터를 반환합니다
    return f"'{query}'에 대한 검색 결과: [검색 결과 데이터]"
 
def calculator(expression: str) -> str:
    try:
        # 안전한 수학 표현식만 평가
        allowed_chars = set("0123456789+-*/.() ")
        if not all(c in allowed_chars for c in expression):
            return "허용되지 않는 문자가 포함되어 있습니다."
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"계산 오류: {str(e)}"

SYSTEM_PROMPT = """당신은 문제를 단계적으로 해결하는 AI 에이전트입니다.
각 단계에서 먼저 현재 상황을 분석하고(Thought),
필요한 행동을 취하며(Action), 결과를 관찰합니다(Observation).
 
문제를 해결하기 위해 제공된 도구를 적극 활용하십시오.
충분한 정보를 수집한 후에 최종 답변을 제공하십시오."""
 
def react_agent(user_message: str, max_iterations: int = 10) -> str:
    messages = [{"role": "user", "content": user_message}]
    iteration = 0
 
    while iteration < max_iterations:
        iteration += 1
        print(f"\n--- 반복 {iteration} ---")
 
        # LLM 추론 (Thought + Action 결정)
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            system=SYSTEM_PROMPT,
            tools=tools,
            messages=messages,
        )
 
        # 응답 내용 출력 (디버깅용)
        for block in response.content:
            if hasattr(block, "text"):
                print(f"[Thought] {block.text}")
            elif block.type == "tool_use":
                print(f"[Action] {block.name}({json.dumps(block.input, ensure_ascii=False)})")
 
        # 최종 응답인 경우 루프 종료
        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            return "응답을 생성할 수 없습니다."
 
        # 도구 호출 처리
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                print(f"[Observation] {result}")
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })
 
        # 대화 히스토리에 추가
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_results})
 
    return "최대 반복 횟수에 도달했습니다."

result = react_agent(
    "파이썬의 최신 안정 버전은 무엇이고, "
    "해당 버전이 출시된 지 며칠이 지났는지 계산해 주세요."
)
print(f"\n최종 답변: {result}")

OPTIMIZED_SYSTEM_PROMPT = """당신은 문제를 체계적으로 해결하는 AI 에이전트입니다.
 
## 행동 원칙
1. 행동하기 전에 반드시 현재 상황을 분석하십시오.
2. 한 번에 하나의 도구만 사용하고, 결과를 확인한 후 다음 단계를 결정하십시오.
3. 불확실한 정보는 추측하지 말고 도구를 사용하여 확인하십시오.
4. 충분한 정보를 수집한 후에만 최종 답변을 제공하십시오.
 
## 도구 사용 가이드
- web_search: 최신 정보, 사실 확인, 통계 데이터가 필요할 때
- calculator: 수치 계산, 날짜 계산, 단위 변환이 필요할 때
 
## 답변 형식
- 근거를 먼저 제시하고, 결론을 명확히 제시하십시오.
- 출처가 있는 정보는 출처를 함께 제공하십시오."""

def preprocess_observation(result: str, max_length: int = 2000) -> str:
    """관찰 결과를 적절한 길이로 전처리합니다."""
    if len(result) <= max_length:
        return result
 
    # 핵심 정보를 보존하면서 잘라냄
    truncated = result[:max_length]
    last_period = truncated.rfind(".")
    if last_period > max_length * 0.5:
        truncated = truncated[:last_period + 1]
 
    return truncated + "\n\n[결과가 잘렸습니다. 추가 정보가 필요하면 더 구체적인 검색을 수행하십시오.]"

class LoopController:
    def __init__(self, max_iterations: int = 10, max_tokens: int = 50000):
        self.max_iterations = max_iterations
        self.max_tokens = max_tokens
        self.iteration = 0
        self.total_tokens = 0
        self.action_history = []
 
    def should_continue(self, action: str) -> bool:
        self.iteration += 1
 
        # 최대 반복 횟수 초과
        if self.iteration > self.max_iterations:
            return False
 
        # 동일한 행동 반복 감지
        self.action_history.append(action)
        if len(self.action_history) >= 3:
            last_three = self.action_history[-3:]
            if len(set(last_three)) == 1:
                return False  # 같은 행동을 3번 반복
 
        return True
 
    def get_status(self) -> str:
        return f"반복: {self.iteration}/{self.max_iterations}"

STRUCTURED_SYSTEM_PROMPT = """각 단계를 다음 형식으로 출력하십시오:
 
Thought: [현재 상황 분석과 다음 행동 계획]
Action: [사용할 도구 이름]
Action Input: [도구에 전달할 입력]
 
도구 사용이 필요 없으면 다음 형식으로 최종 답변을 제공하십시오:
Thought: [최종 분석]
Final Answer: [최종 답변]"""

def execute_with_retry(name: str, input_data: dict, max_retries: int = 2) -> str:
    """도구 실행 실패 시 재시도합니다."""
    for attempt in range(max_retries + 1):
        try:
            result = execute_tool(name, input_data)
            if "오류" not in result and "에러" not in result:
                return result
            if attempt < max_retries:
                return f"[실패] {result}\n재시도를 위해 입력을 수정해 주세요. (시도 {attempt + 1}/{max_retries})"
        except Exception as e:
            if attempt < max_retries:
                return f"[예외] {str(e)}\n재시도를 위해 입력을 수정해 주세요."
            return f"[최종 실패] {str(e)}"
    return result