목차
- 들어가며
- AI 에이전트(AI Agent)란?
- AI 에이전트의 핵심 기능 요소
- 단일 AI 에이전트의 실제 활용
- 단일 에이전트 시스템의 한계
- 왜 멀티 에이전트 시스템(Multi-Agent-System, MAS)이 필요한가
- 멀티 에이전트 시스템의 필요성
- 멀티 에이전트 시스템의 개념과 특징
- 멀티 에이전트 시스템의 장점
- 대표적인 멀티 에이전트 아키텍처
- Swarm 아키텍처란?
- Langgraph란?
- MoA(Mixture of Agents) 아키텍처 선택 배경
- MoA 아키텍처란?
- 예제 코드
- SWARM vs Langgraph
들어가며
AI 기술이 빠르게 발전하면서, 우리는 이제 AI에게 더 많은 역할과 책임을 기대하게 되었습니다. 단순한 자동화나 반복 업무를 넘어서, 복잡한 의사결정이나 창의적인 문제 해결까지 AI의 영역이 확장되고 있는 것입니다. 이러한 변화 속에서, AI의 성능과 효율성을 극대화하기 위한 에이전트 기술의 연구와 개발도 활발히 이루어지고 있습니다.
특히 최근에는 단일 에이전트보다는 여러 에이전트를 동시에 활용하는 멀티 에이전트 시스템이 주목받고 있습니다. 각 에이전트가 서로 협력하고 역할을 분담하면서 더 복잡한 문제를 해결할 수 있기 때문입니다. 동시에, 이러한 멀티 에이전트 환경을 효율적으로 관리하고 최적화하기 위한 다양한 방법과 전략이 계속해서 개발되고 있으며, 이는 AI의 활용 범위를 한층 더 넓히는 중요한 열쇠가 되고 있습니다.
AI 에이전트(AI Agent)란?
AI 에이전트는 단순한 자동화 프로그램을 넘어, 스스로 환경을 인식하고 판단하며 행동하는 지능형 시스템입니다.
IBM은 이를 다음과 같이 정의합니다:
ol {margin-bottom:0in;margin-top:0in;}ul {margin-bottom:0in;margin-top:0in;}li {margin-top:.0in;margin-bottom:8pt;}ol.scriptor-listCounterResetlist!list-ded41739-9ab3-45a3-b0ec-d5c34b6fc6976 {counter-reset: section;}ol.scriptor-listCounterlist!list-ded41739-9ab3-45a3-b0ec-d5c34b6fc6976 {list-style-type:bullet;}li.listItemlist!list-ded41739-9ab3-45a3-b0ec-d5c34b6fc6976::before {counter-increment: section;content: none; display: inline-block;}
- “AI agent는 사용자나 다른 시스템을 대신하여 자율적으로 작업을 수행하는 시스템으로, 가용한 도구(tool)와 워크플로우를 설계해 목표를 달성한다.”
즉, AI 에이전트는 주어진 목표를 이루기 위해 상황을 해석하고, 적절한 행동 경로를 스스로 계획하고 실행할 수 있어야 합니다. 이를 위해 내부적으로 인식, 추론, 행동, 학습의 과정을 반복하면서 점점 더 똑똑해지도록 설계됩니다.
AI 에이전트의 핵심 기능 요소
AI 에이전트가 갖춰야 할 핵심 구성 요소는 다음과 같습니다
|
기능
|
설명
|
|
인식
|
에이전트는 센서, API, 사용자 인터페이스, 외부 데이터 소스 등을 통해 환경 정보를 수집하고 해석합니다. 예: 챗봇은 사용자 메시지를 텍스트로 인식하고, 로봇은 카메라·라이다 등으로 주위를 감지.
|
|
추론 및 계획
|
수집된 정보를 바탕으로 분석하고, 목표에 맞는 행동 전략을 세웁니다. 필요할 경우 외부 도구를 호출하거나 하위 작업(subtask)으로 분할하기도 합니다.
|
|
행동
|
계획된 행동을 실제로 실행하여 환경을 변화시킵니다. 예: API 호출, 데이터베이스 갱신, 사용자 응답 생성 등.
|
|
학습 및 적응
|
과거 상호작용, 결과, 오류 등을 바탕으로 성능을 점진적으로 개선하고, 환경 변화에 적응합니다. 메모리나 피드백 루프(feedback loop)를 통해 경험을 저장하고 활용합니다.
|
이들 기능은 독립적으로 분리되어 동작하기보다는 서로 긴밀히 연결되어 순환 구조처럼 작동합니다 — 인식 → 추론 → 실행 → 학습 → 다시
이런 흐름이 반복되며 점점 더 복잡한 목표도 수행하게 되는 것이죠.
단일 AI 에이전트의 실제 활용
단일 에이전트 시스템은 명확히 정의된 특정 업무에서 뛰어난 성능을 발휘합니다. 일상에서 이미 우리는 다양한 단일 AI 에이전트와 상호작용하고 있습니다. 멀티 에이전트 시스템으로 발전하기 전, 단일 에이전트가 어떻게 실제로 활용되는지 구체적인 사례를 통해 살펴보겠습니다.
범용 에이전트: 일상의 디지털 비서
Siri, Alexa, Google 어시스턴트와 같은 가상 비서는 자연어 처리 기술을 활용하여 사람의 말을 이해하고 다양한 작업을 수행합니다. 미리 알림 설정, 이메일 관리, 전화 걸기, 음악 재생, 스마트 홈 기기 제어 등 일상의 여러 업무를 처리할 수 있습니다. 이들은 사용자와의 상호작용을 통해 학습하면서 점점 더 개인화되고 효과적으로 진화하는 특징을 가지고 있습니다.
전문화된 에이전트: 특정 업무의 전문가
고객 서비스 자동화
전자상거래 기업의 AI 챗봇은 주문 처리, 배송 현황 안내, 맞춤형 상품 추천을 담당합니다. 고객 지원 에이전트는 자주 묻는 질문에 답변하고, 환불을 처리하며, 기술적 문제를 해결합니다. 이를 통해 기업은 24시간 즉각적인 고객 응대가 가능해집니다.
금융 서비스
금융 분야에서는 알고리즘 트레이딩 에이전트가 시장 데이터를 분석하여 최적의 매매 타이밍을 포착합니다. 수익 극대화와 손실 최소화를 목표로 주식과 암호화폐 거래를 자동으로 실행합니다. 또한 사기 탐지 시스템은 이상 거래 패턴을 실시간으로 감지하여 금융 범죄를 예방합니다.
제조 및 물류
룸바로 대표되는 로봇 청소기는 명확한 목표를 가진 단일 에이전트의 좋은 예입니다. '접근 가능한 모든 바닥을 청소한다'는 단순하지만 명확한 목표를 향해 자율적으로 경로를 계획하고 실행합니다. 제조 현장에서는 조립 라인 로봇이 용접, 도장, 부품 조립 등의 반복 작업을 정밀하게 수행합니다.
헬스케어
의료 분야에서는 다빈치 수술 시스템 같은 로봇 에이전트가 외과의의 손동작을 정밀하게 보조하여 최소 침습 수술을 가능하게 합니다. AI 영상 분석 에이전트는 X-ray, CT, MRI 이미지를 분석하여 의사의 진단을 돕고, 환자별 맞춤 치료 계획 수립을 지원합니다.
이러한 단일 에이전트들은 각자의 영역에서 탁월한 성능을 보이지만, 여러 도메인이 얽힌 복잡한 문제를 해결하려 할 때는 한계에 직면하게 됩니다. 이것이 바로 멀티 에이전트 시스템이 필요한 이유입니다.
단일 에이전트 시스템의 한계
단일 에이전트 시스템은 단순하거나 범위가 명확한 문제에 대해선 유용하지만, 복잡하고 동적인 환경에서는 여러 제약이 드러납니다. 아래는 주요 한계와 그 설명입니다.
|
한계
|
설명
|
|
확장성 부족
|
작업량이나 상태 공간이 커질수록 병목이 생기고 처리 능력 한계에 도달함
|
|
전문화 및 역할 분리 어려움
|
서로 다른 기능을 하나의 에이전트에 몰아넣으면 복잡성과 유지보수가 증가
|
|
단일 실패 지점
|
하나의 에이전트 오류가 전체 시스템의 기능 정지나 성능 저하로 이어질 수 있음
|
|
복잡한 상호작용 처리의 한계
|
멀티 사용자·외부 시스템 등 복잡한 상호작용을 하나의 에이전트가 감당하기 어려움
|
|
유연성·적응성 저하
|
변화에 대응하기 어렵고 수정이 전체 시스템에 영향을 미침
|
|
병렬 처리 활용 미흡
|
동시다발적 요청이나 작업을 병렬로 효율적으로 처리하기 어렵다
|
짧게 정리하면, 단일 에이전트는 설계와 구현이 간단하고 특정 상황에서는 매우 유용하지만, 복잡성·확장성·탄력성이 요구되는 현대의 많은 문제에는 한계가 있습니다. 그래서 여러 에이전트가 협력하거나 분산되어 문제를 해결하는 멀티 에이전트 시스템(Multi-Agent System) 이 주목받고 있습니다.
왜 멀티 에이전트 시스템(Multi-Agent-System, MAS)이 필요한가
멀티 에이전트 시스템의 필요성
현대의 시스템은 복합성, 규모, 다양성, 실시간성을 동시에 요구합니다.
스마트 그리드의 전력 분배, 자율주행 차량 군집, 대규모 고객지원 네트워크 등은 동시다발적인 입력과 다양한 역할, 실시간 반응이 필수입니다. 이런 환경을 단일 에이전트로 처리하면 과부하, 병목, 역할 충돌 등이 생기기 쉽습니다.
그래서 여러 자율 에이전트가 분산하여 협업·조정·역할 분담하면서 전체 시스템 목표를 달성하는 MAS 접근이 더 적합해졌습니다.
멀티 에이전트 시스템의 개념과 특징
개념(정의)
멀티 에이전트 시스템(MAS)은 여러 개의 자율 에이전트들이 동일한 환경에서 상호작용하며, 개별 또는 공동의 목표를 달성하기 위해 협력 또는 조정하는 분산형 시스템을 말합니다.
각 에이전트는 자체적인 인식, 의사결정, 행동 능력을 가지며, 전체 시스템은 이들의 상호작용으로 복잡한 문제를 풀어 나갑니다.
주요 특징
아래 네 가지 특징은 여러 공식 자료에서 공통적으로 강조되는 핵심 요소입니다:
- 자율성 : 각 에이전트는 외부 명령 없이 스스로 판단하고 행동할 수 있습니다.
- 분산 협력 : 중앙 집중 제어 없이, 여러 에이전트가 서로 협력하거나 조정하면서 문제를 해결합니다.
- 상호작용 : 에이전트들은 메시지 전달, 정보 공유, 협상, 공동 계획 등 다양한 방식으로 상호작용합니다.
- 적응성 : 환경 변화나 조건 변경에 적응할 수 있고, 에이전트가 동적으로 재구성되기도 합니다.
멀티 에이전트 시스템의 장점
멀티 에이전트 시스템이 단일 에이전트보다 강조되는 이유는 아래 장점들 때문입니다:
ol {margin-bottom:0in;margin-top:0in;}ul {margin-bottom:0in;margin-top:0in;}li {margin-top:.0in;margin-bottom:8pt;}ol.scriptor-listCounterResetlist!list-e0c11cbd-701c-411d-b168-260799df728f0 {counter-reset: section;}ol.scriptor-listCounterlist!list-e0c11cbd-701c-411d-b168-260799df728f0 {list-style-type:bullet;}li.listItemlist!list-e0c11cbd-701c-411d-b168-260799df728f0::before {counter-increment: section;content: none; display: inline-block;}
- 유연성 : 상태 변화나 요구 변경이 있을 때 에이전트를 추가·삭제하거나 조정할 수 있어 시스템 전체를 유연하게 관리할 수 있습니다.
- 확장성 : 여러 에이전트가 병렬로 운영되면 더 복잡한 문제나 더 많은 작업량을 처리할 수 있습니다.
- 도메인 전문화 : 각 에이전트가 특정 도메인 또는 역할에 특화될 수 있어, 전문화된 처리가 가능해집니다.
- 성능 향상 : 에이전트들이 자원을 공유하고, 중복 학습을 줄이며, 협업을 통해 더 나은 결과를 낼 수 있습니다.
- 견고성 / 내결함성 : 일부 에이전트가 실패하더라도 전체 시스템은 계속 작동할 수 있어 신뢰성이 높습니다.
- 현실 적합성 : 교통 제어, 공급망, 스마트시티, 로봇 군집 등처럼 분산되고 복합적인 현실 환경에 더욱 적절합니다.
- 가시성 및 최적화 : 각 에이전트의 동작을 개별적으로 모니터링할 수 있어, 병목이나 오류 지점을 찾고 최적화하기 용이하다는 이점도 최근 강조됩니다.
대표적인 멀티 에이전트 아키텍처
멀티 에이전트 시스템을 구축할 때, 적절한 프레임워크 선택은 프로젝트의 성공을 좌우하는 핵심 요소입니다. 시장에는 다양한 멀티 에이전트 프레임워크가 존재하며, 각각 고유한 설계 철학과 강점을 가지고 있습니다.
이 글에서는 대표적인 두 가지 프레임워크인 Swarm과 LangGraph를 중점적으로 다룹니다:
ol {margin-bottom:0in;margin-top:0in;}ul {margin-bottom:0in;margin-top:0in;}li {margin-top:.0in;margin-bottom:8pt;}ol.scriptor-listCounterResetlist!list-ded41739-9ab3-45a3-b0ec-d5c34b6fc6977 {counter-reset: section;}ol.scriptor-listCounterlist!list-ded41739-9ab3-45a3-b0ec-d5c34b6fc6977 {list-style-type:bullet;}li.listItemlist!list-ded41739-9ab3-45a3-b0ec-d5c34b6fc6977::before {counter-increment: section;content: none; display: inline-block;}
- Swarm: OpenAI가 개발한 Swarm은 멀티 에이전트 시스템의 핵심 개념인 루틴'과 핸드오프를 중심으로 구성되어 있습니다. 이를 통해 에이전트 간의 협업을 직관적으로 구현할 수 있습니다. Swarm은 실험적이고 학습 중심의 프레임워크로, 에이전트의 협업 패턴을 명확하게 이해하고자 하는 개발자에게 적합합니다
- LangGraph : LangChain에서 개발한 상태 기반의 오케스트레이션 프레임워크로, 복잡한 에이전트 워크플로우를 관리하고 확장하는 데 강점을 지니고 있습니다. LangGraph는 에이전트 간의 협업을 위한 고급 기능을 제공하며, 대규모 시스템 구축에 적합한 인프라를 갖추고 있습니다
이러한 이유로, Swarm과 LangGraph는 각각의 특성과 강점을 고려하여 선택되었습니다. Swarm은 실험적이고 직관적인 아키텍처를 통해 MAS의 핵심 개념을 명확하게 이해할 수 있도록 도와주며, LangGraph는 상태 기반의 확장 가능한 아키텍처를 통해 복잡한 시스템을 효과적으로 관리하고 확장할 수 있는 기능을 제공합니다.
Swarm 아키텍처란?
Swarm은 여러 에이전트를 대규모로 오케스트레이션하기 위해 설계된 멀티-에이전트 프레임워크입니다. 엔터프라이즈·프로덕션 수준의 신뢰성(로깅·에러 처리·모니터링), 다양한 멀티-에이전트 아키텍처(계층화, 병렬·순차 워크플로, 재배치 등)를 기본으로 제공하며, 여러 LLM 공급자·툴·메모리 백엔드를 유연하게 통합할 수 있도록 설계되어 있습니다.
특징 요약
ol {margin-bottom:0in;margin-top:0in;}ul {margin-bottom:0in;margin-top:0in;}li {margin-top:.0in;margin-bottom:8pt;}ol.scriptor-listCounterResetlist!list-e0c11cbd-701c-411d-b168-260799df728f1 {counter-reset: section;}ol.scriptor-listCounterlist!list-e0c11cbd-701c-411d-b168-260799df728f1 {list-style-type:bullet;}li.listItemlist!list-e0c11cbd-701c-411d-b168-260799df728f1::before {counter-increment: section;content: none; display: inline-block;}
- 생산(프로덕션) 지향: 로깅·오류 처리·모니터링·보안 기능을 갖춤.
- 다양한 아키텍처 패턴: 계층형, 병렬, 혼합 등 여러 실행 패턴을 직접 제공.
- 멀티 모델·툴 통합: OpenAI, Anthropic 등 여러 모델과 툴/플러그인 연동 지원.
- 확장성/배포 옵션: 컨테이너·클라우드 배포, 동시성·로드밸런싱 고려된 설계.
Langgraph 란?
LangGraph는 LangChain 생태계에서 나온 그래프 기반의 상태ful(상태 유지) 오케스트레이션 프레임워크입니다. 워크플로우를 그래프(노드와 엣지)로 모델링하여 에이전트·툴·상태 전이를 명시적으로 설계할 수 있고, 장기 메모리·스트리밍·휴먼-인-더-루프(검토·승인) 같은 기능을 내장해 신뢰성 있는 에이전트 애플리케이션을 만들기 쉽게 합니다. 또한 LangGraph는 오픈소스 라이브러리( MIT )와 별도로 LangGraph Platform이라는 관리형 배포·모니터링 SaaS를 제공하여, 자체 인프라를 신경쓰지 않고 배포·관찰·디버깅을 할 수 있게 합니다.
특징 요약
ol {margin-bottom:0in;margin-top:0in;}ul {margin-bottom:0in;margin-top:0in;}li {margin-top:.0in;margin-bottom:8pt;}ol.scriptor-listCounterResetlist!list-8be71cbf-d34e-4aaf-b911-b95c47621b4c2 {counter-reset: section;}ol.scriptor-listCounterlist!list-8be71cbf-d34e-4aaf-b911-b95c47621b4c2 {list-style-type:bullet;}li.listItemlist!list-8be71cbf-d34e-4aaf-b911-b95c47621b4c2::before {counter-increment: section;content: none; display: inline-block;}
- 그래프 기반 오케스트레이션: 노드(에이전트·툴)와 엣지(제어흐름)를 명확히 모델링.
- 상태(stateful) 설계: AgentState 등으로 명시적 상태 관리를 지원하며 장기 메모리 통합 가능.
- 디버깅·관찰성: LangGraph Studio(시각화/디버깅 도구), LangSmith(관찰성 통합) 등 개발자 경험(UX)에 집중.
- 오픈소스 + 플랫폼 모델: 라이브러리는 MIT 라이선스, 플랫폼(관리형)은 유료/프리미엄 옵션 존재.
MoA(Mixture of Agents) 아키텍처 선택 배경
1. 공정한 비교를 위한 동일 조건
- 두 프레임워크의 차이를 명확히 보여주기 위해서는 동일한 아키텍처 패턴을 적용해야 합니다
- MoA는 양쪽 모두에서 구현 가능하며, 각 프레임워크의 특성을 잘 드러낼 수 있는 구조입니다
2. 멀티 에이전트의 핵심 개념 시연 MoA는 멀티 에이전트 시스템의 핵심 개념을 잘 보여줍니다.
- 전문화: 각 에이전트가 특정 도메인(리스크 계산, 포트폴리오 분석, 시장 모니터링)에 집중
- 병렬 처리: 여러 에이전트가 동시에 작업 수행
- 협업: 집계자가 모든 결과를 종합하여 최종 결론 도출
- 모듈화: 각 에이전트를 독립적으로 개선하거나 교체 가능
3. 코드 이해의 용이성
- MoA는 구조가 직관적이어서 멀티 에이전트 시스템을 처음 접하는 독자도 쉽게 이해할 수 있습니다
- "분업 → 집계 → 의사결정"이라는 단순하면서도 강력한 패턴을 보여줍니다
이런 이유로, 멀티 에이전트 시스템(MAS)의 예시로 MoA(Mixture of Agents) 아키텍처를 선택했습니다. MoA는 전문화, 병렬 처리, 협업, 모듈화 등 MAS의 핵심 개념을 직관적으로 보여주며, 동일한 조건에서 다양한 프레임워크를 비교하기에도 적합합니다. 또한 구조가 명확해 처음 접하는 독자도 쉽게 이해할 수 있습니다
MoA 아키텍처란?
Swarm과 LangGraph의 실제 활용을 이해하기 위해, 이번 예제에서는 Mixture of Agents(MoA) 아키텍처를 구현했습니다.
MoA는 복잡한 문제를 해결하기 위한 협업 패턴으로, 다음과 같은 구조를 가집니다.
- 구성 : 여러 전문 에이전트(예: 위험 계산, 포트폴리오 분석, 시장 리스크 탐지)와 최종 집계 에이전트로 이루어진 구조
- 특징 : 각 에이전트가 독립적으로 작업한 뒤, 집계자가 모든 결과를 통합
- 장점 :
- 모듈화와 확장성이 뛰어남
- 각 에이전트의 전문성 극대화
- 최종 보고서를 종합적·체계적으로 제공
예제 코드
두 코드의 간단한 구성 차이
|
구분
|
Swarm
|
LangGraph
|
|
핵심 개념
|
개별 에이전트(Agents)들의 자율적 행동을 통해 집단 지능 Emergent
|
노드(Node) 기반 그래프 구조에서 언어 모델과 데이터 연결, 흐름 중심 처리
|
|
구조적 단위
|
에이전트(Agent)
|
노드(Node) / 엣지(Edge)
|
|
통신/상호작용 방식
|
에이전트 간 메시지, 신호, 환경 공유를 통한 간접적 상호작용
|
노드 간 그래프 연결을 통한 직접 데이터 흐름과 의존성 관리
|
|
데이터 처리 방식
|
분산 처리, 각 에이전트가 지역적 정보를 처리하고 공유
|
그래프 기반 처리, 노드 단위로 데이터와 연산 명시적 흐름 정의
|
|
제어 방식
|
탈중앙화, Emergent Behavior
|
중앙화/분산화 혼합 가능, 명시적 데이터 흐름 제어
|
|
목표 지향성
|
전체 시스템 목표는 Emergent, 각 에이전트는 개별 목표
|
전체 프로세스 목표를 그래프 구조로 명시, 노드 단위로 목표 수행
|
|
확장성
|
에이전트 수 증가 시 자연스럽게 확장 가능
|
그래프 노드/엣지 증가에 따라 확장 가능, 연결 구조 복잡도 증가 가능
|
|
대표적 활용 예시
|
로봇 군집 제어, 분산 의사결정, 시뮬레이션
|
LLM 기반 데이터 파이프라인, 지식 그래프, 멀티모달 처리
|
.env 파일
# .env
AGENT_MODEL_NAME=gpt-5-nano
AGENT_MAX_LOOPS=3
API_HOST=0.0.0.0
API_PORT=8000
LOG_LEVEL=info
OPENAI_API_KEY = ""
OLLAMA_BASE_URL = ""
OLLAMA_API_BASE = ${OLLAMA_BASE_URL}
ANTHROPIC_API_KEY=""
AGENT_MODEL_NAME=gpt-4o-mini
Swarm 예제 코드
# swarms_main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from swarms import Agent, MixtureOfAgents
import uvicorn
from typing import Optional
import time
from dotenv import load_dotenv
import os
load_dotenv()
MODEL_NAME = os.getenv("AGENT_MODEL_NAME", "gpt-4o-mini")
app = FastAPI(
title="Swarms 3-Layer MoA API",
description="REST API for a 3-layer Mixture-of-Agents system (gpt-5 + qwen3)",
version="0.0.1"
)
class SwarmRequest(BaseModel):
task: str
max_loops: Optional[int] = 1
class SwarmResponse(BaseModel):
success: bool
result: str
execution_time: Optional[float] = None
risk_metrics_agent = Agent(
agent_name="Risk-Metrics-Calculator",
agent_description="Calculates key risk metrics like VaR, Sharpe ratio, and volatility",
system_prompt="""You are a risk metrics specialist. Calculate and explain:
- Value at Risk (VaR)
- Sharpe ratio
- Volatility
- Maximum drawdown
- Beta coefficient
Provide clear, numerical results with brief explanations.""",
max_loops=1,
model_name=MODEL_NAME, # ollama/llama3.1
random_model_enabled=False,
dynamic_temperature_enabled=True,
output_type="str-all-except-first",
max_tokens=4096,
)
portfolio_risk_agent = Agent(
agent_name="Portfolio-Risk-Analyzer",
agent_description="Analyzes portfolio diversification and concentration risk",
system_prompt="""You are a portfolio risk analyst. Focus on:
- Portfolio diversification analysis
- Concentration risk assessment
- Correlation analysis
- Sector/asset allocation risk
- Liquidity risk evaluation
Provide actionable insights for risk reduction.""",
max_loops=1,
model_name=MODEL_NAME, # ollama/llama3.1
random_model_enabled=False,
dynamic_temperature_enabled=True,
output_type="str-all-except-first",
max_tokens=4096,
)
market_risk_agent = Agent(
agent_name="Market-Risk-Monitor",
agent_description="Monitors market conditions and identifies risk factors",
system_prompt="""You are a market risk monitor. Identify and assess:
- Market volatility trends
- Economic risk factors
- Geopolitical risks
- Interest rate risks
- Currency risks
Provide current risk alerts and trends.""",
max_loops=1,
model_name=MODEL_NAME, # ollama/llama3.1
random_model_enabled=False,
dynamic_temperature_enabled=True,
output_type="str-all-except-first",
max_tokens=4096,
)
aggregator = Agent(
agent_name="Strategic-Aggregator",
agent_description="Synthesizes analyses from all agents to provide strategic recommendations",
system_prompt="""You are a strategic decision aggregator responsible for:
1. Synthesizing specialist analyses
2. Identifying key insights
3. Evaluating trade-offs
4. Making recommendations
5. Providing action plans""",
max_loops=1,
# model_name=MODEL_NAME, # ollama/llama3.1
# random_model_enabled=False,
# dynamic_temperature_enabled=True,
output_type="str-all-except-first",
max_tokens=4096,
allow_fallback=False,
)
swarm = MixtureOfAgents(
agents=[
risk_metrics_agent,
portfolio_risk_agent,
market_risk_agent,
],
aggregator_agent=aggregator,
aggregator_system_prompt="""Synthesize the analyses from all specialists to provide:
1. Comprehensive situation analysis
2. Key opportunities and risks
3. Strategic recommendations
4. Implementation considerations
5. Success metrics""",
aggregator_model_name=MODEL_NAME,
layers=1,
max_loops=1,
output_type="final",
)
@app.get("/")
async def root():
return {"message": "3-Layer Swarm API is running!", "status": "healthy"}
@app.post("/swarm/run", response_model=SwarmResponse)
async def run_swarm(request: SwarmRequest):
try:
start_time = time.time()
result = swarm.run(request.task)
exec_time = time.time() - start_time
return SwarmResponse(
success=True,
result=str(result),
execution_time=exec_time
)
except Exception as e:
raise HTTPException(status_code=500, detail=f"Swarm execution failed: {str(e)}")
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)
Langgraph 예제 코드
# langgraph_main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional
import time
from typing import TypedDict
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_ollama import ChatOllama
from langchain.prompts import PromptTemplate, ChatPromptTemplate
import uvicorn
import os
from dotenv import load_dotenv
load_dotenv()
MODEL_NAME = os.getenv("AGENT_MODEL_NAME", "gemma3:27b")
app = FastAPI(
title="LangGraph 3-Layer MoA API",
description="REST API for a 3-layer Mixture-of-Agents system (LangGraph: gpt-5 + qwen3)",
version="0.0.1"
)
class LangGraphRequest(BaseModel):
task: str
max_loops: Optional[int] = 1
class LangGraphResponse(BaseModel):
success: bool
result: str
execution_time: Optional[float] = None
# ===== Graph State =====
class GraphState(TypedDict, total=False):
task: str
risk_metrics: str
portfolio_risk: str
market_risk: str
final: str
def get_agent(model_name: str, prompt: str, temperature: float = 0.7):
if "gpt" in model_name.lower():
model = ChatOpenAI(model=model_name, temperature=temperature)
else:
ollama_base_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
model = ChatOllama(
model=model_name,
temperature=temperature,
base_url=ollama_base_url
)
system_prompt = ChatPromptTemplate.from_messages([
("system", prompt),
("user", "{input}")
])
return system_prompt | model
risk_metrics_prompt = """You are a risk metrics specialist. Calculate and explain:
- Value at Risk (VaR)
- Sharpe ratio
- Volatility
- Maximum drawdown
- Beta coefficient
Provide clear, numerical results with brief explanations.
"""
portfolio_risk_prompt = """You are a portfolio risk analyst. Focus on:
- Portfolio diversification analysis
- Concentration risk assessment
- Correlation analysis
- Sector/asset allocation risk
- Liquidity risk evaluation
Provide actionable insights for risk reduction.
"""
market_risk_prompt = """You are a market risk monitor. Identify and assess:
- Market volatility trends
- Economic risk factors
- Geopolitical risks
- Interest rate risks
- Currency risks
Provide current risk alerts and trends.
"""
aggregator_prompt = """You are a strategic decision aggregator responsible for:
1. Synthesizing specialist analyses
2. Identifying key insights
3. Evaluating trade-offs
4. Making recommendations
5. Providing action plans
Combine the provided proposals into a single, coherent, prioritized report.
"""
# ===== Agents =====
risk_metrics_proposer = get_agent(MODEL_NAME, risk_metrics_prompt)
portfolio_risk_proposer = get_agent(MODEL_NAME, portfolio_risk_prompt)
market_risk_proposer = get_agent(MODEL_NAME, market_risk_prompt)
aggregator = get_agent(MODEL_NAME, aggregator_prompt, temperature=0.3)
# ===== Nodes =====
def risk_metrics_proposer_node(state: GraphState) -> GraphState:
task = state["task"]
resp = risk_metrics_proposer.invoke(task)
return {"risk_metrics": resp.content}
def portfolio_risk_proposer_node(state: GraphState) -> GraphState:
task = state["task"]
resp = portfolio_risk_proposer.invoke(task)
return {"portfolio_risk": resp.content}
def market_risk_proposer_node(state: GraphState) -> GraphState:
task = state["task"]
resp = market_risk_proposer.invoke(task)
return {"market_risk": resp.content}
def aggregator_node(state: GraphState) -> GraphState:
proposals = []
if "risk_metrics" in state:
proposals.append(("Risk Metrics Proposer", state["risk_metrics"]))
if "portfolio_risk" in state:
proposals.append(("Portfolio Risk Proposer", state["portfolio_risk"]))
if "market_risk" in state:
proposals.append(("Market Risk Proposer", state["market_risk"]))
joined = "\n\n---\n\n".join(f"{agent}:\n{content}" for agent, content in proposals)
resp = aggregator.invoke(joined)
return {**state, "final": resp.content}
# ===== Build Graph =====
def build_graph():
workflow = StateGraph(GraphState)
workflow.add_node("risk_metrics_state", risk_metrics_proposer_node)
workflow.add_node("portfolio_risk_state", portfolio_risk_proposer_node)
workflow.add_node("market_risk_state", market_risk_proposer_node)
workflow.add_node("aggregator", aggregator_node)
workflow.set_entry_point("risk_metrics_state")
workflow.set_entry_point("portfolio_risk_state")
workflow.set_entry_point("market_risk_state")
workflow.add_edge("risk_metrics_state", "aggregator")
workflow.add_edge("portfolio_risk_state", "aggregator")
workflow.add_edge("market_risk_state", "aggregator")
workflow.add_edge("aggregator", END)
return workflow.compile()
graph = build_graph()
# ===== API Endpoint =====
@app.post("/langgraph/run", response_model=LangGraphResponse)
async def run_langgraph(request: LangGraphRequest):
try:
print(f"Using MODEL_NAME: {MODEL_NAME}")
start_time = time.time()
result = graph.invoke({"task": request.task})
exec_time = time.time() - start_time
return LangGraphResponse(
success=True,
result=result["final"],
execution_time=exec_time
)
except Exception as e:
raise HTTPException(status_code=500, detail=f"LangGraph execution failed: {str(e)}")
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8001)
예제 실행 코드
# multi_agent_test.ipynb
# conda create -n swarm_env python=3.11 -y
# conda activate swarm_env
# pip install swarms fastapi uvicorn requests python-dotenv langgraph langchain-openai langchain-ollama langchain
# python swarm_main.py
# python langgraph_main.py
#-------------------------------------------------------------------------
import requests
task = "Calculate VaR and Sharpe ratio for a portfolio with 15% annual return and 20% volatility"
response = requests.post(
"http://localhost:8000/swarm/run",
json={"task": task}
)
if response.status_code == 200:
print("Swarm Result:")
print(response.json())
else:
print("Swarm API Error:", response.text)
#------------------------------------------------------
response = requests.post(
"http://localhost:8001/langgraph/run",
json={"task": task}
)
if response.status_code == 200:
print("LangGraph Result:")
print(response.json())
else:
print("LangGraph API Error:", response.text)
SWARM vs Langgraph
아래 표는 Swarm과 LangGraph를 핵심 요소만 간추려 비교한 내용입니다. 블로그 독자가 예제 코드 이후 어떤 프레임워크를 선택할지 직관적으로 이해할 수 있도록 구성했습니다.
|
구분
|
Swarm
|
LangGraph
|
|
핵심 개념
|
다양한 멀티에이전트 실행 패턴을 지원하는 프로덕션 지향 프레임워크
|
워크플로우를 그래프(노드·엣지) 로 모델링하는 상태 기반 오케스트레이션
|
|
강점
|
확장성, 배포·모니터링, 보안 등 엔터프라이즈 환경 최적화
|
시각화·디버깅 도구(LangGraph Studio), 상태 관리, LangChain 생태계 연동
|
|
단점
|
초기 설정·운영이 복잡, 학습 곡선이 있음
|
그래프 개념 학습 필요, 엔터프라이즈급 보안·배포 기능은 상대적으로 약함
|
|
사용자 대상
|
대규모 운영·프로덕션 환경이 필요한 기업 팀
|
대화형 서비스·실험적 프로젝트·LangChain 기반 앱 개발자
|
멀티 에이전트 시스템을 실제로 적용하려면 프레임워크 선택이 중요합니다.
- Swarm은 엔터프라이즈 환경에서의 안정성, 확장성, 배포·모니터링 지원에 강점을 가진 반면, 초기 설정과 운영이 다소 복잡합니다.
- LangGraph는 시각화, 디버깅, 상태 관리가 용이하며 실험적 프로젝트나 LangChain 기반 앱 개발에 최적화되어 있습니다.
이번 글에서 다룬 예제 코드는 Mixture-of-Agents(MoA) 아키텍처를 기준으로 작성되었습니다. 실제 서비스 환경이나 연구 목적에 맞게 프레임워크를 선택하고, 에이전트 설계·배포 전략을 고민하는 것이 MAS 도입 성공의 핵심입니다.
멀티 에이전트 시스템은 단일 에이전트로는 해결하기 어려운 복잡한 분산 문제를 모듈화, 병렬화, 전문화하여 처리할 수 있는 강력한 패러다임입니다. 앞으로 더 많은 실험과 상용 사례가 쌓이면서, 개발자와 기업 모두에게 보다 안정적이고 유연한 MAS 도구 선택지가 늘어날 것으로 기대됩니다.
