​
Visão Geral

Uma crew no crewAI representa um grupo colaborativo de agentes trabalhando em conjunto para alcançar um conjunto de tarefas. Cada crew define a estratégia de execução de tarefas, colaboração entre agentes e o fluxo de trabalho geral.

​
Atributos de Crew

AtributoParâmetrosDescrição
TaskstasksUma lista de tasks atribuídas à crew.
AgentsagentsUma lista de agentes que fazem parte da crew.
Process (opcional)processO fluxo de processo (por exemplo, sequencial, hierárquico) seguido pela crew. O padrão é sequential.
Verbose (opcional)verboseO nível de verbosidade para logging durante a execução. O padrão é False.
Manager LLM (opcional)manager_llmO modelo de linguagem utilizado pelo agente gerenciador em um processo hierárquico. Obrigatório ao usar um processo hierárquico.
Function Calling LLM (opcional)function_calling_llmSe definido, a crew utilizará este LLM para invocar funções das ferramentas para todos os agentes da crew. Cada agente pode ter seu próprio LLM, que substitui o LLM da crew para chamadas de função.
Config (opcional)configConfigurações opcionais para a crew, no formato Json ou Dict[str, Any].
Max RPM (opcional)max_rpmNúmero máximo de requisições por minuto que a crew respeita durante a execução. O padrão é None.
Memory (opcional)memoryUtilizada para armazenar memórias de execução (curto prazo, longo prazo, memória de entidade).
Memory Config (opcional)memory_configConfiguração para o provedor de memória a ser utilizada pela crew.
Cache (opcional)cacheEspecifica se deve usar cache para armazenar os resultados da execução de ferramentas. O padrão é True.
Embedder (opcional)embedderConfiguração do embedder a ser utilizado pela crew. Atualmente mais usado por memory. O padrão é {"provider": "openai"}.
Step Callback (opcional)step_callbackUma função chamada após cada etapa de cada agente. Pode ser usada para registrar as ações do agente ou executar outras operações; não sobrescreve o step_callback específico do agente.
Task Callback (opcional)task_callbackUma função chamada após a conclusão de cada tarefa. Útil para monitoramento ou para operações adicionais pós-execução da task.
Share Crew (opcional)share_crewSe deseja compartilhar as informações completas da crew e execução com a equipe do crewAI para melhorar a biblioteca e nos permitir treinar modelos.
Output Log File (opcional)output_log_fileDefina como True para salvar logs como logs.txt no diretório atual ou forneça um caminho de arquivo. Os logs estarão em formato JSON se o nome terminar com .json, caso contrário .txt. O padrão é None.
Manager Agent (opcional)manager_agentmanager define um agente customizado que será utilizado como gerente.
Prompt File (opcional)prompt_fileCaminho para o arquivo JSON de prompt a ser utilizado pela crew.
Planning (opcional)planningAdiciona habilidade de planejamento à Crew. Quando ativado, antes de cada iteração, todos os dados da Crew são enviados a um AgentPlanner que planejará as tasks e este plano será adicionado à descrição de cada task.
Planning LLM (opcional)planning_llmO modelo de linguagem usado pelo AgentPlanner em um processo de planejamento.

Crew Max RPM: O atributo max_rpm define o número máximo de requisições por minuto que a crew pode executar para evitar limites de taxa e irá sobrescrever as configurações de max_rpm dos agentes individuais se você o definir.

​
Criando Crews

Existem duas maneiras de criar crews no CrewAI: utilizando configuração YAML (recomendado) ou definindo diretamente em código.

​
Configuração YAML (Recomendado)

O uso da configuração YAML proporciona uma forma mais limpa e fácil de manter para definir crews, sendo consistente com a definição de agentes e tasks em projetos CrewAI.

Após criar seu projeto CrewAI conforme descrito na seção Instalação, você pode definir sua crew em uma classe que herda de CrewBase e utiliza decorators para definir agentes, tarefas e a própria crew.

