À medida que a indústria de IA começou a reconhecer as capacidades de raciocínio dos Large Language Models (LLMs), decidimos torná-los mais agentes, permitindo que realizem ações mais complexas. Essas categorias de Large Language Models passaram a ser conhecidas como agentes.
Assim, os sistemas de agente único nasceram. Mas logo ficou evidente que atribuir várias ações a um único agente não era a maneira mais inteligente de construir sistemas agentes. Uma abordagem melhor era usar múltiplos agentes, cada um com sua própria tarefa a realizar, trabalhando juntos para atingir um objetivo definido pelo usuário.
No entanto, outro problema surgiu. Gerenciar múltiplos agentes não é tão fácil quanto gerenciar um único. Para resolver isso, vários frameworks de Sistemas Multi-Agente foram introduzidos, e um dos mais promissores é o CrewAI.
O CrewAI ajuda desenvolvedores a construir Sistemas Multi-Agente. Com o CrewAI, você pode gerenciar seus agentes, suas tarefas e seu fluxo de trabalho. Neste artigo, usaremos o CrewAI junto com a infinidade de LLMs disponíveis na Novita para construir Sistemas Multi-Agente práticos e inteligentes.
O que é um Sistema Multi-Agente e por que precisamos dele?
Desde a introdução dos Large Language Models (LLMs), várias abordagens foram exploradas para torná-los mais autônomos. Uma das mais populares foi o padrão ReAct introduzido no artigo Synergizing Reasoning and Acting in Language Models. Frameworks como o LangChain implementaram rapidamente o ReAct para dar capacidades agentes aos LLMs.
Ferramentas como o AutoGPT foram ainda mais longe, construindo agentes de IA mais robustos que podiam realizar quase qualquer tarefa desejada pelo usuário com apenas um prompt de texto. Embora esses sistemas de agente único tenham mostrado grande promessa, eles apresentavam limitações. Um agente único geralmente depende de um único LLM para lidar com todas as tarefas, o que leva a algumas desvantagens críticas:
- Contexto limitado: Um agente único tem que gerenciar todas as tarefas usando uma única janela de contexto. À medida que o fluxo de trabalho avança, o agente eventualmente fica sem espaço de contexto.
- Complexidade aumentada: À medida que mais tarefas são atribuídas a um único agente, o raciocínio se torna mais difícil de gerenciar, tornando o agente mais propenso a alucinações ou falhas.
- Ponto único de falha: Com um único agente responsável por tudo, não há backup. Se ele não conseguir lidar com uma tarefa, o sistema falha completamente.
- Falta de paralelização: As tarefas são processadas uma após a outra. Não há suporte nativo para agentes trabalhando em paralelo para acelerar o processo.
Os sistemas multi-agente foram introduzidos para resolver esses desafios. Em vez de confiar em um único agente para lidar com várias tarefas, um sistema multi-agente distribui responsabilidades entre vários agentes que trabalham em colaboração. Isso ajuda a evitar problemas como exceder o comprimento do contexto, já que cada agente só precisa gerenciar sua própria parte do fluxo de trabalho, e a carga geral de contexto é reduzida.
Configurações multi-agente também permitem usar modelos diferentes para finalidades diferentes: alguns podem ser ajustados para tarefas específicas, alguns podem vir com prompts predefinidos, alguns podem ser equipados com ferramentas especializadas e outros podem ser otimizados para raciocínio. Essa diversidade não apenas melhora o desempenho, mas também permite o paralelismo, tornando os sistemas multi-agente mais rápidos e eficientes do que seus equivalentes de agente único.
Para construir um sistema multi-agente, você precisa de dois componentes principais: um provedor de modelos que forneça os LLMs e um framework multi-agente para gerenciar todo o fluxo de trabalho agente. Neste artigo, usaremos a Novita como nosso provedor de modelos e o CrewAI como nosso framework de escolha.
Por que você precisa de um framework como o CrewAI
Construir um sistema multi-agente é muito mais complexo do que construir um sistema de agente único. Por exemplo, você pode facilmente transformar qualquer modelo da Novita em um agente, dando a ele ferramentas por meio do uso de chamadas de função. Mas assim que você começa a conectar múltiplos agentes, a complexidade aumenta significativamente. Agora você tem que gerenciar várias partes móveis, incluindo:
- Comunicação e delegação de tarefas: Você precisa coordenar como os agentes se comunicam entre si e como as tarefas são transferidas entre eles.
- Gerenciamento de ferramentas: Sem um framework, você é responsável por gerenciar definições de ferramentas e esquemas JSON manualmente, algo que pode rapidamente se tornar desorganizado.
- Arquiteturas e padrões agentes: Frameworks multi-agente geralmente vêm com suporte nativo a padrões agentes bem estabelecidos. Se você estiver construindo do zero, precisará se manter atualizado com esses padrões em evolução e implementá-los você mesmo.
- Observabilidade: Sem um framework, você também é responsável por configurar suas próprias ferramentas para monitorar, depurar e visualizar como seus agentes interagem e performam.
Um framework Multi-Agente pode ajudar a gerenciar todas essas complexidades. Neste artigo, usaremos o CrewAI como nosso framework de escolha. O CrewAI oferece várias vantagens em relação a outros frameworks: se destaca por sua simplicidade, usando conceitos intuitivos para modelar Sistemas Multi-Agente; é maduro e bem estabelecido; e fornece uma excelente experiência para desenvolvedores.
Entendendo os Conceitos Principais do CrewAI
Para construir sistemas multi-agente com o CrewAI, você precisa estar familiarizado com alguns conceitos principais introduzidos pelo framework. Aqui está uma breve visão geral dos principais com os quais trabalharemos neste artigo:
- Agentes
- Tarefas
- Crews
- Processos
- Flows
Agentes
Agentes são o núcleo do CrewAI. Eles representam os trabalhadores de IA reais alimentados por um LLM. Cada agente no CrewAI é definido por uma função, um objetivo que guia sua tomada de decisão e uma história de fundo que molda sua personalidade. Todos eles são representados como prompts de texto enviados ao LLM. Os agentes também podem ser equipados com ferramentas, das quais podem escolher para realizar ações específicas. O objetivo principal de um agente no CrewAI é concluir a tarefa ou tarefas atribuídas a ele.
Tarefas
Tarefas definem o trabalho que precisa ser concluído. No CrewAI, você pode criar tarefas e atribuí-las diretamente a agentes específicos ou permitir que os agentes as peguem se corresponderem aos requisitos da tarefa. Cada tarefa geralmente inclui uma descrição clara, uma saída esperada e outros parâmetros relevantes, como um agente opcional que pode lidar com a tarefa.
Crew
Este é o conceito central do CrewAI. No CrewAI, um grupo de agentes trabalhando juntos para realizar tarefas é chamado de crew. Uma crew também define o fluxo de trabalho dos agentes dentro dela.
Processos
Um processo é um fluxo de trabalho predefinido que informa a uma crew como executar suas tarefas. O CrewAI suporta dois tipos principais de processos:
- Sequencial: As tarefas são tratadas uma de cada vez pelos agentes da crew.
- Hierárquico: Nesse processo, um agente atua como gerente, coordenando outros agentes e delegando tarefas conforme necessário.
Flows
Enquanto os processos são fluxos de trabalho predefinidos, os flows do CrewAI dão aos desenvolvedores a flexibilidade de projetar fluxos de trabalho de agentes personalizados. Um flow pode incluir agentes, tarefas e até crews inteiras, permitindo interações mais complexas.
Construindo Crews com a Novita
Agora que cobrimos os conceitos principais do CrewAI, vamos passar pelo processo de construção de uma Crew. Neste exemplo, criaremos uma Crew projetada para ajudar usuários a construir rapidamente um produto mínimo viável (MVP). Esta Crew consiste em três agentes especializados:
- Architect: Define a estrutura do software e delineia o escopo do MVP. Este agente é alimentado pelo modelo moonshotai/kimi-k2-instruct, hospedado na Novita.
- Coder: Implementa o plano do Architect e escreve o código real. Ele usa uma ferramenta FileWriter para criar todos os arquivos do projeto e é executado no modelo qwen/qwen3-coder-480b-a35b-instruct da Novita.
- Reviewer: Analisa o código gerado pelo Coder e sugere melhorias usando feedback no estilo diff. Assim como o Architect, ele também usa o modelo moonshotai/kimi-k2-instruct.
Nossa Crew seguirá um processo sequencial.
Instalação e Configuração
Agora que temos um plano definido, vamos começar configurando nosso ambiente. Começaremos instalando o CrewAI junto com seu suporte a ferramentas nativas:
pip install 'crewai[tools]'
Em seguida, você precisará da sua chave de API da Novita. Assim que tiver ela, adicione-a às suas variáveis de ambiente como NOVITA_API_KEY:
export NOVITA_API_KEY=your_api_key_here
Com isso feito, estamos prontos para começar a construir a Crew.
Criando os LLMs
Vamos começar importando as dependências necessárias:
import os
from crewai import Agent, Task, Crew, Process, LLM
from crewai_tools import FileWriterTool
Em seguida, criaremos uma instância da FileWriterTool, que será usada pelo agente Coder para escrever arquivos no disco:
file_writer_tool = FileWriterTool()
Com as ferramentas configuradas, agora podemos inicializar os LLMs para cada um de nossos agentes:
architect_llm = LLM(
model="novita/moonshotai/kimi-k2-instruct",
temperature=0.5,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ['NOVITA_API_KEY']
)
coder_llm = LLM(
model="novita/qwen/qwen3-coder-480b-a35b-instruct",
temperature=0.4,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ['NOVITA_API_KEY']
)
reviewer_llm = LLM(
model="novita/moonshotai/kimi-k2-instruct",
temperature=0.5,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ['NOVITA_API_KEY']
)
Essas três instâncias de LLM correspondem aos modelos descritos em nosso plano. Eles estão hospedados na Novita e acessados via CrewAI. Nos bastidores, o CrewAI usa o LiteLLM para conectar e gerenciar esses modelos.
Definindo os Agentes
Agora vamos criar os três agentes:
architect = Agent(
role="Software Architect for MVP Projects",
goal="Define a basic system structure and simple feature set to guide MVP development",
backstory="""You specialize in quickly outlining software architectures and project scopes for
minimum viable products. Your plans help guide coders with enough structure to get started while staying lean.""",
llm=architect_llm,
verbose=True
)
coder = Agent(
role="Developer for MVP Projects",
goal="Implement the MVP using simple, clear code, and write all necessary code files using the FileWriter tool",
backstory="""You're a practical developer focused on speed. You prioritize working code over polish.
Simulate any runtime behavior if needed, and make sure to keep code clear and modular.""",
llm=coder_llm,
verbose=True,
tools=[file_writer_tool]
)
reviewer = Agent(
role="Code Reviewer for MVP Projects",
goal="Read the code files, provide helpful feedback, and write improvements as diffs into a markdown file",
backstory="""You're a fast but thoughtful reviewer. You check code for clarity, obvious bugs, and
provide improvements as diffs. Instead of modifying code directly, you
save your suggestions in a markdown file
for easy inspection.""",
llm=reviewer_llm,
verbose=True,
tools=[file_writer_tool]
)
Cada agente recebe uma função, um objetivo e uma história de fundo específicos.
Definindo as Tarefas
Vamos criar as tarefas dos agentes:
architect_task = Task(
description="""
Create a basic plan for building a simple MVP version of a {project}.
Focus on the core features, basic file structure, and tech stack.
Make the structure minimal but enough to get a working demo.
""",
expected_output="""
A simple architectural overview with:
- Project goals
- Key components or files
- Basic data flow or structure
""",
agent=architect,
output_file="architecture.md"
)
coder_task = Task(
description="""
Based on the architect's plan, implement the core parts of the {project} MVP.
Keep it lean and functional. Use the FileWriter tool to save all your code files.
If you need to simulate behavior (e.g. without a real interpreter), do so with clear comments or mocked logic.
""",
expected_output="""
Working code files saved using the FileWriter tool that implement the key features defined in the plan.
Code should be readable and logically structured.
""",
agent=coder,
context=[architect_task]
)
review_task = Task(
description="""
Review the code files created for the {project} MVP. Read each file using the FileRead tool.
Suggest improvements using diffs. Do not modify the original code files directly.
Instead, save all your suggested diffs into a markdown file using the FileWriter tool.
""",
expected_output="""
A markdown file containing diff-style suggestions for each file reviewed.
""",
agent=reviewer,
context=[coder_task],
output_file="code_review_diffs.md"
)
Criando a Crew
Agora que definimos nossos agentes, seus respectivos LLMs e tarefas, vamos reunir tudo montando a crew:
code_crew = Crew(
agents=[architect, coder, reviewer],
tasks=[architect_task, coder_task, review_task],
process=Process.sequential,
verbose=True
)
Com tudo configurado, agora podemos executar a crew:
if __name__ == "__main__":
code_crew.kickoff(inputs={"project": "Todo App"})
Agora temos uma crew totalmente funcional capaz de gerar um projeto de MVP com base em uma especificação definida pelo usuário. No exemplo acima, pedimos à crew para construir um aplicativo de lista de tarefas simples.
Veja como funciona:
- O agente Architect inicia o processo projetando a arquitetura do software e salvando o plano em um arquivo chamado architecture.md.
- O agente Coder então pega a saída do architect e cria os diretórios e arquivos de código necessários para implementar o aplicativo de lista de tarefas.
- Por fim, o agente Reviewer revisa o código gerado e fornece sugestões usando diffs, salvando seu feedback em um arquivo chamado code_review_diffs.md.
Este fluxo de trabalho de desenvolvimento baseado em crew é poderoso e modular, mas não está isento de algumas limitações:
- Prompts hardcoded: Ao inserir prompts diretamente no código, torna-se mais difícil mantê-los ou melhorá-los ao longo do tempo.
- Estrutura dispersa: Agentes e tarefas são definidos inline, o que pode levar a um script desorganizado e mais difícil de navegar à medida que o projeto cresce.
Na próxima seção, veremos como organizar isso externalizando as definições de agentes e os prompts de tarefas para arquivos YAML.
Construindo Crews Baseadas em Classes
O CrewAI nos permite criar crews baseadas em classes. Vamos atualizar nosso código anterior para seguir essa estrutura. Primeiro, crie uma pasta chamada config. Esta pasta conterá arquivos YAML que definem a configuração para os agentes e tarefas.
Vamos criar um arquivo chamado agents.yaml, que servirá como o arquivo de configuração dos agentes:
architect:
role: >
Software Architect for MVP Projects
goal: >
Define a basic system structure and simple feature set to guide MVP development
backstory: >
You specialize in quickly outlining software architectures and project scopes for minimum viable products.
Your plans help guide coders with enough structure to get started while staying lean.
coder:
role: >
Developer for MVP Projects
goal: >
Implement the MVP using simple, clear code, and write all necessary code files using the FileWriter tool
backstory: >
You're a practical developer focused on speed. You prioritize working code over polish.
Simulate any runtime behavior if needed, and make sure to keep code clear and modular.
reviewer:
role: >
Code Reviewer for MVP Projects
goal: >
Read the code files, provide helpful feedback, and write improvements as diffs into a markdown file
backstory: >
You're a fast but thoughtful reviewer. You check code for clarity, obvious bugs, and provide improvements
as diffs. Instead of modifying code directly, you save your suggestions in a markdown file for easy inspection.
Este arquivo define as funções, objetivos e histórias de fundo para cada agente.
Em vez disso, salve todos os seus diffs sugeridos em um arquivo markdown usando a ferramenta FileWriter.
Em seguida, criaremos um arquivo tasks.yaml para armazenar as configurações das tarefas:
architect_task:
description: >
Create a basic plan for building a simple MVP version of a {project}.
Focus on the core features, basic file structure, and tech stack.
Make the structure minimal but enough to get a working demo.
expected_output: >
A simple architectural overview with:
- Project goals
- Key components or files
- Basic data flow or structure
agent: architect
output_file: architecture.md
coder_task:
description: >
Based on the architect's plan, implement the core parts of the {project} MVP.
Keep it lean and functional. Use the FileWriter tool to save all your code files.
If you need to simulate behavior (e.g. without a real interpreter), do so with clear comments or mocked logic.
expected_output: >
Working code files saved using the FileWriter tool that implement the key features defined in the plan.
Code should be readable and logically structured.
agent: coder
context:
- architect_task
review_task:
description: >
Review the code files created for the {project} MVP. Read each file using the FileRead tool.
Suggest improvements using diffs. Do not modify the original code files directly.
Instead, save all your suggested diffs into a markdown file using the FileWriter tool.
expected_output: >
A markdown file containing diff-style suggestions for each file reviewed.
agent: reviewer
context:
- coder_task
output_file: code_review_diffs.md
Em seguida, vamos criar nossa Crew baseada em classes. Para fazer isso, definimos uma classe e a decoramos com o decorador @CrewBase fornecido pelo CrewAI.
@CrewBase
class CodeCrew():
"""Three-agent code crew: architect, coder, reviewer"""
@agent
def architect(self) -> Agent:
pass
@agent
def coder(self) -> Agent:
pass
@agent
def reviewer(self) -> Agent:
pass
@task
def architect_task(self) -> Task:
pass
@task
def code_task(self) -> Task:
pass
@task
def review_task(self) -> Task:
pass
@crew
def crew(self) -> Crew:
pass
Nesta estrutura:
- O decorador @agent é usado para definir métodos que produzem agentes.
- O decorador @task marca métodos que produzem tarefas.
- O decorador @crew especifica o método que monta a crew inteira.
Agora, vejamos a implementação completa:
import os
from crewai import Agent, Crew, Process, Task, LLM
from crewai.project import CrewBase, agent, crew, task
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List
from crewai_tools import FileWriterTool
# Instantiate tool
file_writer_tool = FileWriterTool()
@CrewBase
class CodeCrew():
agents: List[BaseAgent]
tasks: List[Task]
agents_config = 'config/agents.yaml'
tasks_config = 'config/tasks.yaml'
@agent
def architect(self) -> Agent:
llm = LLM(
model="novita/moonshotai/kimi-k2-instruct",
temperature=0.5,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ['NOVITA_API_KEY']
)
return Agent(
config=self.agents_config['architect'],
llm=llm,
verbose=True
)
@agent
def coder(self) -> Agent:
llm = LLM(
model="novita/qwen/qwen3-coder-480b-a35b-instruct",
temperature=0.4,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ['NOVITA_API_KEY']
)
return Agent(
config=self.agents_config['coder'],
llm=llm,
verbose=True,
tools=[file_writer_tool]
)
@agent
def reviewer(self) -> Agent:
llm = LLM(
model="novita/moonshotai/kimi-k2-instruct",
temperature=0.5,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ['NOVITA_API_KEY']
)
return Agent(
config=self.agents_config['reviewer'],
llm=llm,
verbose=True,
)
@task
def architect_task(self) -> Task:
return Task(config=self.tasks_config['architect_task'])
@task
def coder_task(self) -> Task:
return Task(config=self.tasks_config['coder_task'])
@task
def review_task(self) -> Task:
return Task(config=self.tasks_config['review_task'])
@crew
def crew(self) -> Crew:
return Crew(
agents=self.agents,
tasks=self.tasks,
process=Process.sequential,
verbose=True
)
Este código define todos os métodos necessários e inclui atributos para agentes e tarefas. Ele também especifica os caminhos para os arquivos de configuração, que são usados nos métodos de agente e tarefa para carregar suas respectivas configurações.
Agora você pode executar a crew adicionando o seguinte código ao script:
def main():
code_crew = CodeCrew()
code_crew.crew().kickoff(inputs={"project": "Todo App"})
if __name__ == '__main__':
main()
Construindo Flows com a Novita
Anteriormente, construímos uma crew que seguia um processo sequencial. Agora, vamos explorar como construir um flow que segue um fluxo de trabalho projetado personalizadamente.
Nosso Fluxo de Trabalho
Queremos projetar um Sistema Multi-Agente de Suporte ao Cliente que tenha um agente líder responsável por classificar os problemas dos clientes. Com base na classificação, o sistema determinará qual agente especializado é mais adequado para lidar com o problema. A configuração consiste em quatro agentes:
- Customer Agent: Este é o agente líder. Ele recebe o problema do cliente e o classifica em uma das seguintes categorias: Cobrança, Técnico ou Geral.
- Agente de Cobrança: Lida com todos os problemas relacionados a cobrança.
- Agente Técnico: Lida com problemas técnicos.
- Agente Geral: Lida com quaisquer problemas que não se encaixem nas categorias acima.
Definindo o Estado do Flow
Os Flows no CrewAI têm um estado compartilhado. O estado é acessível em todos os agentes e crews dentro do flow. Para nosso fluxo de suporte ao cliente, o estado contém o rótulo do problema e a consulta do usuário.
Vamos importar os módulos necessários e definir nosso estado:
import json
import os
from typing import Literal, Dict, Any
from pydantic import BaseModel, ValidationError
from crewai import Agent, LLM
from crewai.flow.flow import Flow, start, router, listen
# Define the flow state
class SupportState(BaseModel):
issue: Literal["billing", "technical", "general"] = "general"
message: str = ""
Criando o Flow
Os Flows no CrewAI são baseados em grafos e usam um sistema orientado a eventos para lidar com transições entre nós. Para criar nosso flow, começaremos com um nó que classifica o problema, seguido por um nó de roteador que determina para qual nó de manipulador rotear com base na classificação.
class CustomerSupportFlow(Flow[SupportState]):
@start()
def classify_issue(self):
pass
@router(classify_issue)
def route_based_on_issue(self) -> str:
print(f"📨 Routing to agent for issue type: {self.state.issue}")
if self.state.issue == "billing":
return "billing"
if self.state.issue == "technical":
return "technical"
else:
return "general"
@listen("billing")
def handle_billing(self):
pass
@listen("technical")
def handle_technical(self):
pass
@listen("general")
def handle_general(self):
pass
O método decorado com @start() é o ponto de entrada do flow. Neste caso, ele lida com a classificação de problemas. O método decorado com @router() é executado após o classify_issue e determina para qual agente rotear. Os outros métodos usam o sistema orientado a eventos para responder quando são roteados.
Implementando os Métodos do Flow
Agora vamos implementar cada método e atribuir o agente apropriado a cada um:
class CustomerSupportFlow(Flow[SupportState]):
@start()
def classify_issue(self) -> Dict[str, Any]:
intake_agent = Agent(
role="User Intake Agent",
goal="Classify user support issue and summarize the message",
backstory="You classify the user query into billing, technical, or general categories.",
llm=LLM(
model="novita/qwen/qwen2.5-vl-72b-instruct",
temperature=0.3,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ["NOVITA_API_KEY"]
),
verbose=True
)
prompt = f"""
A user submitted this message: "{self.state.message}"
Your task:
1. Identify whether the issue is "billing", "technical", or "general".
2. Rephrase or extract the message clearly.
Respond in valid JSON format like the example below:
{{
"issue": "billing",
"message": "The user has been charged twice for their subscription and is requesting a refund."
}}
"""
output = intake_agent.kickoff(prompt, response_format=SupportState)
try:
# Parse the JSON string
print(output.raw)
parsed_json = json.loads(output.raw)
# Validate with Pydantic
validated = SupportState(**parsed_json)
# Save to state
self.state.issue = validated.issue
self.state.message = validated.message
except (json.JSONDecodeError, ValidationError) as e:
print("❌ Failed to parse or validate response:", e)
self.state.issue = "general"
@router(classify_issue)
def route_based_on_issue(self) -> str:
print(f"📨 Routing to agent for issue type: {self.state.issue}")
if self.state.issue == "billing":
return "billing"
if self.state.issue == "technical":
return "technical"
else:
return "general"
@listen("billing")
def handle_billing(self):
agent = Agent(
role="Billing Agent",
goal="Handle billing questions, refunds, and invoice issues",
backstory="You resolve billing-related queries effectively.",
llm=LLM(
model="novita/meta-llama/llama-3.3-70b-instruct",
temperature=0.5,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ["NOVITA_API_KEY"]
),
verbose=True
)
result = agent.kickoff(self.state.message)
print("💰 Billing Agent Response:", result)
@listen("technical")
def handle_technical(self):
agent = Agent(
role="Technical Support Agent",
goal="Help users resolve technical issues",
backstory="You're a technical expert providing troubleshooting support.",
llm=LLM(
model="novita/meta-llama/llama-3.1-8b-instruct",
temperature=0.5,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ["NOVITA_API_KEY"]
),
verbose=True
)
result = agent.kickoff(self.state.message)
print("🛠 Technical Agent Response:", result)
@listen("general")
def handle_general(self):
agent = Agent(
role="General Support Agent",
goal="Provide helpful answers to non-technical and non-billing questions",
backstory="You're friendly and well-informed about our services.",
llm=LLM(
model="novita/minimaxai/minimax-m1-80k",
temperature=0.5,
api_base="https://api.novita.ai/v3/openai",
api_key=os.environ["NOVITA_API_KEY"]
),
verbose=True
)
result = agent.kickoff(self.state.message)
print("📋 General Agent Response:", result)
O método classify_issue usa o Pydantic para garantir que o modelo retorne uma resposta válida. Com essa configuração concluída, agora podemos executar o flow usando o seguinte código:
def run():
flow = CustomerSupportFlow()
flow.plot("CustomerSupportFlowPlot")
# Example input message
example_input = {
"message": "Hello, I was charged twice for my subscription and need a refund."
}
flow.kickoff(inputs=example_input)
if __name__ == "__main__":
run()
Conclusão
Para construir um Sistema Multi-Agente, você precisa de dois componentes principais: um provedor de modelos que ofereça uma grande variedade de modelos e um Framework Multi-Agente para orquestrar suas interações. Neste artigo, mostramos como a Novita e o CrewAI podem desempenhar esses papéis de forma eficaz. Para saber mais sobre o CrewAI, não deixe de explorar sua documentação. E se você está procurando experimentar mais modelos para suas crews, confira o LLM playground da Novita.
Repositório com arquivos - https://github.com/novitalabs/Novita-CollabHub/tree/main/examples/novita-crewai
Sobre a Novita AI
NovitaAIé uma plataforma de nuvem de IA que oferece aos desenvolvedores uma maneira fácil de implantar modelos de IA usando nossa API simples, além de fornecer uma nuvem de GPU acessível e confiável para construir e escalar.
