JYP Garden

GenAI Application Design Patterns: ReAct, Reflection, Tool Use, Planning, Multi-Agent

Properties1
tagssource, gen-ai, agent-architecture, design-patterns, knowledge

10 min read

GenAI Application Design Patterns: ReAct, Reflection, Tool Use, Planning, Multi-Agent

Source: 2026-04-26-genai-design-patterns-devto Type: Article (DEV Community) Valid as of: 2026-04-26

핵심 Takeaway

상세 요약

생성형 AI 서비스 설계의 핵심 과제

문제 1: LLM의 지식 한계

사용자: "우리 회사의 2024년 분기별 매출 데이터를 분석해줄 수 있나?"
LLM만: "죄송하지만, 저는 2023년까지의 데이터만 알고 있습니다" ❌

문제 2: 실시간 데이터 미반영

LLM의 훈련 데이터는 과거 지점까지만 반영.

해결책: Agent + Tool + LLM

사용자 질문
    ↓
[LLM 판단] "데이터 분석이 필요하다"
    ↓
[Tool 호출] 데이터베이스/파일 접근
    ↓
[결과 처리] LLM이 도구 결과 분석
    ↓
[최종 답변] 사용자에게 결과 반환 ✓

패턴 1: ReAct (Reasoning + Acting)

개념: LLM이 “생각”과 “행동”을 번갈아 반복.

단계별 실행 예시: 비행기표 검색

사용자: "뉴욕에서 서울로 비행기 표를 사는데 얼마나 드나?"

Step 1 — Reasoning (생각):
LLM: "사용자는 비행기 표 가격을 알고 싶습니다. 
      비행 일자가 명시되지 않았으므로 먼저 확인해야 합니다."

Step 2 — Action (행동):
Agent: flight_search_tool(from="NYC", to="Seoul", date=None)
       ← 날짜가 없어서 실패

Step 3 — Observation (관찰):
Tool Output: "날짜가 필요합니다"

Step 4 — Reasoning:
LLM: "사용자에게 여행 일자를 물어봐야 합니다"

Step 5 — Action:
Agent: ask_user_for_dates()

... (사용자 입력) ...

Step 6 — Final Action:
Agent: flight_search_tool(from="NYC", to="Seoul", 
                          date="2024-05-15", return_date="2024-05-22")

Step 7 — Observation:
Tool Output: [항공편 목록 with 가격·운항시간]

Step 8 — Final Response:
LLM: "가장 저렴한 옵션은 United Airlines의 $850입니다."

코드 구현 (LangChain)

from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import tool
from langchain.llms import ChatOpenAI
 
@tool
def flight_search(from_city: str, to_city: str, date: str) -> str:
    """Search for flight prices"""
    return "[항공권 결과]..."
 
@tool
def hotel_search(city: str, check_in: str, check_out: str) -> str:
    """Search for hotel prices"""
    return "[호텔 결과]..."
 
llm = ChatOpenAI(model="gpt-4", temperature=0)
tools = [flight_search, hotel_search]
 
agent = create_react_agent(llm, tools)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
result = executor.invoke({
    "input": "뉴욕에서 서울로 2024년 5월 15-22일 여행하려고 합니다. 비행기와 호텔 추천해주세요"
})

패턴 2: Reflection (자기 성찰)

개념: LLM이 자신의 답변을 검증하고 개선.

예시: 코드 버그 찾기

사용자: "이 코드의 버그를 찾아줄 수 있나?"