​
Exemplo de Classe Crew com Decorators

code
from crewai import Agent, Crew, Task, Process
from crewai.project import CrewBase, agent, task, crew, before_kickoff, after_kickoff
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List

@CrewBase
class YourCrewName:
    """Descrição da sua crew"""

    agents: List[BaseAgent]
    tasks: List[Task]

    # Caminhos para seus arquivos de configuração YAML
    # Para um exemplo de agente e tarefa definidos em YAML, confira:
    # - Task: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
    # - Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
    agents_config = 'config/agents.yaml'
    tasks_config = 'config/tasks.yaml'

    @before_kickoff
    def prepare_inputs(self, inputs):
        # Modifique inputs antes da crew iniciar
        inputs['additional_data'] = "Alguma informação extra"
        return inputs

    @after_kickoff
    def process_output(self, output):
        # Modifique a saída após a crew finalizar
        output.raw += "\nProcessado após kickoff."
        return output

    @agent
    def agent_one(self) -> Agent:
        return Agent(
            config=self.agents_config['agent_one'], # type: ignore[index]
            verbose=True
        )

    @agent
    def agent_two(self) -> Agent:
        return Agent(
            config=self.agents_config['agent_two'], # type: ignore[index]
            verbose=True
        )

    @task
    def task_one(self) -> Task:
        return Task(
            config=self.tasks_config['task_one'] # type: ignore[index]
        )

    @task
    def task_two(self) -> Task:
        return Task(
            config=self.tasks_config['task_two'] # type: ignore[index]
        )

    @crew
    def crew(self) -> Crew:
        return Crew(
            agents=self.agents,  # Coletado automaticamente pelo decorator @agent
            tasks=self.tasks,    # Coletado automaticamente pelo decorator @task
            process=Process.sequential,
            verbose=True,
        )

Como executar o código acima:

code
YourCrewName().crew().kickoff(inputs={"any": "input here"})

As tarefas serão executadas na ordem em que forem definidas.

A classe CrewBase, junto com esses decorators, automatiza a coleta de agentes e tarefas, reduzindo a necessidade de gerenciamento manual.

​
Visão geral dos Decorators de annotations.py

O CrewAI fornece vários decorators no arquivo annotations.py que são usados para marcar métodos dentro de sua classe crew para tratamento especial:

  • @CrewBase: Marca a classe como classe base de crew.
  • @agent: Denota um método que retorna um objeto Agent.
  • @task: Denota um método que retorna um objeto Task.
  • @crew: Denota o método que retorna o objeto Crew.
  • @before_kickoff: (Opcional) Marca um método a ser executado antes da crew iniciar.
  • @after_kickoff: (Opcional) Marca um método a ser executado após a crew finalizar.

Esses decorators ajudam na organização da estrutura da sua crew e coletam automaticamente agentes e tasks sem precisar listá-los manualmente.

​
Definição Direta em Código (Alternativa)

Como alternativa, você pode definir a crew diretamente em código sem utilizar arquivos de configuração YAML.

code
from crewai import Agent, Crew, Task, Process
from crewai_tools import YourCustomTool

class YourCrewName:
    def agent_one(self) -> Agent:
        return Agent(
            role="Data Analyst",
            goal="Analyze data trends in the market",
            backstory="An experienced data analyst with a background in economics",
            verbose=True,
            tools=[YourCustomTool()]
        )

    def agent_two(self) -> Agent:
        return Agent(
            role="Market Researcher",
            goal="Gather information on market dynamics",
            backstory="A diligent researcher with a keen eye for detail",
            verbose=True
        )

    def task_one(self) -> Task:
        return Task(
            description="Collect recent market data and identify trends.",
            expected_output="A report summarizing key trends in the market.",
            agent=self.agent_one()
        )

    def task_two(self) -> Task:
        return Task(
            description="Research factors affecting market dynamics.",
            expected_output="An analysis of factors influencing the market.",
            agent=self.agent_two()
        )

    def crew(self) -> Crew:
        return Crew(
            agents=[self.agent_one(), self.agent_two()],
            tasks=[self.task_one(), self.task_two()],
            process=Process.sequential,
            verbose=True
        )

