소개: CrewAI와 에이전트 팀 패러다임
크루AI AI 에이전트 팀을 조율하도록 설계된 오픈 소스 Python 프레임워크입니다. 기업 세계에서 영감을 받은 패러다임을 통해 각 에이전트는 특정 역할, 명확한 목표를 가지고 있으며 다른 팀 구성원과 협력하여 복잡한 작업을 완료합니다. 달리 그래프로 흐름을 모델링하는 LangGraph와 에이전트 간의 자유로운 대화를 기반으로 하는 AutoGen의 CrewAI는 직관적인 은유를 채택합니다. 작업 팀 멤버 각자의 실력이 있는 곳 뚜렷하고 전용 도구와 잘 정의된 책임이 있습니다.
2024년생이 버전에 도달했습니다. 0.80+ 2026년 CrewAI는 급격한 상승세를 보였습니다. 사용하기 쉽고 학습 곡선이 매우 낮기 때문에 인기가 있습니다. 다른 사람들은 어디에 프레임워크를 사용하려면 상태 그래프, 비동기 메시징 또는 통신 프로토콜인 CrewAI를 사용하면 수십 개로 작동하는 다중 에이전트 시스템을 정의할 수 있습니다. 코드 줄. 이는 제한된 프레임워크라는 의미는 아닙니다. 해당 아키텍처는 프로세스를 지원합니다. 순차적이고 계층적이며 합의된 장기 기억, 수십 가지 도구와의 통합 및 프로덕션에 배포.
CrewAI의 강점은 정신 모델의 명확성에 있습니다. 에이전트 팀을 설계할 때 CrewAI를 사용하면 작업 팀을 구성해야 하는 관리자와 똑같이 생각합니다. 사람은 누구입니까? 맞습니다. 어떤 기술이 필요한지, 누가 무엇을, 어떤 순서로, 어떤 도구를 사용하여 수행하는지 말이죠. 이런 자연스러운 비유 아이디어에서 구현까지 소요되는 시간을 획기적으로 단축합니다.
이 기사에서 배울 내용
- CrewAI 아키텍처: 에이전트, 작업, 승무원, 도구 및 연결 방법
- 효과적인 역할, 목표 및 배경 스토리를 갖춘 에이전트를 정의하는 방법
- 작업 관리: 예상 출력, 컨텍스트 및 위임
- 프로세스 유형: 순차, 계층 및 각 사용 시기
- 데코레이터를 사용하여 사용자 정의 도구를 만드는 방법
@tool및 BaseTool 클래스 - 에이전트 간 메모리 및 컨텍스트 공유 시스템
- 전체 사례 연구: 3명의 에이전트로 구성된 콘텐츠 제작팀
- CrewAI, LangGraph 및 AutoGen의 실제 비교
- 프로덕션 사용에 대한 모범 사례 및 제한 사항
CrewAI 아키텍처
CrewAI의 아키텍처는 시너지 효과를 발휘하는 네 가지 기본 개념을 기반으로 합니다. 대리인, 작업, 승무원 e 도구. 이해하다 이러한 구성 요소를 연결하는 방법은 효과적인 다중 에이전트 시스템을 설계하는 데 중요합니다.
네 개의 기둥
- 대리인: 역할, 목표, 배경 스토리가 있는 자율적인 개체입니다. 모든 에이전트 LLM 템플릿과 선택적으로 도구 세트에 액세스할 수 있습니다. 에이전트는 "누구"입니다. 누가 작업을 수행합니까?
- 작업: 명확한 설명, 예상되는 출력 및 할당된 에이전트가 포함된 작업 단위입니다. 임무는 "무엇", 즉 무엇을 해야 하는지입니다.
- 승무원: 에이전트와 작업을 하나로 모으고 실행 프로세스를 정의하며 조정을 관리합니다. 승무원은 "어떻게", 즉 작업이 어떻게 구성되는지입니다.
- 도구: 에이전트가 외부 세계와 상호 작용하기 위해 호출할 수 있는 기능 (웹 검색, 파일 읽기, API 쿼리). 도구는 "무엇을 사용하여" 작업하는 도구입니다.
건축 계획
Architettura CrewAI:
+-------------------------------------------------+
| CREW |
| (processo: sequential / hierarchical) |
| |
| +-------------+ +-------------+ +-----------+ |
| | AGENT 1 | | AGENT 2 | | AGENT 3 | |
| | role: ... | | role: ... | | role: ... | |
| | goal: ... | | goal: ... | | goal: ... | |
| | tools: [A,B]| | tools: [C] | | tools: [] | |
| +------+------+ +------+------+ +-----+-----+ |
| | | | |
| +------v------+ +------v------+ +-----v-----+ |
| | TASK 1 | | TASK 2 | | TASK 3 | |
| | description | | description | | descript. | |
| | expected_ | | context: | | context: | |
| | output | | [task1] | | [task1,2] | |
| +-------------+ +-------------+ +-----------+ |
+-------------------------------------------------+
흐름은 명확합니다. 승무원은 작업 실행을 조정하고 프로세스에 따라 에이전트에 작업을 할당합니다. 구성되었습니다. 각 Task는 다음과 같이 수신할 수 있습니다. 문맥 이전 작업의 출력, 생성 각 에이전트가 다른 에이전트의 작업을 기반으로 구축되는 종속성 체인입니다. 이 컨텍스트 메커니즘 CrewAI 협업의 핵심입니다.
에이전트 정의
CrewAI에서 각 에이전트는 네 가지 기본 속성으로 정의됩니다. role, goal,
backstory e tools. 이러한 속성은 단순한 메타데이터가 아니라 통합되어 있습니다.
상담원의 시스템 프롬프트에 포함되며 기본 LLM의 동작에 직접적인 영향을 미칩니다. 대리인
잘 정의된 속성은 일반 속성을 사용한 속성보다 훨씬 더 나은 결과를 생성합니다.
에이전트의 속성
- 역할: 대리인의 직위입니다. 그것은 정체성과 유형을 정의합니다. 그가 갖고 있는 전문성. 예: "선임 데이터 분석가", "콘텐츠 마케팅 전략가", "QA 엔지니어".
- 목표: 에이전트가 달성하려는 목표입니다. 구체적이고 측정 가능해야 합니다. LLM은 목표를 사용하여 결정을 내리고 결과가 적절한지 평가합니다.
- 뒷이야기: 에이전트에게 상황과 동기를 제공하는 내러티브입니다. 뒷이야기 답변의 질을 향상시키는 세부 사항으로 프롬프트를 풍부하게 합니다: 이전 경험, 작업 스타일, 지침 원칙.
- 도구: 에이전트가 사용할 수 있는 도구 목록입니다. 도구가 없는 에이전트는 다음 작업만 수행할 수 있습니다. 추론하고 텍스트를 생성합니다. 도구를 갖춘 에이전트는 웹 검색, 파일 읽기, 계산 수행 및 외부 시스템과 상호 작용합니다.
실제 예: 대리인의 정의
from crewai import Agent
from crewai_tools import SerperDevTool, ScrapeWebsiteTool
# Tool per la ricerca web
search_tool = SerperDevTool()
scrape_tool = ScrapeWebsiteTool()
# Agente 1: Ricercatore
researcher = Agent(
role="Senior Research Analyst",
goal="Trovare informazioni accurate e aggiornate su un argomento, "
"verificando le fonti e sintetizzando i dati chiave",
backstory="""Sei un analista di ricerca con 15 anni di esperienza nel
settore tecnologico. Hai lavorato per think tank prestigiosi e sei noto
per la tua capacità di trovare dati affidabili e separare i fatti dalle
opinioni. Il tuo approccio è sempre evidence-based: non affermi nulla
che non sia supportato da fonti verificabili.""",
tools=[search_tool, scrape_tool],
verbose=True,
allow_delegation=False,
max_iter=5,
llm="gpt-4o"
)
# Agente 2: Scrittore
writer = Agent(
role="Content Writer",
goal="Scrivere articoli tecnici coinvolgenti, accurati e ottimizzati "
"per la SEO, basati sui dati forniti dal team di ricerca",
backstory="""Sei un technical writer con esperienza nella comunicazione
scientifica e tecnologica. Sai trasformare dati complessi in narrative
accessibili senza sacrificare la precisione tecnica. I tuoi articoli
sono noti per essere sia informativi che piacevoli da leggere. Segui
le best practice SEO per massimizzare la visibilità dei contenuti.""",
tools=[],
verbose=True,
allow_delegation=False,
llm="gpt-4o"
)
# Agente 3: Editor
editor = Agent(
role="Senior Content Editor",
goal="Revisionare i contenuti per garantire qualità, coerenza, "
"correttezza grammaticale e aderenza alle linee guida editoriali",
backstory="""Sei un editor senior con un occhio impeccabile per i
dettagli. Hai revisionato centinaia di articoli tecnici e sai
individuare errori logici, imprecisioni tecniche e problemi di
struttura. Il tuo feedback è sempre costruttivo e orientato al
miglioramento del contenuto finale.""",
tools=[],
verbose=True,
allow_delegation=False,
llm="gpt-4o"
)
효과적인 배경 이야기를 위한 팁
뒷이야기는 일반적인 문구로 채워지는 선택 항목이 아닙니다. 그것은 가장 많은 것 중 하나입니다 에이전트의 행동을 제어하는 데 강력합니다. 가장 잘 작성하는 방법은 다음과 같습니다.
- 특성: '많은 경험'보다 '15년의 핀테크 경험'이 낫다
- 작동 원리: 에이전트가 따라야 하는 규칙을 포함합니다('항상 출처 확인', '명확성 우선순위').
- 안티패턴: 에이전트가 해서는 안 되는 일을 명시적으로 나타냅니다("데이터를 만들어내지 마세요", "쓸데없는 전문 용어를 사용하지 마세요").
- 톤과 스타일: 통신 레지스터 정의("공식적이지만 접근 가능", "직접적이고 간결함")
고급 에이전트 매개변수
CrewAI는 기본 속성 외에도 고급 매개변수를 제공하여 미세하게 제어할 수 있습니다. 에이전트의 행동:
advanced_agent = Agent(
role="Data Scientist",
goal="Analizzare dataset e produrre insight statistici",
backstory="Esperto di data science con specializzazione in NLP.",
# Parametri avanzati
verbose=True, # Log dettagliato delle operazioni
allow_delegation=True, # Può delegare task ad altri agenti
max_iter=10, # Massimo numero di iterazioni per task
max_rpm=30, # Rate limit: max richieste al minuto
memory=True, # Abilita la memoria dell'agente
cache=True, # Cache dei risultati dei tool
step_callback=None, # Callback custom dopo ogni step
# Configurazione LLM
llm="gpt-4o", # Modello da utilizzare
function_calling_llm=None, # LLM separato per il function calling
max_tokens=4096, # Limite token per risposta
)
업무 및 위임
I 작업 CrewAI의 기본 작업 단위입니다. 각 작업은 정의합니다. 특정 목표, 예상 결과, 담당 에이전트 및 선택적으로 컨텍스트 이전 작업에서 발생합니다. 작업 정의의 품질은 정비례합니다. 승무원이 생산한 결과의 품질에 달려 있습니다.
작업 분석
from crewai import Task
# Task 1: Ricerca
research_task = Task(
description="""Conduci una ricerca approfondita su {topic}.
Devi trovare:
1. Le ultime novità e sviluppi (ultimi 6 mesi)
2. I principali player e le loro soluzioni
3. Trend emergenti e previsioni degli esperti
4. Dati quantitativi (statistiche, market size, growth rate)
5. Almeno 5 fonti affidabili con URL
Concentrati su fonti autorevoli: paper accademici, report di
analisti, documentazione ufficiale e articoli di esperti riconosciuti.""",
expected_output="""Un report di ricerca strutturato con:
- Executive summary (3-5 righe)
- Sezione 'Stato dell'Arte' con i principali sviluppi
- Sezione 'Player Principali' con confronto
- Sezione 'Trend e Previsioni' con dati quantitativi
- Lista delle fonti con URL
Il report deve essere tra 800 e 1200 parole.""",
agent=researcher
)
# Task 2: Scrittura (dipende dalla ricerca)
writing_task = Task(
description="""Basandoti sul report di ricerca fornito, scrivi un
articolo tecnico completo su {topic}.
L'articolo deve:
1. Avere un titolo accattivante e ottimizzato SEO
2. Iniziare con un'introduzione che catturi l'attenzione
3. Sviluppare ogni sezione con esempi pratici
4. Includere code snippet dove appropriato
5. Concludere con takeaway actionable per il lettore
6. Usare un tono professionale ma accessibile""",
expected_output="""Un articolo tecnico di 1500-2000 parole con:
- Titolo SEO-friendly
- Introduzione coinvolgente
- 4-6 sezioni tematiche con sottotitoli H2/H3
- Almeno 2 code snippet pratici
- Conclusione con call-to-action
- Meta description di 150-160 caratteri""",
agent=writer,
context=[research_task] # Riceve l'output della ricerca
)
# Task 3: Revisione (dipende dalla scrittura)
editing_task = Task(
description="""Revisiona l'articolo prodotto dal writer.
Verifica:
1. Correttezza tecnica di tutte le affermazioni
2. Coerenza logica e strutturale
3. qualità della scrittura (grammatica, stile, leggibilità)
4. Ottimizzazione SEO (keyword density, meta tags)
5. Completezza rispetto al brief iniziale
Fornisci l'articolo finale corretto, non solo il feedback.""",
expected_output="""L'articolo finale revisionato e pronto per la
pubblicazione, con tutte le correzioni applicate. In coda,
includi una sezione 'Note Editoriali' con le modifiche effettuate
e la valutazione complessiva (voto da 1 a 10).""",
agent=editor,
context=[research_task, writing_task]
)
컨텍스트 매개변수
매개변수 context 이는 작업이 정보를 공유하는 메커니즘입니다.
작업이 있을 때 context=[task_precedente], 이전 작업의 출력이 옵니다.
현재 작업을 실행하는 에이전트의 프롬프트에 자동으로 삽입됩니다. 이것은
각 에이전트가 동료의 작업을 기반으로 구축되는 종속성 체인입니다.
작업은 여러 이전 작업으로부터 컨텍스트를 받을 수 있습니다. 위의 예에서 편집자는 두 가지를 모두 받습니다. 원본 연구 보고서와 작성된 논문 사이의 일관성을 확인할 수 있습니다. 연구가 최종 콘텐츠입니다. 이 패턴은 누적 컨텍스트 전자 전체 출력의 품질을 보장하는 데 필수적입니다.
에이전트 간 위임
대리인이 있는 경우 allow_delegation=True, 독립적으로 위임 여부를 결정할 수 있습니다.
그의 작업의 일부를 승무원의 다른 요원에게 전달합니다. 이 메커니즘은 다음의 동작을 복제합니다.
동료가 특정 하위 작업에 더 적합하다는 것을 인식하는 팀 관리자.
통제되지 않은 위임을 조심하세요
위임은 강력할 수도 있지만 위험할 수도 있습니다. 상담원이 너무 많으면
allow_delegation=True, 시스템은 순환 위임 루프에 들어갈 수 있습니다.
여기서 에이전트 A는 B에게 위임하고 B는 A에게 다시 위임합니다. 이를 방지하려면 다음을 수행하세요.
- 조정 역할이 있는 상담원에게만 위임을 활성화하세요.
- Imposta
max_iter반복 횟수를 제한하려면 - 실제로는 보유
allow_delegation=False대부분의 상담원에게
프로세스 유형
CrewAI는 두 가지 주요 작업 조정 모드를 지원합니다. 잇달아 일어나는 e 계층적. 프로세스 선택에 따라 작업 수행 방법이 결정됩니다. 에이전트가 서로 상호 작용하는 방식.
순차적 프로세스
그 과정에서 잇달아 일어나는, 작업은 순서대로 하나씩 실행됩니다. 정의되어 있습니다. 각 작업의 출력은 작업의 컨텍스트로 제공됩니다. 후속 것. 이는 선형 파이프라인에 이상적인 가장 간단하고 예측 가능한 프로세스입니다. 여기서 각 단계는 이전 단계에 따라 달라집니다.
from crewai import Crew, Process
# Crew con processo sequenziale
crew = Crew(
agents=[researcher, writer, editor],
tasks=[research_task, writing_task, editing_task],
process=Process.sequential,
verbose=True
)
# Esecuzione
result = crew.kickoff(
inputs={"topic": "AI Agents nel 2026"}
)
print(result.raw) # Output finale come stringa
print(result.token_usage) # Token consumati per agente
Flusso Sequential:
[research_task] --output--> [writing_task] --output--> [editing_task]
| | |
researcher writer editor
| | |
"Report di "Articolo "Articolo
ricerca" bozza" finale"
계층적 프로세스
그 과정에서 계층적, CrewAI는 자동으로 매니저 에이전트 팀의 업무를 조정하는 사람. 관리자는 업무를 분석하고, 실행순서를 결정하고, 배정한다. 가장 적절한 상담원에게 작업을 전달하며 수정이 필요할 수 있습니다. 이 프로세스는 더 유연하지만 관리자가 상황에 따라 자율적인 결정을 내리기 때문에 예측 가능성은 더욱 낮습니다.
from crewai import Crew, Process
# Crew con processo gerarchico
crew = Crew(
agents=[researcher, writer, editor],
tasks=[research_task, writing_task, editing_task],
process=Process.hierarchical,
manager_llm="gpt-4o", # LLM per il manager agent
verbose=True
)
result = crew.kickoff(
inputs={"topic": "AI Agents nel 2026"}
)
Flusso Hierarchical:
+-------------------+
| MANAGER AGENT |
| (creato da CrewAI) |
+--------+----------+
|
+--------------+--------------+
| | |
v v v
[researcher] [writer] [editor]
| | |
v v v
"Risultato" "Risultato" "Risultato"
| | |
+--------------+--------------+
|
v
Output Finale
프로세스 간 비교
| 특성 | 잇달아 일어나는 | 계층적 |
|---|---|---|
| 예측 가능성 | 높음 - 고정 순서 | 평균 - 관리자가 결정 |
| 유연성 | 저-강성 파이프라인 | 높음 - 동적 적응 |
| 토큰 비용 | 예측 가능 | 변수(추가 관리자) |
| 복잡성 | 최소한의 | 평균 |
| 이상적인 사용 사례 | 선형 파이프라인 및 메모 | 복잡한 종속성이 있는 작업 |
| 디버깅 | 단순 - 선형 흐름 | 복잡한 - 관리자 결정 |
실제로 프로세스는 잇달아 일어나는 대부분의 경우 권장되는 선택입니다. 사용 사례. 토큰 측면에서 더 예측 가능하고 디버그하기 쉽고 저렴합니다. 계층적 프로세스는 조정 논리가 복잡하고 조정이 불가능할 때 유용합니다. 사전에 정적으로 정의되지만 가변성과 추가 비용이 발생합니다. 가장 신뢰도가 낮은 시스템.
맞춤형 도구
도구는 에이전트와 외부 세계를 연결하는 다리입니다. CrewAI는 두 가지 접근 방식을 지원합니다.
사용자 정의 도구 정의: 장식가 @tool 간단한 기능을 위해
그리고 수업 BaseTool 더 복잡한 도구가 필요한 경우
내부 상태 또는 고급 구성.
데코레이터가 포함된 도구
from crewai.tools import tool
@tool("Search Database")
def search_database(query: str, table: str = "products") -> str:
"""Cerca nel database aziendale informazioni su prodotti,
clienti o ordini.
Args:
query: Termine di ricerca.
table: Tabella da interrogare (products, customers, orders).
Returns:
Risultati della ricerca formattati.
"""
import sqlite3
conn = sqlite3.connect("company.db")
cursor = conn.execute(
f"SELECT * FROM {table} WHERE name LIKE ?",
(f"%{query}%",)
)
results = cursor.fetchall()
conn.close()
if not results:
return f"Nessun risultato trovato per '{query}' nella tabella {table}."
formatted = [str(row) for row in results[:10]]
return f"Trovati {len(results)} risultati:\n" + "\n".join(formatted)
@tool("Calculate Metrics")
def calculate_metrics(data: str, metric_type: str = "mean") -> str:
"""Calcola metriche statistiche sui dati forniti.
Args:
data: Dati numerici separati da virgola (es. '10,20,30,40').
metric_type: Tipo di metrica: mean, median, std, min, max.
Returns:
Il valore della metrica calcolata.
"""
import statistics
values = [float(x.strip()) for x in data.split(",")]
metrics = {
"mean": statistics.mean,
"median": statistics.median,
"std": statistics.stdev if len(values) > 1 else lambda x: 0,
"min": min,
"max": max,
}
if metric_type not in metrics:
return f"Metrica '{metric_type}' non supportata. Usa: {list(metrics.keys())}"
result = metrics[metric_type](values)
return f"{metric_type} di {values}: {result:.4f}"
BaseTool 클래스가 포함된 도구
내부 상태, 지속적인 연결 또는 초기화 논리가 필요한 도구의 경우
CrewAI는 복잡한 클래스를 제공합니다. BaseTool:
from crewai.tools import BaseTool
from pydantic import BaseModel, Field
from typing import Type
class APISearchInput(BaseModel):
"""Schema di input per il tool di ricerca API."""
endpoint: str = Field(description="Endpoint API da interrogare")
params: str = Field(
default="",
description="Parametri della query in formato key=value separati da &"
)
class APISearchTool(BaseTool):
name: str = "API Search"
description: str = (
"Interroga un'API REST esterna per recuperare dati. "
"Supporta endpoint GET con parametri di query."
)
args_schema: Type[BaseModel] = APISearchInput
base_url: str = "https://api.example.com"
api_key: str = ""
def _run(self, endpoint: str, params: str = "") -> str:
"""Esegue la richiesta API."""
import requests
url = f"{self.base_url}/{endpoint}"
headers = {"Authorization": f"Bearer {self.api_key}"}
query_params = {}
if params:
for pair in params.split("&"):
key, value = pair.split("=")
query_params[key.strip()] = value.strip()
try:
response = requests.get(
url, headers=headers, params=query_params, timeout=10
)
response.raise_for_status()
return str(response.json())
except requests.RequestException as e:
return f"Errore nella richiesta API: {str(e)}"
# Utilizzo
api_tool = APISearchTool(
base_url="https://api.example.com/v2",
api_key="your-api-key"
)
CrewAI 사전 정의 도구
CrewAI는 패키지를 통해 사전 정의된 풍부한 도구 세트를 제공합니다. crewai-tools:
from crewai_tools import (
SerperDevTool, # Ricerca web via Serper.dev
ScrapeWebsiteTool, # Web scraping
WebsiteSearchTool, # Ricerca semantica su un sito
FileReadTool, # Lettura file
DirectoryReadTool, # Listing directory
PDFSearchTool, # Ricerca in file PDF
CSVSearchTool, # Ricerca in file CSV
JSONSearchTool, # Ricerca in file JSON
CodeDocsSearchTool, # Ricerca in documentazione codice
YoutubeVideoSearchTool, # Ricerca in video YouTube
)
# Configurazione
search = SerperDevTool()
scraper = ScrapeWebsiteTool()
pdf_reader = PDFSearchTool(pdf="report.pdf")
csv_reader = CSVSearchTool(csv="data.csv")
도구 설명 및 에이전트 품질
La description 도구의 올바른 작동을 위해 가장 중요한 부분입니다.
대리인의. LLM은 설명만을 토대로 호출할 도구를 결정합니다.
"사물 검색"과 같은 모호한 설명은 잘못된 호출로 이어질 수 있습니다. 정확한 설명
예를 들어 "검색 엔진을 사용하여 웹에서 정보를 검색하고 처음 5개의 결과를 반환합니다.
제목, URL 및 스니펫 포함'을 사용하면 LLM이 도구 사용 시기와 방법을 정확하게 결정할 수 있습니다.
메모리 및 컨텍스트 공유
CrewAI는 에이전트가 공유할 수 있는 다중 레벨 메모리 시스템을 구현합니다. 정보를 얻고, 이전 상호 작용을 기억하고, 시간이 지남에 따라 지식을 축적합니다. 시스템 메모리는 서로 다른 시간 규모에서 작동하는 세 가지 개별 구성 요소로 구성됩니다.
기억의 세 가지 수준
-
단기 기억: 현재 연주에 대한 정보를 저장합니다.
승무원의. 완료된 작업, 상담원 대화 및 결과의 출력을 포함합니다.
도구의. 실행이 끝나면 0으로 재설정됩니다. 그리고 매개변수에 힘을 실어주는 메커니즘
context작업의. - 장기 기억: 실행 간에 지속됩니다. 배운 교훈을 기억하고, 좋은 결과를 낳은 성공적인 패턴과 전략. 데이터베이스 사용 지속성을 위한 로컬(SQLite). 동일한 크루를 반복적으로 실행할 때 유용합니다. 비슷한 작업에.
- 엔터티 메모리: 언급된 개체에 대한 로그를 유지합니다. 실행(사람, 조직, 제품, 개념). 에이전트가 빌드할 수 있도록 허용 그들이 활동하는 영역에 대한 누적된 이해.
메모리 구성
from crewai import Crew, Process
crew = Crew(
agents=[researcher, writer, editor],
tasks=[research_task, writing_task, editing_task],
process=Process.sequential,
# Configurazione memoria
memory=True, # Abilita il sistema di memoria
embedder={
"provider": "openai",
"config": {
"model": "text-embedding-3-small"
}
},
verbose=True
)
# Prima esecuzione: la crew impara
result1 = crew.kickoff(inputs={"topic": "AI Agents"})
# Seconda esecuzione: la crew ricorda le lezioni apprese
result2 = crew.kickoff(inputs={"topic": "Multi-Agent Systems"})
작업 간 컨텍스트 공유
Il 컨텍스트 공유 CrewAI의 주요 협업 메커니즘입니다. 언제
작업은 매개변수의 다른 작업을 나열합니다. context, 해당 작업의 결과는 다음과 같습니다.
현재 작업을 실행하는 에이전트의 프롬프트에 자동으로 포함됩니다. 이것은
각 에이전트가 전임자의 작업에 액세스할 수 있는 정보 체인입니다.
# Task con contesto multiplo
final_review = Task(
description="Revisione finale del contenuto completo.",
expected_output="Contenuto approvato e pronto per la pubblicazione.",
agent=editor,
context=[research_task, writing_task] # Accede a entrambi gli output
)
# Il prompt dell'editor includera automaticamente:
# 1. L'output del research_task (report di ricerca)
# 2. L'output del writing_task (articolo bozza)
# L'editor può cosi verificare la coerenza tra ricerca e contenuto
컨텍스트 공유가 내부적으로 작동하는 방식
작업이 있을 때 context=[task_a, task_b], CrewAI가 프롬프트를 구축합니다.
참조된 작업의 출력이 포함된 전용 섹션을 포함하는 에이전트의 내용:
[System Prompt con role, goal, backstory dell'agente]
Contesto dalle attivita precedenti:
---
Output di Task A:
[output completo di task_a]
---
Output di Task B:
[output completo di task_b]
---
Task corrente:
[description del task corrente]
Expected Output:
[expected_output del task corrente]
즉, 이전 작업의 전체 출력이 프롬프트에 포함됩니다. 작업별
출력이 매우 길면 상당한 양의 토큰이 소모될 수 있습니다. 중요하다
정의하다 expected_output 출력은 간결하지만 완전합니다.
사례 연구: 콘텐츠 제작팀
콘텐츠 제작팀의 완전하고 실제 작동하는 예를 구현해 보겠습니다. 팀은 세 명의 전문 에이전트로 구성됩니다. 연구원 수집하는 것 정보, 작가 아이템을 생산하는 곳과 편집자 최종 콘텐츠를 검토하는 사람입니다. 이 패턴은 모든 콘텐츠 파이프라인에 적용 가능합니다. 작성: 블로그 게시물, 뉴스레터, 회사 보고서, 기술 문서.
설정 완료
import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, ScrapeWebsiteTool
# Configurazione API keys
os.environ["OPENAI_API_KEY"] = "your-openai-key"
os.environ["SERPER_API_KEY"] = "your-serper-key"
# --- TOOLS ---
search_tool = SerperDevTool()
scrape_tool = ScrapeWebsiteTool()
# --- AGENTS ---
researcher = Agent(
role="Senior Tech Research Analyst",
goal="Raccogliere informazioni complete, accurate e aggiornate "
"sull'argomento assegnato, con dati quantitativi e fonti verificabili",
backstory="""Sei un analista di ricerca con 12 anni di esperienza
nel settore tecnologico. Hai contribuito a report per Gartner e
Forrester. La tua metodologia prevede:
1. Ricerca iniziale ampia per mappare il panorama
2. Deep dive sulle fonti più rilevanti
3. Verifica incrociata dei dati tra almeno 3 fonti
4. Sintesi strutturata con distinzione tra fatti e opinioni""",
tools=[search_tool, scrape_tool],
verbose=True,
allow_delegation=False,
max_iter=7,
llm="gpt-4o"
)
writer = Agent(
role="Technical Content Writer",
goal="Trasformare i dati di ricerca in un articolo tecnico "
"coinvolgente, accurato e ottimizzato per SEO e leggibilità",
backstory="""Sei un technical writer con 8 anni di esperienza.
Hai scritto per pubblicazioni come Towards Data Science, Dev.to
e documentazione ufficiale di framework open-source. Il tuo stile
combina rigore tecnico e accessibilità: usi analogie concrete,
esempi pratici e una struttura chiara. Ogni articolo che scrivi
segue la formula: hook -> contesto -> profondità -> takeaway.""",
tools=[],
verbose=True,
allow_delegation=False,
llm="gpt-4o"
)
editor = Agent(
role="Senior Technical Editor",
goal="Garantire che l'articolo finale sia impeccabile dal punto "
"di vista tecnico, linguistico e strutturale",
backstory="""Sei un editor con background in computer science e
giornalismo tecnico. Hai revisionato oltre 500 articoli tecnici.
Il tuo processo di revisione:
1. Verifica correttezza tecnica (affermazioni, codice, dati)
2. Analisi strutturale (flusso logico, transizioni, coerenza)
3. Revisione linguistica (grammatica, chiarezza, concisione)
4. Check SEO (titolo, meta description, keyword placement)
Non ti limiti a segnalare problemi: correggi direttamente.""",
tools=[],
verbose=True,
allow_delegation=False,
llm="gpt-4o"
)
# --- TASKS ---
research_task = Task(
description="""Conduci una ricerca approfondita su: {topic}
Requisiti:
- Identifica almeno 5 sviluppi chiave degli ultimi 6 mesi
- Trova dati quantitativi (statistiche, benchmark, market data)
- Raccogli opinioni di esperti riconosciuti
- Individua trend emergenti e previsioni
- Documenta tutte le fonti con URL completi""",
expected_output="""Report di ricerca strutturato (800-1000 parole):
1. Executive Summary (5 righe)
2. Sviluppi Chiave (5+ punti con fonti)
3. Dati Quantitativi (statistiche con fonti)
4. Opinioni di Esperti (citazioni attribuite)
5. Trend Emergenti (3+ previsioni)
6. Bibliografia (5+ fonti con URL)""",
agent=researcher
)
writing_task = Task(
description="""Scrivi un articolo tecnico basato sul report di ricerca.
Specifiche:
- Titolo: accattivante, max 60 caratteri, con keyword principale
- Introduzione: hook + contesto + preview del contenuto
- Corpo: 4-6 sezioni con H2, esempi pratici e dati
- Conclusione: sintesi + takeaway actionable + CTA
- Tono: professionale ma accessibile, in italiano
- Lunghezza: 1500-2000 parole""",
expected_output="""Articolo completo in formato Markdown con:
- Titolo SEO-optimized
- Meta description (155 caratteri)
- 5-7 keyword target
- Contenuto strutturato con H2/H3
- Almeno 2 esempi pratici o code snippet
- Conclusione con 3 takeaway numerati""",
agent=writer,
context=[research_task]
)
editing_task = Task(
description="""Revisiona e finalizza l'articolo.
Checklist di revisione:
- [ ] Tutte le affermazioni tecniche sono corrette
- [ ] I dati citati corrispondono alle fonti
- [ ] La struttura è logica e fluida
- [ ] Non ci sono errori grammaticali o di stile
- [ ] Il titolo e la meta description sono efficaci
- [ ] Il SEO è ottimizzato
- [ ] La lunghezza è nei limiti richiesti
Produci la versione finale corretta dell'articolo.""",
expected_output="""Articolo finale revisionato e pronto per la
pubblicazione, con in coda:
- Note editoriali (modifiche effettuate)
- Score di qualità (1-10)
- Checklist completata""",
agent=editor,
context=[research_task, writing_task]
)
# --- CREW ---
content_crew = Crew(
agents=[researcher, writer, editor],
tasks=[research_task, writing_task, editing_task],
process=Process.sequential,
verbose=True,
memory=True,
embedder={
"provider": "openai",
"config": {"model": "text-embedding-3-small"}
}
)
# --- ESECUZIONE ---
result = content_crew.kickoff(
inputs={"topic": "L'impatto degli AI Agents sulla produttività aziendale nel 2026"}
)
# Accesso ai risultati
print("=== RISULTATO FINALE ===")
print(result.raw)
print(f"\n=== TOKEN USAGE ===")
print(f"Token totali: {result.token_usage}")
일반적인 승무원 출력
실행 중에 CrewAI는 프로세스의 각 단계를 어떤 에이전트에 있는지에 대한 세부 정보와 함께 기록합니다.
그가 어떤 도구를 사용하고 있는지, 어떤 결과물을 만들어냈는지. 최종 결과는 출력입니다.
수정된 기사가 포함된 마지막 작업(editing_task)의 출판 준비가 완료되었습니다.
분야 token_usage 에이전트별, 작업별 토큰 소비 분석을 제공합니다.
비용 모니터링에 필수적입니다.
CrewAI vs LangGraph vs AutoGen
올바른 프레임워크를 선택하려면 아키텍처의 차이점을 이해하는 것이 중요합니다. CrewAI, LangGraph 및 AutoGen 간의 철학적입니다. 각 프레임워크는 특정 시나리오에서 탁월합니다. 단순성, 유연성 및 제어 간에 서로 다른 절충안을 제공합니다.
자세한 비교
| 크기 | 크루AI | 랭그래프 | 자동 생성/AG2 |
|---|---|---|---|
| 어형 변화표 | 역할 기반 팀 | 그래프 상태 저장 | 다중 에이전트 대화 |
| 은유 | 사업팀 | 흐름도 | 그룹채팅 |
| 학습 곡선 | 낮은 | 높은 | 평균 |
| 유연성 | 평균 | 최고 | 높은 |
| 일반적인 코드 줄 | 30-80 | 80-200+ | 50-150 |
| 지속적인 상태 | 메모리 시스템 | 네이티브 체크포인트 | 채팅 기록 |
| 인간 참여형 | 구성 가능 | 네이티브(인터럽트) | 네이티브(4가지 모드) |
| 도구 생태계 | 크루아이 도구(풍부한) | LangChain 도구 | 기능 등록 |
| 코드 실행 | 도구를 통해 | 커스텀 노드 | 네이티브(도커) |
| 이상적인 사용 사례 | 콘텐츠 파이프라인, 구조화된 워크플로 | 분기가 포함된 복잡한 워크플로 | 반복적인 협업 및 코드 생성 |
CrewAI를 선택해야 하는 경우
- 신속한 프로토타이핑: When you need a working multi-agent system in the shortest time possible. API의 단순성 덕분에 아이디어에서 프로토타입까지 몇 분 안에 완료할 수 있습니다.
- 선형 파이프라인: 워크플로우가 명확한 단계 순서인 경우 (연구 -> 처리 -> 검토 -> 출력)입니다.
- 서로 다른 역할을 맡은 팀: 각 상담원이 잘 정의된 역할과 잘 정의되지 않은 역할을 갖고 있는 경우 복잡한 조정이 필요합니다.
- 콘텐츠 제작: CrewAI는 다양한 콘텐츠 제작 파이프라인에 탁월합니다. 전문가들이 순차적으로 기여합니다.
CrewAI를 선택하지 말아야 할 경우
- 복잡한 분기 작업흐름: 흐름에 조건부 결정이 필요한 경우 multiple, loops with specific output conditions or parallel execution of sub-flows, LangGraph가 최선의 선택입니다.
- 에이전트 간의 협상: 대리인이 논의하고 협상하고 수렴해야 하는지 여부 대화식 반복을 통한 솔루션에서는 AutoGen이 더 적합합니다.
- 세분화된 흐름 제어: CrewAI는 많은 흐름 세부정보를 추상화합니다. 실행. If you need to check every single state transition, use LangGraph.
생산 모범 사례
Using CrewAI in production environments requires attention to several aspects ranging beyond the simple definition of agents and tasks. 다음은 기본 모범 사례를 기반으로 한 것입니다. on the experience accumulated with the framework.
1. 신속한 디자인
- 일반적인 역할이 아닌 특정 역할: "경험이 풍부한 수석 Python 백엔드 개발자 FastAPI 및 PostgreSQL에서는 "Programmer"보다 훨씬 낫습니다.
- 측정 가능한 목표: "최소 5개 소스를 사용하여 800-1200 단어로 보고서를 작성합니다. 검증 가능하다'가 '연구를 해라'보다 낫다.
- 예상되는 세부 출력: 구조, 형식 및 길이를 정의합니다. 예상 출력의. LLM은 관련된 내용을 정확히 알 때 더 나은 결과를 생성합니다. 잠깐.
- 프롬프트의 안티패턴: 하지 말아야 할 일에 대한 지침을 포함합니다. "발명하지 마세요. 데이터", "2024년 이전 소스를 사용하지 마십시오"는 일반적인 오류를 방지합니다.
2. 비용 관리
# Strategia per il controllo dei costi
crew = Crew(
agents=[researcher, writer, editor],
tasks=[research_task, writing_task, editing_task],
process=Process.sequential,
# Limiti per prevenire costi eccessivi
max_rpm=30, # Rate limit globale
verbose=True, # Monitoring attivo
)
# Dopo l'esecuzione, analizza il consumo
result = crew.kickoff(inputs={"topic": "Test Topic"})
usage = result.token_usage
print(f"Token totali input: {usage.total_tokens}")
print(f"Token totali output: {usage.prompt_tokens}")
print(f"Costo stimato: ${usage.total_tokens * 0.00003:.4f}")
3. 오류 처리 및 복원력
from crewai import Crew, Process
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def run_crew_with_retry(crew, inputs, max_retries=3):
"""Esegue la crew con retry automatico."""
for attempt in range(max_retries):
try:
result = crew.kickoff(inputs=inputs)
logger.info(f"Crew completata al tentativo {attempt + 1}")
return result
except Exception as e:
logger.warning(
f"Tentativo {attempt + 1} fallito: {str(e)}"
)
if attempt == max_retries - 1:
logger.error("Tutti i tentativi esauriti.")
raise
logger.info("Retry in corso...")
return None
4. 승무원 테스트
import pytest
from unittest.mock import patch, MagicMock
def test_research_agent_configuration():
"""Verifica che l'agente di ricerca sia configurato correttamente."""
assert researcher.role == "Senior Tech Research Analyst"
assert len(researcher.tools) == 2
assert researcher.allow_delegation is False
assert researcher.max_iter == 7
def test_task_context_chain():
"""Verifica la catena di contesto tra i task."""
assert research_task in writing_task.context
assert research_task in editing_task.context
assert writing_task in editing_task.context
def test_crew_process():
"""Verifica il tipo di processo della crew."""
assert content_crew.process == Process.sequential
assert len(content_crew.agents) == 3
assert len(content_crew.tasks) == 3
@patch("crewai_tools.SerperDevTool._run")
def test_crew_execution_mock(mock_search):
"""Test di integrazione con mock dei tool esterni."""
mock_search.return_value = "Risultati di ricerca simulati..."
result = content_crew.kickoff(
inputs={"topic": "Test Topic"}
)
assert result is not None
assert len(result.raw) > 0
제한 사항 및 고려 사항
CrewAI는 우아함과 단순함에도 불구하고 알아야 할 중요한 한계가 있습니다. 프로덕션에 적용하기 전에:
CrewAI의 주요 제한 사항
- 흐름에 대한 제한된 제어: LangGraph와는 달리 불가능합니다. 사용자 정의 종료 조건을 사용하여 복잡한 조건 분기 또는 루프를 정의합니다. 흐름은 기본적으로 선형(순차적)이거나 관리자에게 위임됩니다(계층적).
- 불투명한 디버깅: 에이전트가 예상치 못한 또는 낮은 출력을 생성하는 경우 품질이 떨어지면 그 이유를 이해하기 어려울 수 있습니다. verbose 모드는 도움이 되지만 부족함 단계별 추적으로 인해 프로덕션에서 디버깅이 어려워집니다.
- 높은 토큰 소비: 컨텍스트 공유는 전체 출력을 주입합니다. 프롬프트의 이전 작업. 긴 체인을 사용하면 토큰 소비가 빠르게 증가합니다. 문맥상 2000단어 기사는 각 후속 작업에서 약 2500개의 토큰을 소비합니다.
- LLM에 대한 의존성: 출력 품질은 모델에 따라 크게 달라집니다. LLM이 선택되었습니다. 성능이 떨어지는 모델(GPT-3.5, 소규모 로컬 모델)을 사용하여 대표단은 복잡한 추론이 크게 저하됩니다.
- 프레임워크 성숙도: 0.80+ 버전에서는 API가 변경될 수 있습니다. 릴리스 사이. 주요 변경 사항은 첫 번째 버전보다 빈도가 낮았지만 종속성 관리에 주의가 필요합니다.
- 기본 비동기 지원 없음: 팀은 동기적으로 실행됩니다. 비동기 실행이 필요한 웹 애플리케이션의 경우 래핑이 필요합니다. 비동기 스레드 또는 작업에서의 실행.
결론
CrewAI는 다중 에이전트 시스템의 세계로 가장 접근하기 쉬운 진입점을 나타냅니다. 그의 비즈니스 팀 비유는 상담원이 직관적으로 작업할 수 있는 작업 파이프라인을 설계합니다. 전문가들은 복잡한 목표를 달성하기 위해 협력합니다. API의 단순성은 그렇지 않습니다. 성능 희생: 수십 줄의 코드로 시스템 구축이 가능합니다. 자동 검색, 처리 및 검토를 조율하는 정교한 것입니다.
CrewAI의 주요 강점은 최소 학습 곡선, 는 사전 정의된 도구로 구성된 풍부한 생태계 그리고 메모리 시스템 다단계. 주요 제한 사항은 다음과 같습니다. 제한된 통제 흐름 그리고 높은 토큰 소비 작업이 많은 파이프라인의 경우.
CrewAI, LangGraph 및 AutoGen 간의 선택은 바이너리가 아닙니다. 복잡한 아키텍처에서는 가능합니다. 프레임워크 결합: 구조화된 작업 팀에는 CrewAI를 사용하고 워크플로에는 LangGraph를 사용합니다. 반복적인 협상이 필요한 상호 작용을 위한 조건부 분기 및 AutoGen을 사용합니다. 핵심은 각 도구의 장점과 한계를 이해하고 상황에 맞는 도구를 선택하는 것입니다. 시스템의 각 구성 요소.
다음 기사에서는 살펴보겠습니다. AutoGen 및 AG2, 대화 프레임워크 Microsoft Research에서는 사용자 간의 대화를 기반으로 커뮤니케이션 모델을 분석합니다. 에이전트, 코드 생성 및 자체 수정 주기, Human-in-the-Loop 패턴 및 Microsoft Agent Framework로의 마이그레이션 경로입니다.