def calculate_average(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n
    return sum / len(numbers)

Step 1 — Initial Response:
LLM: "코드가 정상적으로 보입니다." ❌
     (빈 리스트일 때 ZeroDivisionError 발생)

Step 2 — Reflection:
LLM: "잠깐, 다시 확인해봅시다.
      - 빈 리스트 처리? ❌
      - 타입 체크? ❌
      버그가 있습니다!"

Step 3 — Improved Response:
LLM: "버그:
      1. 빈 리스트 → ZeroDivisionError
      2. 타입 체크 없음
      
      수정 코드:
      def calculate_average(numbers):
          if not numbers:
              return 0
          return sum(numbers) / len(numbers)"

코드 구현

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
 
# Step 1: 초기 응답
initial_response = llm.predict(initial_prompt.format(code=user_code))
 
# Step 2: 반사적 검증
reflection_prompt = PromptTemplate(
    input_variables=["code", "initial_response"],
    template="""코드: {code}
 
초기 분석: {initial_response}
 
엣지 케이스를 확인하세요:
- 빈 입력, 음수, None 등
- 타입 오류, 성능 이슈, 보안 문제
 
더 개선된 분석을 제시하세요."""
)
 
improved_response = llm.predict(
    reflection_prompt.format(code=user_code, initial_response=initial_response)
)

패턴 3: Tool Use (도구 사용)

개념: LLM이 자신의 능력을 초과하는 작업을 “도구”로 위임.

자주 사용되는 10가지 Tool

#Tool용도예시
1Calculator계산”345 × 789를 계산해줘”
2Web Search최신 정보”2026년 환율은?“
3Database Query데이터 조회”올해 상반기 매출은?“
4API Call외부 서비스”기상청 날씨 조회”
5Code Execution코드 실행”Python으로 이미지 변환”
6File Read/Write파일 조작”CSV 파일 분석”
7Text-to-Speech음성 생성”음성 가이드 생성”
8Image Generation이미지 생성”로고 디자인”
9Email Send이메일 발송”보고서를 팀장에게 전송”
10Slack Post메시지 전송”팀 채널에 공지”

복합 Tool 사용 코드

from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import tool
import yfinance as yf
 
@tool
def stock_price(ticker: str) -> str:
    """Get current stock price"""
    stock = yf.Ticker(ticker)
    return f"{ticker}: ${stock.info['currentPrice']}"
 
@tool
def currency_converter(amount: float, from_curr: str, to_curr: str) -> str:
    """Convert currency"""
    return f"{amount} {from_curr} = {converted} {to_curr}"
 
@tool
def calculate(expression: str) -> str:
    """Calculate math expression"""
    return f"Result: {eval(expression)}"
 
executor = AgentExecutor.from_agent_and_tools(
    agent=create_openai_tools_agent(llm, tools),
    tools=tools,
    verbose=True
)
 
# 복합 질문
query = """
Apple 주가가 $150인데, 이를 한국원으로 환전하면 얼마일까요?
추가로 150달러 × 10개 = 총액은?
"""
result = executor.invoke({"input": query})

패턴 4: Planning (계획 수립)

개념: 복잡한 작업을 단계별 계획으로 분해.

예시: 웹사이트 성능 개선

사용자: "우리 웹사이트의 성능을 개선하고 싶어요"

Step 1 — Planning:
LLM: "다음 단계가 필요합니다:
      1. 현재 성능 측정 (페이지 로드 시간, Core Web Vitals)
      2. 병목 지점 분석 (이미지, JavaScript, CSS)
      3. 최적화 전략 수립 (이미지 압축, 코드 분할, 캐싱)
      4. 개선 구현
      5. 성능 재측정 및 검증"

Step 2 — Execution:
[각 단계를 순차적으로 실행 및 검증]

Step 3 — Monitoring:
계속 모니터링하며 필요시 계획 조정

패턴 5: Multi-Agent (다중 에이전트)

개념: 여러 전문가 Agent가 협력하여 복잡한 문제 해결.

아키텍처 예시: 전자상거래 진단

┌─────────────────────────────┐
│  Orchestrator (주관)         │
└─────────────────────────────┘
    ↓        ↓        ↓       ↓
┌────────┐┌────────┐┌────────┐┌────────┐
│Frontend│││Backend││ Database│ DevOps │
│Expert  │││Expert │ Expert  │ Expert │
└────────┘└────────┘└────────┘└────────┘

각 Expert가 독립적으로 분석 → Orchestrator가 종합

코드 구현 개요

# Expert 1: Frontend 전문가
frontend_agent = create_react_agent(llm, [page_speed_tool, css_analyzer_tool])
 
# Expert 2: Backend 전문가  
backend_agent = create_react_agent(llm, [api_latency_tool, db_query_tool])
 
# Expert 3: Database 전문가
db_agent = create_react_agent(llm, [query_optimizer_tool])
 
# Expert 4: DevOps 전문가
devops_agent = create_react_agent(llm, [infra_monitoring_tool])
 
# Orchestrator: 모든 Agent 조율 및 종합 분석
def diagnose_ecommerce_issues(problem_description: str):
    frontend_report = frontend_agent.run(problem_description)
    backend_report = backend_agent.run(problem_description)
    db_report = db_agent.run(problem_description)
    devops_report = devops_agent.run(problem_description)
    
    # 종합 분석
    final_recommendation = llm.predict(synthesis_prompt)
    return final_recommendation

패턴 선택 기준

문제 유형추천 패턴이유
여행 계획, 구매 결정ReAct상호작용 & 정보 수집 필요
코드 검토, 품질 관리Reflection검증 & 개선 필요
계산, 외부 데이터Tool Use전문 도구 활용
대규모 프로젝트Planning체계적 분해 필요
복잡한 의사결정Multi-Agent다양한 관점 필요

실전: 기업 문서 Q&A 시스템

아키텍처:

사용자 쿼리 (UI)
    ↓
[Query Router - ReAct Agent]
    ↓
[Retriever - RAG]
    ↓
[LLM with Reflection]
    ↓
[결과 포매팅 - FastAPI]

FastAPI 구현으로 “/search” 엔드포인트 제공 → RAG Retriever + ReAct Agent + Reflection으로 정확한 답변.

연결되는 위키 페이지

그래프 뷰