LangGraph 멀티 에이전트 시스템 완전 가이드

개요

AI 에이전트 시스템이 점점 더 복잡해지면서, 단일 에이전트만으로는 해결하기 어려운 문제들이 늘어나고 있습니다. 이런 상황에서 멀티 에이전트 시스템(Multi-Agent Systems)은 여러 전문화된 에이전트들이 협력하여 복잡한 작업을 해결하는 강력한 패러다임을 제공합니다.

LangGraph는 LangChain 팀이 개발한 프로덕션급 그래프 기반 오케스트레이션 프레임워크로, 상태를 가진(stateful) 멀티 에이전트 AI 시스템을 구축할 수 있게 해줍니다. LinkedIn, Uber, Replit, Klarna, Elastic과 같은 기업들이 이미 프로덕션 환경에서 LangGraph를 사용하고 있습니다.

이 글에서는 LangGraph의 핵심 개념부터 실전 코드 예제, 프로덕션 배포 가이드까지 모든 것을 다룹니다.

LangGraph의 핵심 개념

그래프 기반 아키텍처

LangGraph의 가장 큰 특징은 그래프 기반 아키텍처입니다. 기존의 선형적인 체인(Chain) 방식과 달리, 그래프는 다음과 같은 장점을 제공합니다:

• 순환 워크플로우(Cyclic Workflows): 에이전트가 반복적으로 작업을 수행할 수 있습니다
• 조건부 분기(Conditional Branching): 상황에 따라 다른 경로를 선택할 수 있습니다
• 병렬 실행(Parallel Execution): 여러 에이전트가 동시에 작업할 수 있습니다

graph TD
    Start[시작] --> Supervisor[수퍼바이저 에이전트]
    Supervisor -->|연구 작업| Researcher[연구 에이전트]
    Supervisor -->|코딩 작업| Coder[코딩 에이전트]
    Supervisor -->|리뷰 작업| Reviewer[리뷰 에이전트]
    Researcher --> Supervisor
    Coder --> Supervisor
    Reviewer --> End[종료]

상태 관리 시스템

LangGraph는 강력한 상태 관리 시스템을 제공합니다. 이를 통해:

• 체크포인팅(Checkpointing): 언제든지 워크플로우를 저장하고 복원할 수 있습니다
• 상태 지속성(State Persistence): 데이터베이스에 상태를 저장하여 장기 실행 작업을 지원합니다
• Human-in-the-Loop: 중요한 결정 시점에 사람의 승인을 받을 수 있습니다

노드와 엣지

LangGraph의 그래프는 두 가지 핵심 요소로 구성됩니다:

• 노드(Nodes): 에이전트 또는 작업을 나타냅니다
• 엣지(Edges): 워크플로우의 흐름을 정의합니다
  • 일반 엣지(Normal Edges): 항상 실행되는 고정된 경로
  • 조건부 엣지(Conditional Edges): 상태에 따라 다음 노드를 동적으로 선택

멀티 에이전트 아키텍처 패턴

1. 수퍼바이저 패턴

수퍼바이저 패턴(Supervisor Pattern)은 중앙 조정자 에이전트가 여러 작업자 에이전트들을 관리하는 구조입니다.

graph TD
    User[사용자 요청] --> Supervisor[수퍼바이저]
    Supervisor -->|작업 할당| Agent1[에이전트 1]
    Supervisor -->|작업 할당| Agent2[에이전트 2]
    Supervisor -->|작업 할당| Agent3[에이전트 3]
    Agent1 -->|결과 보고| Supervisor
    Agent2 -->|결과 보고| Supervisor
    Agent3 -->|결과 보고| Supervisor
    Supervisor -->|최종 응답| User

장점:

• 명확한 책임 분리
• 작업 우선순위 관리 용이
• 에러 처리 및 재시도 로직 중앙화

2. 계층적 패턴

계층적 패턴(Hierarchical Pattern)은 여러 레벨의 수퍼바이저를 두어 복잡한 조직 구조를 모델링합니다.

사용 사례:

• 대규모 소프트웨어 개발 프로젝트
• 복잡한 연구 작업
• 다단계 의사결정 프로세스

3. 네트워크 패턴

네트워크 패턴(Network Pattern)은 에이전트들이 직접 통신하며 협력하는 구조입니다. 중앙 조정자 없이 피어투피어(P2P) 방식으로 작동합니다.

4. 스웜 패턴

스웜 패턴(Swarm Pattern)은 많은 수의 단순한 에이전트들이 협력하여 복잡한 문제를 해결합니다. 자연의 군집 지능을 모방한 패턴입니다.

실전 코드 예제

기본 멀티 에이전트 시스템

다음은 연구 에이전트와 작성 에이전트가 협력하는 기본적인 멀티 에이전트 시스템입니다:

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_functions_agent
from langchain.tools import Tool

# 상태 정의
class AgentState(TypedDict):
    messages: Annotated[list, "메시지 리스트"]
    next_agent: str
    research_result: str
    final_output: str

# LLM 초기화
llm = ChatOpenAI(model="gpt-4", temperature=0)