Como executar o código acima:

code
YourCrewName().crew().kickoff(inputs={})

Neste exemplo:

  • Agentes e tarefas são definidos diretamente dentro da classe, sem decorators.
  • Criamos e gerenciamos manualmente a lista de agentes e tasks.
  • Essa abordagem fornece mais controle, mas pode ser menos sustentável para projetos maiores.

​
Saída da Crew

A saída de uma crew no framework CrewAI é encapsulada na classe CrewOutput. Essa classe fornece uma forma estruturada de acessar os resultados da execução da crew, incluindo vários formatos como string bruta, JSON e modelos Pydantic. O CrewOutput inclui os resultados da tarefa final, uso de tokens e as saídas das tasks individuais.

​
Atributos do Crew Output

AtributoParâmetrosTipoDescrição
RawrawstrA saída bruta da crew. Este é o formato padrão da saída.
PydanticpydanticOptional[BaseModel]Um objeto modelo Pydantic representando a saída estruturada da crew.
JSON Dictjson_dictOptional[Dict[str, Any]]Um dicionário representando a saída da crew em formato JSON.
Tasks Outputtasks_outputList[TaskOutput]Uma lista de objetos TaskOutput, cada um representando a saída de uma task na crew.
Token Usagetoken_usageDict[str, Any]Um resumo do uso de tokens, oferecendo informações sobre a performance do modelo de linguagem.

​
Métodos e Propriedades do Crew Output

Método/PropriedadeDescrição
jsonRetorna a representação em string JSON da saída da crew caso o formato seja JSON.
to_dictConverte as saídas JSON e Pydantic em um dicionário.
strRetorna a representação em string do resultado da crew, priorizando Pydantic, depois JSON, depois raw.

​
Acessando a Saída da Crew

Após executar uma crew, sua saída pode ser acessada pelo atributo output do objeto Crew. A classe CrewOutput oferece várias formas de interagir com esta saída.

​
Exemplo

Code
# Execução de exemplo da crew
crew = Crew(
    agents=[research_agent, writer_agent],
    tasks=[research_task, write_article_task],
    verbose=True
)

crew_output = crew.kickoff()

# Acessando a saída da crew
print(f"Raw Output: {crew_output.raw}")
if crew_output.json_dict:
    print(f"JSON Output: {json.dumps(crew_output.json_dict, indent=2)}")
if crew_output.pydantic:
    print(f"Pydantic Output: {crew_output.pydantic}")
print(f"Tasks Output: {crew_output.tasks_output}")
print(f"Token Usage: {crew_output.token_usage}")

​
Acessando Logs da Crew

Você pode visualizar o log em tempo real da execução da crew, definindo output_log_file como True(Boolean) ou um file_name(str). Suporta logging de eventos como tanto file_name.txt quanto file_name.json. Se for True(Boolean), salvará como logs.txt.

Caso output_log_file seja False(Boolean) ou None, os logs não serão gerados.

Code
# Salvar logs da crew
crew = Crew(output_log_file = True)  # Logs serão salvos como logs.txt
crew = Crew(output_log_file = file_name)  # Logs serão salvos como file_name.txt
crew = Crew(output_log_file = file_name.txt)  # Logs serão salvos como file_name.txt
crew = Crew(output_log_file = file_name.json)  # Logs serão salvos como file_name.json

​
Utilização de Memória

As crews podem utilizar memória (curto prazo, longo prazo e memória de entidade) para potencializar sua execução e aprendizado ao longo do tempo. Este recurso permite que as crews armazenem e recuperem memórias de execução, auxiliando na tomada de decisão e nas estratégias de execução de tasks.

