ReAct 에이전트 구현

# 임베딩 설정
embd = OpenAIEmbeddings()

def create_pdf_retriever(
    pdf_path: str,               # PDF 파일 경로
    persist_directory: str,      # 벡터 스토어 저장 경로
    embedding_model: OpenAIEmbeddings,
    chunk_size: int = 512,
    chunk_overlap: int = 0
) -> Chroma.as_retriever:

    # PDF 파일로드
    loader = PyMuPDFLoader(pdf_path)
    data = loader.load()

    # 청킹
    text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
        chunk_size=chunk_size,
        chunk_overlap=chunk_overlap
    )
    doc_splits = text_splitter.split_documents(data)

    # 벡터 스토어로 적재
    vectorstore = Chroma.from_documents(
        persist_directory=persist_directory,
        documents=doc_splits,
        embedding=embedding_model,
    )

    return vectorstore.as_retriever()

retriever_ict_japan = create_pdf_retriever(
    pdf_path="ict_japan_2024.pdf",
    persist_directory="db_ict_policy_japan_2024",
    embedding_model=embd
)

retriever_ict_usa = create_pdf_retriever(
    pdf_path="ict_usa_2024.pdf",
    persist_directory="db_ict_policy_usa_2024",
    embedding_model=embd
)

retriever_blockchain_usa = create_pdf_retriever(
    pdf_path="blockchain_usa_2025.pdf",
    persist_directory="db_blockchain_usa_2025",
    embedding_model=embd
)

ict_japan_engine = create_retriever_tool(
    retriever=retriever_ict_japan,
    name="japan_ict_trend_searcher",
    description="일본의 ICT 산업의 시장동향 정보를 제공합니다."
)

ict_usa_engine = create_retriever_tool(
    retriever=retriever_ict_usa,
    name="usa_ict_trend_searcher",
    description="미국의 ICT 산업의 시장동향 정보를 제공합니다."
)

blockchain_usa_engine = create_retriever_tool(
    retriever=retriever_blockchain_usa,
    name="usa_blockchain_trend_searcher",
    description="미국의 블록체인 산업의 동향 정보를 제공합니다."
)

tools = [ict_japan_engine, ict_usa_engine, blockchain_usa_engine]
tool_map: Dict[str, object] = {t.name: t for t in tools}

react_template = '''다음 질문에 최선을 다해 답변하세요. 당신은 다음 도구들에 접근할 수 있습니다:

{tools}

다음 형식을 사용하세요:

Question: 답변해야 하는 입력 질문
Thought: 무엇을 할지 항상 생각하세요
Action: 취해야 할 행동, [{tool_names}] 중 하나여야 합니다. 리스트에 있는 도구 중 1개를 택하십시오.
Action Input: 행동에 대한 입력값
Observation: 행동의 결과
... (이 Thought/Action/Action Input/Observation의 과정이 N번 반복될 수 있습니다)
Thought: 이제 최종 답변을 알겠습니다

Final Answer: 원래 입력된 질문에 대한 최종 답변

## 추가적인 주의사항
- 반드시 [Thought -> Action -> Action Input format] 이 사이클의 순서를 준수하십시오. 항상 Action 전에는 Thought가 먼저 나와야 합니다.
- 최종 답변에는 최대한 많은 내용을 포함하십시오.
- 한 번의 검색으로 해결되지 않을 것 같다면 문제를 분할하여 푸는 것은 중요합니다.
- 정보가 취합되었다면 불필요하게 사이클을 반복하지 마십시오.
- 묻지 않은 정보를 찾으려고 도구를 사용하지 마십시오.

시작하세요!

Question: {input}
{agent_scratchpad}'''

prompt = PromptTemplate.from_template(react_template)

def _format_tools_for_prompt(ts: List[object]) -> Tuple[str, str]:
    lines, names = [], []
    for t in ts:
        names.append(t.name)
        desc = getattr(t, "description", "")
        lines.append(f"{t.name}: {desc}")
    return "\n".join(lines), ", ".join(names)

def _render_prompt(user_input: str, scratchpad: str) -> str:
    tools_str, tool_names = _format_tools_for_prompt(tools)
    return prompt.format(
        tools=tools_str,
        tool_names=tool_names,
        input=user_input,
        agent_scratchpad=scratchpad,
    )

llm = ChatOpenAI(model="gpt-4.1", temperature=0)