# 연구 에이전트 함수
def research_agent(state: AgentState) -> AgentState:
    """주제에 대한 연구를 수행하는 에이전트"""
    messages = state["messages"]
    user_query = messages[-1]["content"]

    # 실제로는 여기서 검색 도구를 사용합니다
    research_prompt = f"다음 주제에 대해 상세히 조사하세요: {user_query}"
    research_result = llm.invoke(research_prompt).content

    return {
        **state,
        "research_result": research_result,
        "next_agent": "writer"
    }

# 작성 에이전트 함수
def writer_agent(state: AgentState) -> AgentState:
    """연구 결과를 바탕으로 콘텐츠를 작성하는 에이전트"""
    research_result = state["research_result"]

    writing_prompt = f"다음 연구 결과를 바탕으로 블로그 포스트를 작성하세요:\n\n{research_result}"
    final_output = llm.invoke(writing_prompt).content

    return {
        **state,
        "final_output": final_output,
        "next_agent": "end"
    }

# 수퍼바이저 함수 (다음 에이전트 결정)
def supervisor(state: AgentState) -> str:
    """다음 실행할 에이전트를 결정"""
    next_agent = state.get("next_agent", "researcher")

    if next_agent == "end":
        return END
    return next_agent

# 그래프 구성
workflow = StateGraph(AgentState)

# 노드 추가
workflow.add_node("researcher", research_agent)
workflow.add_node("writer", writer_agent)

# 엣지 추가
workflow.set_entry_point("researcher")
workflow.add_conditional_edges(
    "researcher",
    supervisor,
    {
        "writer": "writer",
        END: END
    }
)
workflow.add_conditional_edges(
    "writer",
    supervisor,
    {
        END: END
    }
)

# 그래프 컴파일
app = workflow.compile()

# 실행
result = app.invoke({
    "messages": [{"role": "user", "content": "LangGraph의 주요 특징"}],
    "next_agent": "researcher"
})

print(result["final_output"])

계층적 시스템 구현

더 복잡한 계층적 멀티 에이전트 시스템 예제입니다:

from langgraph.graph import StateGraph, END
from typing import TypedDict, List

class HierarchicalState(TypedDict):
    task: str
    subtasks: List[str]
    results: List[str]
    final_result: str

# 관리자 에이전트 (작업을 하위 작업으로 분해)
def manager_agent(state: HierarchicalState) -> HierarchicalState:
    """주 작업을 하위 작업들로 분해"""
    task = state["task"]

    # LLM을 사용하여 작업 분해
    decompose_prompt = f"""
    다음 작업을 3〜5개의 하위 작업으로 분해하세요:
    {task}

    각 하위 작업을 한 줄로 작성하세요.
    """

    llm = ChatOpenAI(model="gpt-4")
    response = llm.invoke(decompose_prompt).content
    subtasks = [line.strip() for line in response.split('\n') if line.strip()]

    return {
        **state,
        "subtasks": subtasks,
        "results": []
    }

# 작업자 에이전트 (하위 작업 실행)
def worker_agent(state: HierarchicalState) -> HierarchicalState:
    """하위 작업을 순차적으로 처리"""
    subtasks = state["subtasks"]
    results = []

    llm = ChatOpenAI(model="gpt-4")

    for subtask in subtasks:
        # 각 하위 작업 실행
        result = llm.invoke(f"다음 작업을 수행하세요: {subtask}").content
        results.append(result)

    return {
        **state,
        "results": results
    }

# 통합 에이전트 (결과 통합)
def integrator_agent(state: HierarchicalState) -> HierarchicalState:
    """모든 하위 작업 결과를 통합"""
    results = state["results"]
    task = state["task"]

    llm = ChatOpenAI(model="gpt-4")

    integration_prompt = f"""
    원래 작업: {task}

    하위 작업 결과들:
    {chr(10).join(f"{i+1}. {r}" for i, r in enumerate(results))}

    이 결과들을 통합하여 최종 답변을 작성하세요.
    """

    final_result = llm.invoke(integration_prompt).content

    return {
        **state,
        "final_result": final_result
    }

# 계층적 워크플로우 구성
hierarchical_workflow = StateGraph(HierarchicalState)

# 노드 추가
hierarchical_workflow.add_node("manager", manager_agent)
hierarchical_workflow.add_node("worker", worker_agent)
hierarchical_workflow.add_node("integrator", integrator_agent)

# 순차적 엣지
hierarchical_workflow.set_entry_point("manager")
hierarchical_workflow.add_edge("manager", "worker")
hierarchical_workflow.add_edge("worker", "integrator")
hierarchical_workflow.add_edge("integrator", END)

# 컴파일 및 실행
hierarchical_app = hierarchical_workflow.compile()

result = hierarchical_app.invoke({
    "task": "온라인 쇼핑몰을 위한 완전한 마케팅 전략 수립"
})

print(result["final_result"])

프로덕션 배포 가이드

필수 고려사항

프로덕션 환경에서 LangGraph를 배포할 때는 다음 사항들을 고려해야 합니다:

1. 상태 지속성
   • PostgreSQL, Redis 등을 사용한 체크포인터 구성
   • 장기 실행 작업을 위한 상태 저장

from langgraph.checkpoint.postgres import PostgresSaver

# PostgreSQL 체크포인터 설정
checkpointer = PostgresSaver.from_conn_string(
    "postgresql://user:pass@localhost/dbname"
)

app = workflow.compile(checkpointer=checkpointer)

2. 에러 처리 및 재시도

   • 각 노드에 try-except 블록 추가
   • 지수 백오프(exponential backoff) 재시도 로직

3. 모니터링 및 로깅

   • LangSmith를 활용한 추적
   • 각 에이전트의 성능 메트릭 수집

4. 비용 관리

   • LLM 호출 횟수 최적화
   • 캐싱 전략 활용

모범 사례

1. 명확한 상태 스키마 정의

   • TypedDict를 사용하여 타입 안전성 확보
   • 필요한 필드만 포함

2. 작은 단위의 에이전트 설계

   • 단일 책임 원칙 적용
   • 재사용 가능한 에이전트 구성

3. 조건부 라우팅 활용

   • 상황에 따른 동적 워크플로우
   • 불필요한 에이전트 실행 방지

4. Human-in-the-Loop 통합

   • 중요한 결정에 사람의 승인 추가
   • 품질 관리 강화

다른 프레임워크와의 비교

LangGraph vs CrewAI

특성	LangGraph	CrewAI
제어 수준	높음 (세밀한 제어 가능)	중간 (추상화 레벨 높음)
학습 곡선	가파름	완만함
유연성	매우 높음	중간
프로덕션 기능	완전함 (체크포인팅, 상태 관리)	기본적
사용 사례	복잡한 커스텀 워크플로우	빠른 프로토타이핑

LangGraph를 선택해야 할 때:

• 세밀한 제어가 필요한 프로덕션 시스템
• 복잡한 상태 관리가 필요한 경우
• 순환 워크플로우가 필요한 경우

CrewAI를 선택해야 할 때:

• 빠른 프로토타이핑이 목표
• 간단한 멀티 에이전트 시스템
• 개발 시간 단축이 중요한 경우

LangGraph vs AutoGen

특성	LangGraph	AutoGen
아키텍처	그래프 기반	대화 기반
구조화	명시적 워크플로우	자율적 대화
예측 가능성	높음	낮음
디버깅	쉬움	어려움
실행 제어	완전한 제어	제한적

LangGraph를 선택해야 할 때:

• 예측 가능한 워크플로우가 중요
• 명확한 책임 분리가 필요
• 프로덕션 안정성이 중요

AutoGen을 선택해야 할 때:

• 창의적이고 자율적인 에이전트 상호작용
• 탐색적 문제 해결
• 유연한 대화 패턴

실제 사용 사례

LinkedIn - 채용 공고 자동화

LinkedIn은 LangGraph를 사용하여 채용 공고 작성 및 최적화 시스템을 구축했습니다:

• 연구 에이전트: 업계 트렌드 및 유사 포지션 분석
• 작성 에이전트: 채용 공고 초안 작성
• SEO 에이전트: 검색 최적화
• 검토 에이전트: 규정 준수 및 품질 검사

Uber - 고객 지원 자동화

Uber는 복잡한 고객 문의를 처리하기 위해 계층적 멀티 에이전트 시스템을 구현했습니다:

• 분류 에이전트: 문의 유형 식별
• 전문 에이전트: 결제, 여행, 계정 등 도메인별 처리
• 에스컬레이션 에이전트: 복잡한 케이스 인간 상담원 연결

Replit - 코드 생성 및 디버깅

Replit은 LangGraph를 활용하여 AI 기반 코딩 어시스턴트를 개발했습니다:

• 계획 에이전트: 코딩 작업 분해
• 코더 에이전트: 실제 코드 작성
• 테스터 에이전트: 자동 테스트 실행
• 디버거 에이전트: 오류 수정

결론

LangGraph는 프로덕션급 멀티 에이전트 시스템을 구축하기 위한 강력하고 유연한 프레임워크입니다. 그래프 기반 아키텍처, 강력한 상태 관리, 다양한 아키텍처 패턴을 통해 복잡한 AI 워크플로우를 효과적으로 구현할 수 있습니다.

LangGraph를 사용해야 하는 경우:

• 복잡한 멀티 스텝 워크플로우가 필요한 경우
• 상태 지속성과 체크포인팅이 중요한 경우
• 여러 전문화된 에이전트의 협력이 필요한 경우
• 프로덕션 환경에서 안정적인 운영이 필요한 경우

2025년 10월에 출시 예정인 v1.0과 LangGraph Platform GA를 통해 더욱 강력한 기능들이 추가될 예정이니, 지금부터 LangGraph를 학습하고 실험해보는 것을 추천합니다.

참고 자료

• LangGraph 공식 문서
• LangGraph GitHub 저장소
• LangGraph 튜토리얼
• LangSmith Documentation
• Multi-Agent Systems 패턴
• LangGraph Cloud Platform