반응형
2025년은 AI 에이전트가 핫할 것이라는 것은 이제 많은 사람들이 알 것이다. 그러면 그냥 나에게 주어진 제품을 사용하듯이 사용할 수 있을까? 아니 회사들이 제품으로 제공하는 AI 에이전트만 사용하면 되는 것일까라는 질문이 맞을 것 같다. AI 에이전트가 하루가 다르게 진화하고 있고 어느 정도 안정적인 기능을 제공하는 시점에 접해도 될 것이라고 생각할 수도 있다고 본다.
하지만, AI 에이전트와 함께 내 삶의 변화를 주도하고 싶은 사람이라면 좀 더 적극적으로 AI 에이전트를 내 삶에 적용하고 싶을 것이고 그 방법을 모색해 볼 것이라고 생각한다.
그런 의미에서 AI 에이전트를 나에게 맞춤형으로 만들어 나가는 것은 개발자 뿐만 아니라 일반인들에게도 필수?가 된 것이 아닐까 싶다. 물론 예전처럼 직접 코딩을 하기 위해서 프로그래밍 언어를 배우고 직접 코딩을 해야 한다면 개발자들이 개발한 AI 에이전트를 사용하는 것에 만족해야 하겠지만, 이제 우리의 언어로 코딩을 도와주는 도구들(Cursor AI, n8n + MCP 등)을 사용해서 어느 정도 필요한 기능을 쉽게 내 로컬 컴퓨터에 설치해서 사용할 수 있게 되었다.
일반인들도 AI의 도움을 받아 본인의 맞춤형 니즈를 충족시킬 수 있게 되었기 때문에 자신의 컴퓨터에 설치할 AI 에이전트에 대한 AI 에이전트 프레임워크를 배워야 한다고 생각한다.
다음 내용은 클로드 AI가 '일반인들이 AI에이전트 프레임워크를 배워야 하는 이유'에 대해 말해준 내용이다.
일반인들이 AI 에이전트 프레임워크를 배워야 하는 이유
1. 맞춤형 솔루션 구축
일반적인 AI 도구들은 '원 사이즈 핏츠 올' 접근 방식을 취하고 있어서 특정 니즈를 완벽히 충족시키지 못합니다.
에이전트 프레임워크를 이해하면 자신만의 맞춤형 AI 도우미를 구축할 수 있습니다.
예를 들어, 소규모 비즈니스 운영자라면 마케팅, 고객 서비스, 재고 관리를 자동화하는 자신만의 특화된 AI 팀을 만들 수 있습니다.
2. 디지털 자율성 확보
기성품 AI 솔루션에 의존하면 다른 회사의 우선순위와 비즈니스 모델에 종속됩니다.
에이전트 프레임워크를 활용할 줄 알면 데이터, 프라이버시, 작업 방식에 대한 통제권을 유지할 수 있습니다.
3. 업무 자동화의 민주화
프로그래밍 기술이 없어도, 기본적인 에이전트 프레임워크 지식만으로도 복잡한 워크플로우를 자동화할 수 있습니다.
특히 CrewAI와 같은 프레임워크는 비개발자도 쉽게 사용할 수 있게 설계되어 있어 기술적 진입 장벽을 낮추고 있습니다.
4. 경쟁 우위 확보
AI 기술 활용 능력은 점점 더 중요한 차별화 요소가 되고 있습니다.
단순히 AI를 사용하는 것을 넘어 자신의 요구에 맞게 조정할 수 있는 능력은 어떤 분야에서든 경쟁 우위를 제공합니다.
5. 개인 생산성의 비약적 향상
일반 사용자도 간단한 에이전트 시스템을 구축하여 일상 업무(예: 이메일 분류, 정보 수집, 콘텐츠 요약)를 자동화할 수 있습니다.
생산성 향상 도구를 자신의 워크플로우에 정확히 맞출 수 있다는 점이 핵심입니다.
6. AI 이해도 향상
에이전트 프레임워크를 배우는 과정은 AI가 실제로 어떻게 작동하는지에 대한 깊은 이해를 제공합니다.
이는 단순히 도구를 사용하는 것보다 훨씬 가치 있는 지식입니다.
일반인을 위한 접근 방식
기술적인 깊이에 압도되지 않도록, 일반인을 대상으로 할 때는:
- 단계적 학습 경로 제공: 코딩 경험이 적은 사람들도 쉽게 시작할 수 있는 간단한 프로젝트부터 시작하도록 합니다.
- 실제 사례 중심: 개발자가 아닌 사람들도 공감할 수 있는 일상적인 문제 해결 사례(예: 정보 수집, 콘텐츠 요약, 이메일 관리)를 중심으로 설명합니다.
- 저코드/노코드 옵션 강조: CrewAI와 같이 상대적으로 진입 장벽이 낮은 프레임워크나, 앞으로 등장할 시각적 인터페이스를 강조합니다.
핵심은 "AI 에이전트를 프로그래밍하는 법"을 가르치는 것이 아니라, "자신만의 디지털 조수를 설계하고 지시하는 법"을 가르치는 접근 방식이 효과적일 것입니다.
이렇게 하면 기술적 배경이 없는 사람들도 이 강력한 도구를 활용하여 자신의 삶과 업무를 혁신할 수 있습니다.
위에 클로드AI가 지적한 배움의 이유가 맞다고 생각하시나요?
그렇다면 다음에 기술한 3가지 프레임워크에 대한 기초정보를 읽어보시면 좋을 것 같다.
2025년 주요 AI 에이전트 프레임워크 비교: LangGraph vs CrewAI vs AutoGen
프레임워크 비교표
특성LangGraphCrewAIAutoGen (AG2)| 개발사/지원 | LangChain 팀 | Joao Moura(개인 개발자) | Microsoft |
| 오픈소스 | ✅ | ✅ | ✅ |
| 주요 개념 | 상태 관리를 갖춘 그래프 기반 워크플로우 | 역할 기반 AI 팀(Crew) 협업 시스템 | 액터 모델 기반 분산 에이전트 시스템 |
| 설계 접근법 | 명시적 그래프 상태/전환 | 역할 기반 협업 | 대화 기반 다중 에이전트 |
| 언어 지원 | Python, JavaScript | Python 전용 | Python, .NET |
| 기본 구조 | 노드와 엣지로 이루어진 그래프 | 역할, 태스크, 크루(팀) | 액터 기반 에이전트 |
| 상태 관리 | 강력한 내장 상태 관리 | 기본 상태 관리 | 대화 기록 기반 |
| 인간 참여 | Human-in-the-loop 지원 | 제한적 지원 | 강력한 Human-in-the-loop 지원 |
| 확장성 | 중간 | 중간 | 높음 (분산 시스템 지원) |
| 모델 지원 | 다양한 LLM 지원 | 다양한 LLM 지원 | 다양한 LLM 지원 |
| 도구 통합 | LangChain 도구 활용 | 자체 도구 시스템 | 강력한 도구 통합 시스템 |
| 메모리 시스템 | 단기 및 장기 메모리 지원 | 기본 메모리 | 대화 기반 메모리 |
| 최신 버전 | 0.2.70 (2025년 2월) | 0.100.1 (2025년 1월) | 최신 AG2 버전 |
| 기업 채택 | Replit, Uber, LinkedIn, GitLab 등 | 다양한 기업 | Microsoft 생태계 |
| 복잡성 | 중간-높음 | 낮음-중간 | 중간-높음 |
| 초보자 친화도 | 중간 | 높음 | 중간 |
| 유스케이스 | 복잡한 워크플로우, 대화형 에이전트 | 명확한 역할 구분이 필요한 태스크 | 분산 환경, 대화 기반 협업 태스크 |
적합한 사용 시나리오
- LangGraph: 복잡한 상태 관리가 필요한 워크플로우, 대화형 에이전트, 조건부 로직이 필요한 시스템
- CrewAI: 명확한 역할 구분이 필요한 팀 기반 태스크, 간단하고 직관적인 에이전트 시스템 구축
- AutoGen: 분산 환경에서의 확장 가능한 시스템, Microsoft 제품과의 통합, 자유로운 대화 기반 다중 에이전트 시스템
LangGraph 개념 및 코딩 기초 자료
1. LangGraph란?
LangGraph는 LangChain 팀에서 개발한 상태 관리 기능을 갖춘 AI 에이전트 프레임워크로, LLM 기반 애플리케이션에서 복잡한 워크플로우를 구현할 수 있게 해줍니다. 주요 특징은 다음과 같습니다:
- 상태 관리: 대화 및 태스크의 상태를 명시적으로 관리
- 그래프 기반 워크플로우: 노드와 엣지를 통한 직관적인 워크플로우 정의
- 사이클 지원: 반복적인 작업이나 피드백 루프 구현 가능
- 조건부 로직: 상황에 따른 다양한 실행 경로 정의
- Human-in-the-loop: 인간 피드백과 상호작용 지원
LangGraph는 그래프 구조를 통해 AI 에이전트의 행동과 상태 변화를 명시적으로 모델링하는 강력한 도구입니다.
2. 핵심 개념
2.1 노드(Node)
노드는 에이전트가 수행하는 특정 기능이나 상태를 나타냅니다. 각 노드는 입력을 받아 처리하고 출력을 생성하는 함수입니다.
2.2 엣지(Edge)
엣지는 노드 간의 연결을 정의하며, 워크플로우의 흐름을 결정합니다. 조건부 엣지를 통해 상황에 따라 다른 경로로 이동할 수 있습니다.
2.3 상태(State)
LangGraph의 핵심 기능으로, 대화나 작업의 진행 상황을 저장하고 관리합니다. 상태는 메시지 기록, 에이전트 정보, 도구 호출 결과 등을 포함할 수 있습니다.
2.4 스트리밍(Streaming)
LangGraph는 실시간 스트리밍을 지원하여 대화형 애플리케이션에서 점진적인 응답을 제공할 수 있습니다.
3. 기본 구조 및 설치
3.1 설치 방법
pip install langgraph
3.2 기본적인 사용 구조
from langgraph.graph import StateGraph
from langgraph.prebuilt import create_react_agent
import operator
from typing import TypedDict, List, Dict, Any
# 상태 정의
class State(TypedDict):
messages: List[Dict[str, Any]]
# 그래프 생성
graph = StateGraph(State)
# 노드 추가
graph.add_node("agent", agent_function)
graph.add_node("tools", tools_function)
# 엣지 추가
graph.add_edge("agent", "tools")
graph.add_edge("tools", "agent")
# 조건부 엣지 추가
graph.add_conditional_edges(
"agent",
lambda state: state["next_step"],
{
"continue": "tools",
"finish": END
}
)
# 그래프 컴파일
chain = graph.compile()
4. 간단한 예제: ReAct 에이전트 구현
다음은 LangGraph를 사용하여 ReAct(Reasoning and Acting) 에이전트를 구현하는 예제입니다.
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
import os
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
# 도구 정의
@tool
def search(query: str) -> str:
"""인터넷에서 정보를 검색합니다."""
# 실제 구현에서는 실제 검색 API를 사용할 수 있습니다
return f"'{query}'에 대한 검색 결과입니다."
@tool
def calculator(expression: str) -> str:
"""수학 표현식을 계산합니다."""
try:
return str(eval(expression))
except Exception as e:
return f"계산 오류: {str(e)}"
# 도구 목록 생성
tools = [search, calculator]
# LLM 모델 설정
llm = ChatOpenAI(model="gpt-4")
# ReAct 에이전트 생성
agent = create_react_agent(llm, tools)
# 에이전트 실행
response = agent.invoke({
"messages": [
{"role": "user", "content": "서울의 인구는 얼마이고, 그 숫자의 제곱근은 얼마인가요?"}
]
})
print(response)
5. 고급 예제: 다중 에이전트 워크플로우
여러 전문가 에이전트가 협력하는 다중 에이전트 시스템을 구현해 보겠습니다.
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage
from langgraph.graph import StateGraph, END
from typing import TypedDict, List, Dict, Annotated, Union
import operator
# 상태 정의
class AgentState(TypedDict):
messages: List[Dict[str, str]]
current_agent: str
# 에이전트 생성 함수
def create_agent(name, system_prompt):
llm = ChatOpenAI(model="gpt-3.5-turbo")
def agent_function(state):
messages = state["messages"]
agent_messages = [
{"role": "system", "content": system_prompt},
*messages
]
response = llm.invoke(agent_messages)
return {
"messages": [*messages, {"role": "assistant", "content": f"{name}: {response.content}"}],
"current_agent": "supervisor" # 항상 감독 에이전트로 돌아감
}
return agent_function
# 감독자 에이전트 생성
def supervisor_function(state):
messages = state["messages"]
supervisor_llm = ChatOpenAI(model="gpt-4")
system_prompt = """
당신은 여러 전문가 에이전트의 작업을 조율하는 감독자입니다.
다음 에이전트 중 하나를 선택하여 현재 질문에 가장 적합한 에이전트를 지정하세요:
1. researcher - 연구 및 정보 수집
2. analyst - 데이터 분석 및 해석
3. writer - 보고서 및 콘텐츠 작성
4. done - 모든 작업이 완료됨
'에이전트: [선택한 에이전트 이름]' 형식으로 응답하세요.
"""
agent_messages = [
{"role": "system", "content": system_prompt},
*messages
]
response = supervisor_llm.invoke(agent_messages)
response_text = response.content
if "에이전트: done" in response_text or "agent: done" in response_text.lower():
return {
"messages": [*messages, {"role": "assistant", "content": f"Supervisor: 작업이 완료되었습니다."}],
"current_agent": "done"
}
# 선택된 에이전트 추출
import re
agent_match = re.search(r'에이전트: (\w+)|agent: (\w+)', response_text, re.IGNORECASE)
next_agent = agent_match.group(1) if agent_match else "researcher"
return {
"messages": [*messages, {"role": "assistant", "content": f"Supervisor: {next_agent} 에이전트에게 작업을 할당합니다."}],
"current_agent": next_agent
}
# 에이전트 생성
researcher = create_agent("Researcher", "당신은 정보를 검색하고 수집하는 연구원입니다.")
analyst = create_agent("Analyst", "당신은 데이터를 분석하고 인사이트를 도출하는 분석가입니다.")
writer = create_agent("Writer", "당신은 보고서와 콘텐츠를 작성하는 작가입니다.")
# 그래프 생성
workflow = StateGraph(AgentState)
# 노드 추가
workflow.add_node("supervisor", supervisor_function)
workflow.add_node("researcher", researcher)
workflow.add_node("analyst", analyst)
workflow.add_node("writer", writer)
# 조건부 라우팅
def route_agent(state):
return state["current_agent"]
# 엣지 추가
workflow.add_conditional_edges(
"supervisor",
route_agent,
{
"researcher": "researcher",
"analyst": "analyst",
"writer": "writer",
"done": END
}
)
# 모든 에이전트가 작업 후 감독자에게 돌아가도록 설정
workflow.add_edge("researcher", "supervisor")
workflow.add_edge("analyst", "supervisor")
workflow.add_edge("writer", "supervisor")
# 그래프 컴파일
chain = workflow.compile()
# 실행
result = chain.invoke({
"messages": [{"role": "user", "content": "2025년 인공지능 기술 동향에 대한 보고서를 작성해주세요."}],
"current_agent": "supervisor"
})
# 결과 출력
for message in result["messages"]:
if message["role"] == "user":
print(f"User: {message['content']}")
elif message["role"] == "assistant":
print(f"{message['content']}")
6. 주요 장점 및 사용 사례
장점
- 명시적인 상태 관리로 복잡한 워크플로우 구현 가능
- 그래프 구조를 통한 직관적인 설계
- 조건부 로직과 반복 구조 지원
- LangChain 생태계와의 통합
사용 사례
- 복잡한 대화형 에이전트
- 다단계 의사결정 시스템
- 인간-AI 협업 시스템
- 데이터 처리 및 분석 파이프라인
- 고객 응대 및 지원 시스템
7. LangGraph 개발 팁
- 그래프 디자인 먼저: 코딩 전에 그래프 구조를 스케치하고 설계하세요.
- 상태 설계: 상태에 필요한 정보를 명확히 정의하세요.
- 점진적 확장: 간단한 그래프부터 시작하여 점진적으로 복잡도를 높이세요.
- 테스트 자동화: 각 노드와 엣지의 기능을 개별적으로 테스트하세요.
- 오류 처리: 예외 상황에 대한 처리 로직을 포함하세요.
8. 참고 자료
CrewAI 개념 및 코딩 기초 자료
1. CrewAI란?
CrewAI는 역할 기반의 AI 에이전트 팀을 구성하여 복잡한 작업을 해결할 수 있는 프레임워크입니다. 실제 조직이나 회사처럼 각 에이전트가 특정 역할, 목표, 배경 스토리를 가지고 협업하는 개념을 중심으로 설계되었습니다. 2025년 현재 버전 0.100.1로, 다음과 같은 특징을 가집니다:
- 역할 기반 설계: 각 에이전트가 명확한 역할과 책임을 가짐
- 자율적 협업: 에이전트 간 자연스러운 작업 위임과 협력
- 유연한 태스크 관리: 목표 지향적 태스크 할당 및 실행
- 프로세스 중심 실행: 구조화된 워크플로우 정의
- 독립적 아키텍처: LangChain 등 다른 프레임워크에 대한 의존성 없음
2. 핵심 개념
2.1 Agent(에이전트)
특정 역할, 목표, 배경 스토리를 가진 AI 에이전트입니다. 각 에이전트는 자신의 전문 분야에 따라 태스크를 수행합니다.
2.2 Task(태스크)
에이전트가 수행해야 할 특정 작업입니다. 각 태스크는 설명, 예상 결과, 할당된 에이전트를 가집니다.
2.3 Crew(크루)
여러 에이전트로 구성된 팀으로, 복잡한 목표를 달성하기 위해 함께 작업합니다. 크루는 에이전트와 태스크를 관리하고 실행 프로세스를 조율합니다.
2.4 Process(프로세스)
태스크 실행 방식을 정의합니다. 순차적, 병렬 또는 우선순위 기반으로 작업을 수행할 수 있습니다.
2.5 Tool(도구)
에이전트가 사용할 수 있는 외부 도구나 기능으로, API 호출, 데이터 검색, 계산 등을 수행할 수 있습니다.
3. 기본 구조 및 설치
3.1 설치 방법
# 기본 설치
pip install crewai
# 추가 도구 포함 설치
pip install 'crewai[tools]'
3.2 기본적인 사용 구조
from crewai import Agent, Task, Crew, Process
# 에이전트 생성
agent1 = Agent(
role="역할명",
goal="목표",
backstory="배경 스토리",
verbose=True
)
# 태스크 생성
task1 = Task(
description="작업 설명",
expected_output="예상 결과",
agent=agent1
)
# 크루 생성
crew = Crew(
agents=[agent1, agent2],
tasks=[task1, task2],
process=Process.sequential # 순차적 실행
)
# 크루 실행
result = crew.kickoff()
4. 간단한 예제: 리서치 팀 구성
다음은 CrewAI를 사용하여 리서치 팀을 구성하는 간단한 예제입니다.
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI
import os
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
# LLM 모델 설정
llm = ChatOpenAI(model="gpt-4")
# 에이전트 생성
researcher = Agent(
role="연구원",
goal="주제에 대한 깊이 있는 정보 수집",
backstory="당신은 10년 경력의 전문 리서처로, 다양한 주제에 대한 심층적인 정보를 수집하고 분석하는 전문가입니다.",
verbose=True,
llm=llm
)
analyst = Agent(
role="데이터 분석가",
goal="수집된 정보를 분석하고 인사이트 도출",
backstory="당신은 데이터를 통해 통찰력을 발견하는 데이터 분석 전문가입니다. 복잡한 정보를 이해하기 쉽게 정리하는 능력이 뛰어납니다.",
verbose=True,
llm=llm
)
writer = Agent(
role="기술 작가",
goal="분석된 정보를 명확하고 이해하기 쉽게 보고서로 작성",
backstory="당신은 복잡한 기술 정보를 명확하고 간결하게 전달하는 기술 작가입니다. 독자가 쉽게 이해할 수 있는 콘텐츠를 만드는 전문가입니다.",
verbose=True,
llm=llm
)
# 태스크 생성
research_task = Task(
description="2025년 인공지능 기술 동향에 대한 정보를 수집하세요. 주요 기술, 주요 기업, 최신 연구 동향을 포함해야 합니다.",
expected_output="주요 AI 기술 동향에 대한 상세 정보와 출처가 포함된 보고서",
agent=researcher
)
analysis_task = Task(
description="수집된 인공지능 기술 동향 정보를 분석하고, 주요 트렌드와 미래 전망에 대한 인사이트를 도출하세요.",
expected_output="주요 트렌드, 성장 분야, 미래 전망이 포함된 분석 보고서",
agent=analyst,
context=[research_task] # 연구 태스크의 결과를 컨텍스트로 제공
)
writing_task = Task(
description="분석된 정보를 바탕으로 '2025년 인공지능 기술 동향 및 전망' 보고서를 작성하세요. 경영진이 이해하기 쉽게 작성해야 합니다.",
expected_output="경영진을 위한 최종 보고서 (5-10 페이지)",
agent=writer,
context=[research_task, analysis_task] # 이전 두 태스크의 결과를 컨텍스트로 제공
)
# 크루 생성
research_crew = Crew(
agents=[researcher, analyst, writer],
tasks=[research_task, analysis_task, writing_task],
process=Process.sequential, # 순차적 실행
verbose=2 # 자세한 로그 출력
)
# 크루 실행
result = research_crew.kickoff(inputs={"topic": "2025년 인공지능 기술 동향"})
print(result)
6. 프로세스 유형 및 병렬 처리
CrewAI는 다양한 프로세스 유형을 지원하여 태스크 실행 방식을 유연하게 제어할 수 있습니다.
6.1 프로세스 유형
from crewai import Process
# 순차적 프로세스 - 태스크를 순서대로 하나씩 실행
crew_sequential = Crew(
agents=[agent1, agent2, agent3],
tasks=[task1, task2, task3],
process=Process.sequential
)
# 병렬 프로세스 - 모든 태스크를 동시에 실행
crew_parallel = Crew(
agents=[agent1, agent2, agent3],
tasks=[task1, task2, task3],
process=Process.parallel
)
# 우선순위 기반 프로세스 - 태스크 간 의존성에 따라 실행
crew_hierarchical = Crew(
agents=[agent1, agent2, agent3],
tasks=[task1, task2, task3],
process=Process.hierarchical
)
6.2 병렬 처리 예제
병렬로 여러 주제에 대한 리서치를 수행하는 예제입니다.
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI
import os
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
# LLM 모델 설정
llm = ChatOpenAI(model="gpt-4")
# 리서처 에이전트 생성
researcher = Agent(
role="연구원",
goal="주제에 대한 깊이 있는 정보 수집",
backstory="당신은 다양한 주제에 대한 정보를 효율적으로 수집하는 전문가입니다.",
verbose=True,
llm=llm
)
# 여러 주제에 대한 태스크 생성
ai_task = Task(
description="2025년 인공지능 기술 동향에 대한 보고서를 작성하세요.",
expected_output="AI 기술 동향 보고서",
agent=researcher
)
blockchain_task = Task(
description="2025년 블록체인 기술 동향에 대한 보고서를 작성하세요.",
expected_output="블록체인 기술 동향 보고서",
agent=researcher
)
biotech_task = Task(
description="2025년 생명공학 기술 동향에 대한 보고서를 작성하세요.",
expected_output="생명공학 기술 동향 보고서",
agent=researcher
)
# 병렬 처리 크루 생성
parallel_research_crew = Crew(
agents=[researcher],
tasks=[ai_task, blockchain_task, biotech_task],
process=Process.parallel, # 병렬 처리
verbose=2
)
# 크루 실행
results = parallel_research_crew.kickoff()
# 각 태스크 결과 출력
for task, result in zip([ai_task, blockchain_task, biotech_task], results):
print(f"\n===== {task.description} =====\n")
print(result)
7. CrewAI 팁 및 모범 사례
7.1 에이전트 설계 원칙
- 명확한 역할 정의: 각 에이전트의 역할, 목표, 배경 스토리를 구체적으로 작성하세요.
- 적절한 전문성 부여: 에이전트의 전문 분야에 맞는 태스크를 할당하세요.
- 자연스러운 협업 흐름: 실제 조직처럼 에이전트 간 자연스러운 협업이 이루어지도록 설계하세요.
7.2 태스크 설계 원칙
- 구체적인 지시: 태스크 설명은 구체적이고 명확하게 작성하세요.
- 예상 결과 정의: 기대하는 결과물의 형태와 내용을 미리 정의하세요.
- 적절한 컨텍스트 제공: 필요한 배경 정보와 이전 태스크 결과를 컨텍스트로 제공하세요.
7.3 크루 최적화
- 적절한 프로세스 선택: 태스크 특성에 맞는 프로세스 유형을 선택하세요.
- 자원 효율성 고려: 필요한 에이전트만 포함하여 자원을 효율적으로 사용하세요.
- 오류 처리: 예외 상황에 대한 대응 방안을 마련하세요.
8. 참고 자료
## 5. 고급 예제: 도구를 활용한 웹 리서치 팀
도구를 활용하여 실제 웹 검색과 데이터 처리를 수행하는 고급 예제입니다.
```python
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI
from crewai_tools import WebSearchTool, SerperDevTool, CalculatorTool
import os
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
os.environ["SERPER_API_KEY"] = "your_serper_api_key_here" # 웹 검색용 API 키
# 도구 초기화
web_search_tool = SerperDevTool() # 웹 검색 도구
calculator_tool = CalculatorTool() # 계산 도구
# LLM 모델 설정
llm = ChatOpenAI(model="gpt-4")
# 에이전트 생성 (도구 포함)
web_researcher = Agent(
role="웹 리서처",
goal="최신 정보를 웹에서 검색하고 관련 데이터 수집",
backstory="당신은 인터넷에서 정확하고 관련성 높은 정보를 빠르게 찾아내는 전문가입니다.",
verbose=True,
llm=llm,
tools=[web_search_tool] # 웹 검색 도구 할당
)
data_analyst = Agent(
role="데이터 분석가",
goal="수집된 정보를 분석하고 통계적 인사이트 도출",
backstory="당신은 데이터를 분석하고 의미 있는 패턴을 찾아내는 데이터 과학자입니다.",
verbose=True,
llm=llm,
tools=[calculator_tool] # 계산 도구 할당
)
report_writer = Agent(
role="보고서 작성자",
goal="분석된 정보를 명확하고 구조화된 보고서로 작성",
backstory="당신은 복잡한 정보를 명확하고 매력적인 형태로 전달하는 전문 작가입니다.",
verbose=True,
llm=llm
)
# 태스크 생성
search_task = Task(
description="'2025년 인공지능 시장 규모와 성장률'에 대한 최신 정보를 검색하세요. 신뢰할 수 있는 최소 3개의 출처에서 데이터를 수집해야 합니다.",
expected_output="AI 시장 규모, 성장률, 주요 부문별 점유율에 대한 상세 정보와 출처가 포함된 보고서",
agent=web_researcher
)
analysis_task = Task(
description="수집된 AI 시장 데이터를 분석하여 성장률, 트렌드, 예측을 계산하세요. 부문별 비교 분석과 향후 5년간의 예측 데이터를 포함해야 합니다.",
expected_output="데이터 분석 보고서 (차트, 그래프, 주요 수치 포함)",
agent=data_analyst,
context=[search_task]
)
report_task = Task(
description="분석된 데이터를 바탕으로 '2025 AI 시장 동향 및 투자 기회' 보고서를 작성하세요. 경영진과 투자자를 위한 명확한 권장사항을 포함해야 합니다.",
expected_output="최종 시장 분석 보고서 (요약, 주요 발견, 권장사항 포함)",
agent=report_writer,
context=[search_task, analysis_task]
)
# 크루 생성
market_research_crew = Crew(
agents=[web_researcher, data_analyst, report_writer],
tasks=[search_task, analysis_task, report_task],
process=Process.sequential,
verbose=2
)
# 크루 실행
result = market_research_crew.kickoff()
print(result)
AutoGen(AG2) 개념 및 코딩 기초 자료
1. AutoGen(AG2)란?
AutoGen(AG2)은 Microsoft에서 개발한 오픈 소스 에이전트 프레임워크로, 다중 에이전트 AI 애플리케이션을 구축하기 위한 강력한 도구입니다. 프로그래밍 가능한 에이전트를 통해 복잡한 작업을 자율적으로 또는 인간과 협력하여 수행할 수 있습니다. 2025년 현재 AG2로 리브랜딩되어 발전하고 있으며, 다음과 같은 특징을 가집니다:
- 액터 모델: 비동기 분산 통신 시스템을 기반으로 한 설계
- 이벤트 기반 아키텍처: 확장 가능하고 유연한 에이전트 설계
- 분산 시스템 지원: 로컬에서 개발 후 클라우드 환경으로 쉽게 이전 가능
- 자율적 에이전트: 최소한의 인간 개입으로 작업 수행
- 다중 에이전트 대화: 에이전트 간 자연스러운 대화 기반 협업
- 코드 실행 기능: 에이전트가 생성한 코드의 안전한 실행 환경 제공
2. 핵심 개념
2.1 액터 모델(Actor Model)
AutoGen은 액터 모델을 기반으로 합니다. 각 에이전트는 독립적인 액터로 동작하며, 메시지 전달을 통해 다른 에이전트와 통신합니다.
2.2 에이전트(Agent)
특정 역할과 기능을 수행하는 단위로, 메시지를 처리하고 응답하는 기능을 갖추고 있습니다. AutoGen은 다양한 유형의 내장 에이전트를 제공합니다.
2.3 대화(Conversation)
에이전트 간 또는 에이전트와 인간 간의 메시지 교환 체계로, 작업 수행의 기본 단위입니다.
2.4 코드 실행기(Code Executor)
에이전트가 생성한 코드를 안전하게 실행할 수 있는 환경으로, 다양한 언어와 환경을 지원합니다.
2.5 도구 통합(Tool Integration)
외부 API, 라이브러리, 서비스와의 통합을 통해 에이전트의 기능을 확장할 수 있습니다.
3. 기본 구조 및 설치
3.1 설치 방법
# 기본 설치
pip install pyautogen
# Docker를 활용한 코드 실행 기능 사용 시
pip install pyautogen[docker]
3.2 기본적인 사용 구조
from autogen import AssistantAgent, UserProxyAgent, config_list_from_json
# API 구성 로드
config_list = config_list_from_json("config.json")
# 어시스턴트 에이전트 생성
assistant = AssistantAgent(
name="AI_Assistant",
llm_config={"config_list": config_list}
)
# 사용자 프록시 에이전트 생성
user_proxy = UserProxyAgent(
name="User",
human_input_mode="TERMINATE", # TERMINATE, ALWAYS, NEVER 중 선택
max_consecutive_auto_reply=10
)
# 대화 시작
user_proxy.initiate_chat(
assistant,
message="Python으로 피보나치 수열을 계산하는 코드를 작성해주세요."
)
4. 간단한 예제: 대화형 에이전트
다음은 AutoGen을 사용하여 간단한 대화형 에이전트를 구현하는 예제입니다.
import autogen
from autogen import AssistantAgent, UserProxyAgent, config_list_from_json
import os
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
# 기본 구성
config_list = [
{
"model": "gpt-4",
"api_key": os.environ.get("OPENAI_API_KEY")
}
]
# 어시스턴트 에이전트 생성
assistant = AssistantAgent(
name="AI_Expert",
llm_config={"config_list": config_list},
system_message="당신은 AI와 머신러닝 분야의 전문가입니다. 기술적인 질문에 정확하고 유용한 답변을 제공합니다."
)
# 사용자 프록시 에이전트 생성
user_proxy = UserProxyAgent(
name="User",
human_input_mode="TERMINATE", # 대화를 종료하려면 'exit' 입력
max_consecutive_auto_reply=2, # 최대 연속 자동 응답 횟수
code_execution_config=False # 코드 실행 비활성화
)
# 대화 시작
user_proxy.initiate_chat(
assistant,
message="인공지능의 주요 패러다임에 대해 설명해주세요. 머신러닝, 딥러닝, 강화학습의 차이점은 무엇인가요?"
)
5. 고급 예제: 다중 에이전트 시스템
여러 전문가 에이전트가 협력하는 다중 에이전트 시스템을 구현해 보겠습니다.
import autogen
from autogen import AssistantAgent, UserProxyAgent, config_list_from_json, Agent
import os
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
# 기본 구성
config_list = [
{
"model": "gpt-4",
"api_key": os.environ.get("OPENAI_API_KEY")
}
]
# LLM 구성
llm_config = {
"config_list": config_list,
"seed": 42
}
# 에이전트 생성
data_scientist = AssistantAgent(
name="DataScientist",
llm_config=llm_config,
system_message="당신은 데이터 과학과 통계 분석 전문가입니다. 복잡한 데이터 문제를 해결하고 통계적 인사이트를 제공합니다."
)
programmer = AssistantAgent(
name="Programmer",
llm_config=llm_config,
system_message="당신은 파이썬 프로그래밍 전문가입니다. 효율적이고 읽기 쉬운 코드를 작성하며 기술적 문제를 해결합니다."
)
project_manager = AssistantAgent(
name="ProjectManager",
llm_config=llm_config,
system_message="당신은 프로젝트 관리자로, 팀의 작업을 조율하고 목표를 달성하도록 돕습니다. 명확한 요구사항을 정의하고 작업을 할당합니다."
)
# 코드 실행이 가능한 사용자 프록시 생성
user_proxy = UserProxyAgent(
name="User",
human_input_mode="TERMINATE",
max_consecutive_auto_reply=10,
code_execution_config={
"work_dir": "coding",
"use_docker": False # 로컬 환경에서 실행
}
)
# 그룹채팅 시작
groupchat = autogen.GroupChat(
agents=[user_proxy, data_scientist, programmer, project_manager],
messages=[],
max_round=20 # 최대 대화 라운드 수
)
manager = autogen.GroupChatManager(
groupchat=groupchat,
llm_config=llm_config
)
# 대화 시작
user_proxy.initiate_chat(
manager,
message="인터넷에서 2024년 전 세계 GDP 데이터를 수집하고, 이를 분석하여 상위 10개국의 GDP를 막대 그래프로 시각화하는 프로젝트를 진행하고 싶습니다. 어떻게 접근해야 할까요?"
)
6. 코드 실행 기능
AutoGen의 강력한 기능 중 하나는 에이전트가 생성한 코드를 안전하게 실행할 수 있다는 점입니다.
6.1 코드 실행 구성
import autogen
from autogen import AssistantAgent, UserProxyAgent, config_list_from_json
import os
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
# 기본 구성
config_list = [
{
"model": "gpt-4",
"api_key": os.environ.get("OPENAI_API_KEY")
}
]
# 코드 실행 설정
code_execution_config = {
"work_dir": "workspace", # 작업 디렉토리
"use_docker": True, # Docker 사용 (안전한 실행 환경)
"timeout": 60, # 실행 시간 제한 (초)
"last_n_messages": 3 # 코드 실행시 고려할 최근 메시지 수
}
# 어시스턴트 에이전트 생성
coding_assistant = AssistantAgent(
name="CodingExpert",
llm_config={"config_list": config_list},
system_message="당신은 Python 프로그래밍 전문가입니다. 효율적이고 정확한 코드를 작성합니다."
)
# 코드 실행 가능한 사용자 프록시 생성
user_proxy = UserProxyAgent(
name="User",
human_input_mode="TERMINATE",
max_consecutive_auto_reply=10,
code_execution_config=code_execution_config
)
# 대화 시작
user_proxy.initiate_chat(
coding_assistant,
message="웹 스크래핑으로 네이버 뉴스에서 '인공지능' 키워드로 최신 뉴스 기사 10개를 수집하고, 제목과 URL을 CSV 파일로 저장하는 Python 코드를 작성해주세요."
)
6.2 Docker를 이용한 안전한 코드 실행
AutoGen은 Docker를 활용하여 격리된 환경에서 코드를 실행할 수 있습니다.
# Docker 환경에서 코드 실행 설정
docker_execution_config = {
"work_dir": "./workspace",
"use_docker": True,
"dockerfile": """
FROM python:3.9
WORKDIR /workspace
RUN pip install pandas numpy matplotlib seaborn scikit-learn requests beautifulsoup4
""", # 사용자 정의 Dockerfile
"timeout": 120
}
# Docker 코드 실행이 가능한 사용자 프록시 생성
docker_executor = UserProxyAgent(
name="DockerExecutor",
human_input_mode="NEVER",
max_consecutive_auto_reply=10,
code_execution_config=docker_execution_config
)
7. 도구 사용 및 통합
AutoGen은 외부 도구와의 통합을 지원하여 에이전트의 기능을 확장할 수 있습니다.
7.1 도구 정의 및 사용
import autogen
from autogen import AssistantAgent, UserProxyAgent, Tool, config_list_from_json
import os
import requests
import json
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
os.environ["WEATHER_API_KEY"] = "your_weather_api_key_here"
# 기본 구성
config_list = [
{
"model": "gpt-4",
"api_key": os.environ.get("OPENAI_API_KEY")
}
]
# 날씨 검색 도구 정의
def get_weather(location: str) -> str:
"""주어진 위치의 현재 날씨 정보를 검색합니다."""
api_key = os.environ.get("WEATHER_API_KEY")
url = f"https://api.weatherapi.com/v1/current.json?key={api_key}&q={location}"
try:
response = requests.get(url)
data = response.json()
if "error" in data:
return f"오류: {data['error']['message']}"
location_name = data["location"]["name"]
country = data["location"]["country"]
temp_c = data["current"]["temp_c"]
condition = data["current"]["condition"]["text"]
return f"{location_name}, {country}의 현재 날씨: {condition}, 온도: {temp_c}°C"
except Exception as e:
return f"날씨 정보를 가져오는 중 오류가 발생했습니다: {str(e)}"
# 도구 생성
weather_tool = Tool(
name="get_weather",
description="주어진 위치(도시, 국가)의 현재 날씨 정보를 검색합니다.",
function=get_weather
)
# 도구를 사용하는 어시스턴트 에이전트 생성
assistant_with_tools = AssistantAgent(
name="WeatherAssistant",
llm_config={
"config_list": config_list,
"tools": [weather_tool] # 도구 등록
},
system_message="당신은 날씨 정보를 제공하는 어시스턴트입니다. 사용자가 날씨에 관해 물어보면 get_weather 도구를 사용하여 정확한 정보를 제공하세요."
)
# 사용자 프록시 생성
user_proxy = UserProxyAgent(
name="User",
human_input_mode="TERMINATE",
max_consecutive_auto_reply=5
)
# 대화 시작
user_proxy.initiate_chat(
assistant_with_tools,
message="서울의 현재 날씨는 어떤가요?"
)
8. 분산 환경 구성
AutoGen은 분산 환경에서 에이전트를 실행할 수 있는 기능을 제공합니다.
import autogen
from autogen import AssistantAgent, UserProxyAgent, config_list_from_json
import os
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
# 기본 구성
config_list = [
{
"model": "gpt-4",
"api_key": os.environ.get("OPENAI_API_KEY")
}
]
# 분산 환경 설정
distributed_config = {
"cache_config": {
"cache_type": "redis", # Redis 캐시 사용
"cache_host": "localhost",
"cache_port": 6379,
"cache_db": 0
}
}
# 분산 환경에서 작동하는 에이전트 생성
distributed_assistant = AssistantAgent(
name="DistributedAssistant",
llm_config={
"config_list": config_list,
**distributed_config
},
system_message="당신은 분산 환경에서 작동하는 어시스턴트입니다."
)
# 분산 사용자 프록시 생성
distributed_user = UserProxyAgent(
name="DistributedUser",
human_input_mode="TERMINATE",
max_consecutive_auto_reply=5,
**distributed_config
)
# 대화 시작
distributed_user.initiate_chat(
distributed_assistant,
message="분산 환경에서 AutoGen을 실행하는 방법에 대해 설명해주세요."
)
9. AutoGen 팁 및 모범 사례
9.1 에이전트 설계 원칙
- 명확한 역할 정의: 각 에이전트의 역할과 책임을 명확히 정의하세요.
- 적절한 시스템 메시지: 각 에이전트의 전문성과 역할을 명확히 하는 시스템 메시지를 작성하세요.
- 효율적인 대화 관리: 에이전트 간 대화가 효율적으로 이루어지도록 설계하세요.
- 확장성 고려: 시스템이 확장될 수 있도록 모듈화된 설계를 적용하세요.
9.2 코드 실행 모범 사례
- 안전한 환경 사용: 가능하면 Docker를 사용하여 코드를 격리된 환경에서 실행하세요.
- 시간 제한 설정: 실행 시간 제한을 설정하여 무한 루프 등의 문제를 방지하세요.
- 작업 디렉토리 관리: 작업 디렉토리를 명확히 하고 필요한 경우 정리하세요.
- 에러 처리: 코드 실행 중 발생할 수 있는 예외 상황에 대비하세요.
9.3 그룹 대화 최적화
- 적절한 에이전트 구성: 작업에 필요한 전문성을 갖춘 에이전트들로 구성하세요.
- 명확한 작업 지시: 그룹 대화의 목표와 각 에이전트의 역할을 명확히 설명하세요.
- 적절한 중재: GroupChatManager를 통해 대화가 목표를 향해 진행되도록 조율하세요.
- 라운드 제한: 무한 대화를 방지하기 위해 최대 라운드 수를 설정하세요.
10. 참고 자료
11. 확장 예제: 자율형 웹 분석 시스템
다음은 AutoGen을 사용하여 웹사이트를 분석하고 리포트를 생성하는 자율형 시스템 예제입니다.
python
import autogen
from autogen import AssistantAgent, UserProxyAgent, config_list_from_json, Tool
import os
import requests
from bs4 import BeautifulSoup
import pandas as pd
import matplotlib.pyplot as plt
# API 키 설정
os.environ["OPENAI_API_KEY"] = "your_api_key_here"
# 기본 구성
config_list = [
{
"model": "gpt-4",
"api_key": os.environ.get("OPENAI_API_KEY")
}
]
# 웹 스크래핑 도구 정의
def scrape_website(url: str) -> str:
"""주어진 URL의 웹사이트 내용을 스크래핑합니다."""
try:
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
}
response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.text, 'html.parser')
# 제목 추출
title = soup.find('title').text if soup.find('title') else "제목 없음"
# 주요 텍스트 추출
main_content = ""
for p in soup.find_all('p'):
main_content += p.text + "\n"
# 링크 추출
links = []
for link in soup.find_all('a', href=True):
links.append(link['href'])
return f"제목: {title}\n\n내용 요약:\n{main_content[:1500]}...\n\n링크 수: {len(links)}"
except Exception as e:
return f"웹사이트 스크래핑 중 오류 발생: {str(e)}"
# 도구 생성
scrape_tool = Tool(
name="scrape_website",
description="주어진 URL의 웹사이트 내용을 스크래핑합니다.",
function=scrape_website
)
# 에이전트 생성
web_analyst = AssistantAgent(
name="WebAnalyst",
llm_config={
"config_list": config_list,
"tools": [scrape_tool]
},
system_message="당신은 웹사이트 분석 전문가입니다. 웹사이트의 내용을 분석하고 주요 정보를 요약합니다."
)
content_writer = AssistantAgent(
name="ContentWriter",
llm_config={"config_list": config_list},
system_message="당신은 콘텐츠 작가입니다. 분석된 정보를 바탕으로 명확하고 구조화된 보고서를 작성합니다."
)
# 코드 실행이 가능한 사용자 프록시 생성
user_proxy = UserProxyAgent(
name="User",
human_input_mode="TERMINATE",
max_consecutive_auto_reply=10,
code_execution_config={
"work_dir": "web_analysis",
"use_docker": False
}
)
# 그룹채팅 설정
groupchat = autogen.GroupChat(
agents=[user_proxy, web_analyst, content_writer],
messages=[],
max_round=15
)
manager = autogen.GroupChatManager(
groupchat=groupchat,
llm_config={"config_list": config_list}
)
# 대화 시작
user_proxy.initiate_chat(
manager,
message="https://www.example.com 웹사이트를 분석하고, 주요 내용, 구조, 개선점 등을 포함한 종합 보고서를 작성해주세요. 가능하다면 간단한 시각화도 포함해주세요."
)이 확장 예제는 웹 스크래핑, 분석, 보고서 작성을 자동화하는 자율형 에이전트 시스템을 보여줍니다. 각 에이전트는 자신의 전문 분야에서 작업을 수행하며, 협업을 통해 종합적인 결과물을 만들어냅니다.
정보가 넘쳐나는 세상에서 나에게 필요한 정보를 내 것으로 만들고, AI와 협력하여 사람들에게 가치가 있는 것을 만들어낸다는 것은 정보화시대가 되서 오히려 어려워진 것 같다. 너무 많은 정보로 인해 내 스스로 피로감을 갖고 있고 새로운 정보가 정말 유용한 정보인지 인지하는 것조차 버겁다.
창의적인 인재가 이런 시대에 필요하다고 하는데, 창의적 인재로 살아가기가 더 어려워진 역설이 우리 현실이 아닐까? 나만 그렇게 생각하는지 모르겠지만 말이다. 무언가를 쓰고 만들어내려고 해도 이미 나와있는 내용이 아닌가 라는 생각에 글을 쓰지 못하게 되고, 그러다 보면 아무 것도 할 수 없는 사람이 되어 버린다. 그래서, 하루에 한번 내가 생각하기에 필요한 글을 쓰기로 목표를 정하고 실행하려고 하고 있다. 글감을 정하는 것이 가장 어렵다...
살아가는데 도움이 안되더라도 내 생각을 정리하고 주체적인 인간이 되도록 해주는 글쓰기를 계속해야겠다.
이번 주도 행복하길 바라며 ~
반응형
'파이썬으로 할 수 있는 일 > AI&머신러닝' 카테고리의 다른 글
| RAG(Retrieval-Augmented Generation) 구현하기: 파이썬으로 자체 지식 기반 AI 에이전트 구축 (1) | 2025.04.15 |
|---|---|
| AI 튜터링 프롬프트 완벽 가이드: Ethan Mollick의 소크라테스식 학습법 활용하기 (2) | 2025.04.10 |
| AI Agent vs AI Assistant: 2025년 인공지능의 핵심 차이점과 활용 사례 정리 (12) | 2025.04.07 |
| OpenAI API를 사용한 'Hello World' 작성 (2) | 2023.11.09 |
| ChatGPT의 거침없는 발걸음 (0) | 2023.11.07 |