ACTION_RE = re.compile(r"^Action\s*:\s*(?P<tool>.+?)\s*$", re.MULTILINE)
ACTION_INPUT_RE = re.compile(r"^Action Input\s*:\s*(?P<input>.+?)\s*$", re.MULTILINE)
FINAL_ANSWER_RE = re.compile(r"Final Answer\s*:\s*(?P<final>[\s\S]+)$", re.IGNORECASE)

def _parse_action_and_input(text: str) -> Tuple[Optional[str], Optional[str]]:
    m_final = FINAL_ANSWER_RE.search(text)
    if m_final:
        return "__FINAL__", m_final.group("final").strip()

    m_act = ACTION_RE.search(text)
    m_in = ACTION_INPUT_RE.search(text)
    if m_act and m_in:
        return m_act.group("tool").strip(), m_in.group("input").strip()
    return None, None

def _observation_to_text(observation_obj) -> str:
    if isinstance(observation_obj, list):
        # Document 리스트일 수 있음
        def doc_to_str(d):
            try:
                meta = getattr(d, "metadata", {}) or {}
                src = meta.get("source") or meta.get("file_path") or ""
                txt = getattr(d, "page_content", "")
                if len(txt) > 500:
                    txt = txt[:500] + "..."
                return f"[source={src}] {txt}"
            except Exception:
                return str(d)
        return "\n".join(doc_to_str(d) for d in observation_obj[:5])
    return str(observation_obj)

def run_react(user_input: str, max_iters: int = 8) -> Dict[str, str]:
    scratchpad = ""
    for _ in range(max_iters):
        rendered = _render_prompt(user_input, scratchpad)
        resp = llm.invoke(rendered)
        text = resp.content if hasattr(resp, "content") else str(resp)

        tool, action_input = _parse_action_and_input(text)

        if tool is None:
            hint = "\n[파싱안내] 형식을 엄격히 따르세요. 반드시 'Action:'와 'Action Input:'를 한 줄씩 제공하십시오.\n"
            scratchpad += f"{text}\n{hint}"
            continue

        if tool == "__FINAL__":
            final_answer = action_input
            return {"output": final_answer, "log": scratchpad + "\n" + text}

        if tool not in tool_map:
            observation = f"[에러] 존재하지 않는 도구입니다: {tool}"
            scratchpad += f"{text}\nObservation: {observation}\n"
            continue

        try:
            observation_obj = tool_map[tool].invoke(action_input)
            observation = _observation_to_text(observation_obj)
            scratchpad += f"{text}\nObservation: {observation}\n"
        except Exception as e:
            scratchpad += f"{text}\nObservation: [도구실행오류] {e}\n"

    return {
        "output": "반복 한도를 초과했습니다. 질문을 더 구체화해 주세요.",
        "log": scratchpad,
    }

Thought: 미국의 블록체인 시장 규모에 대한 최신 동향과 수치를 확인하기 위해 관련 도구를 사용해야 합니다.
Action: usa_blockchain_trend_searcher
Action Input: 미국 블록체인 시장 규모 및 성장 동향
Observation: 2023년 기준 미국 블록체인 시장 규모는 약 170억 달러로 추정되며, 연평균 성장률(CAGR)은 약 35%로...

Thought: 이제 최종 답변을 알겠습니다.
Final Answer: 2023년 기준 미국의 블록체인 시장 규모는 약 170억 달러로 추정되며...

def chat_with_agent(message, history):
    try:
        response, execution_log = conversation_manager.process_message(message)
    except Exception as e:
        err_msg = f"[오류] {type(e).__name__}: {e}"
        response = err_msg
        execution_log = err_msg

    history = (history or []) + [
        {"role": "user", "content": message},
        {"role": "assistant", "content": response},
    ]
    return "", history, execution_log

def clear_chat_history():
    conversation_manager.clear_history()
    return [], ""

with gr.Blocks() as demo:
    gr.Markdown("# ReACT 에이전트")
    gr.Markdown("일본과 미국의 ICT 정책 또는 미국의 블록체인 동향에 관한 질문을 해보세요.")

    with gr.Row():
        with gr.Column(scale=2):
            chatbot = gr.Chatbot(height=500)
            msg = gr.Textbox(label="질문을 입력하세요", placeholder="예: 일본의 AI 정책에 대해 알려줘")
            clear = gr.Button("대화 초기화")
        with gr.Column(scale=1):
            logs = gr.Textbox(label="ReACT 실행 로그", lines=25, max_lines=25)

    msg.submit(chat_with_agent, inputs=[msg, chatbot], outputs=[msg, chatbot, logs])
    clear.click(clear_chat_history, inputs=None, outputs=[chatbot, logs])

demo.launch(debug=True)