​
Utilização de Cache

Caches podem ser utilizados para armazenar resultados de execuções de ferramentas, tornando o processo mais eficiente ao evitar a reexecução de tasks idênticas.

​
Métricas de Uso da Crew

Após a execução da crew, você pode acessar o atributo usage_metrics para visualizar as métricas de uso do modelo de linguagem (LLM) para todas as tasks executadas pela crew. Isso fornece insights sobre eficiência operacional e oportunidades de melhoria.

Code
# Acessar as métricas de uso da crew
crew = Crew(agents=[agent1, agent2], tasks=[task1, task2])
crew.kickoff()
print(crew.usage_metrics)

​
Processo de Execução da Crew

  • Sequential Process: As tasks são executadas uma após a outra, permitindo um fluxo de trabalho linear.
  • Hierarchical Process: Um agente gerente coordena a crew, delegando tarefas e validando resultados antes de prosseguir. Nota: Um manager_llm ou manager_agent é necessário para este processo e é essencial para validar o fluxo.

​
Iniciando uma Crew

Uma vez que sua crew esteja montada, inicie o workflow com o método kickoff(). Isso inicia a execução conforme o fluxo de processo definido.

Code
# Iniciar execução das tasks da crew
result = my_crew.kickoff()
print(result)

​
Diferentes Formas de Iniciar uma Crew

Assim que sua crew estiver definida, inicie o fluxo de trabalho com o método kickoff apropriado. O CrewAI oferece vários métodos para melhor controle do processo: kickoff(), kickoff_for_each(), kickoff_async() e kickoff_for_each_async().

  • kickoff(): Inicia o processo de execução seguindo o fluxo definido.
  • kickoff_for_each(): Executa tasks sequencialmente para cada evento de entrada ou item da coleção fornecida.
  • kickoff_async(): Inicia o workflow de forma assíncrona.
  • kickoff_for_each_async(): Executa as tasks concorrentemente para cada entrada, aproveitando o processamento assíncrono.
Code
# Iniciar execução das tasks da crew
result = my_crew.kickoff()
print(result)

# Exemplo com kickoff_for_each
inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
results = my_crew.kickoff_for_each(inputs=inputs_array)
for result in results:
    print(result)

# Exemplo com kickoff_async
inputs = {'topic': 'AI in healthcare'}
async_result = await my_crew.kickoff_async(inputs=inputs)
print(async_result)

# Exemplo com kickoff_for_each_async
inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
async_results = await my_crew.kickoff_for_each_async(inputs=inputs_array)
for async_result in async_results:
    print(async_result)

Esses métodos fornecem flexibilidade para gerenciar e executar tasks dentro de sua crew, permitindo fluxos de trabalho síncronos e assíncronos de acordo com sua necessidade.

​
Repetindo Execução a partir de uma Task Específica

Agora é possível reiniciar a execução a partir de uma task específica usando o comando CLI replay.

O recurso de replay no CrewAI permite reexecutar a partir de uma task específica através da interface de linha de comando (CLI). Rodando o comando crewai replay -t <task_id>, você pode especificar o task_id para o processo de replay.

Kickoffs agora salvam localmente as saídas das tasks dos kickoffs recentes para permitir replay posteriormente.

​
Repetindo a Partir de uma Task Específica Usando o CLI

Para usar o recurso de replay, siga estes passos:

  1. Abra seu terminal ou prompt de comando.
  2. Navegue até o diretório do seu projeto CrewAI.
  3. Execute o seguinte comando:

Para visualizar os IDs das últimas tasks do kickoff, utilize:

crewai log-tasks-outputs

Depois, para repetir a partir de uma task específica, utilize:

crewai replay -t <task_id>

Esses comandos permitem repetir tasks dos seus últimos kickoffs, mantendo o contexto das tasks já executadas anteriormente.