> ## Documentation Index
> Fetch the complete documentation index at: https://docs.crewai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# CLI

> Aprenda a usar o CLI do CrewAI para interagir com o CrewAI.

> [!WARNING]
>
> A partir da versão 0.140.0, a plataforma CrewAI AMP iniciou um processo de
> migração de seu provedor de login. Como resultado, o fluxo de autenticação via
> CLI foi atualizado. Usuários que utlizam o Google para fazer login, ou que
> criaram conta após 3 de julho de 2025 não poderão fazer login com versões
> anteriores da biblioteca `crewai`.

## Visão Geral

O CLI do CrewAI fornece um conjunto de comandos para interagir com o CrewAI, permitindo que você crie, treine, execute e gerencie crews & flows.

## Instalação

Para usar o CLI do CrewAI, certifique-se de que o CrewAI está instalado:

```shell Terminal theme={null}
pip install crewai
```

## Uso Básico

A estrutura básica de um comando CLI do CrewAI é:

```shell Terminal theme={null}
crewai [COMMAND] [OPTIONS] [ARGUMENTS]
```

## Comandos Disponíveis

### 1. Create

Crie um novo projeto crew, flow, Agent independente (experimental), tool, skill ou template.

```shell Terminal theme={null}
crewai create [OPTIONS] TYPE NAME
```

* `TYPE`: `crew`, `flow`, `agent` (experimental), `tool`, `skill` ou `template`
* `NAME`: Nome do crew ou flow

Exemplo:

```shell Terminal theme={null}
crewai create crew my_new_crew
crewai create flow my_new_flow
```

Por padrão, `crewai create crew` cria um projeto JSON-first com `crew.jsonc` e `agents/*.jsonc`. Use `crewai create crew my_new_crew --classic` somente quando quiser o scaffold antigo em Python/YAML com `crew.py`, `config/agents.yaml` e `config/tasks.yaml`.

#### Executar agora

Quando você cria um crew ou um flow em um terminal, o `crewai create` oferece executar o novo projeto:

```text theme={null}
  Run it now? [Y/n]:
```

Pressione Enter para iniciar o `crewai run` na pasta do projeto. Em seguida, o `crewai create` sai com o código de saída da execução. A primeira execução também instala as dependências do projeto. Responda `n` para pular a execução, e o CLI imprime o comando para depois:

```text theme={null}
  Run it later: cd my_new_crew && crewai run
```

O `crewai create` não pergunta com `CREWAI_DMN=true`, nem quando stdin ou stdout não é um terminal, como quando um agente de programação ou um job de CI o executa. Criar uma ferramenta, uma skill ou um template nunca pergunta.

#### Agent (Experimental)

```shell Terminal theme={null}
crewai create agent support_agent
crewai create agent json_support --format json
crewai create agent python_support --format python
```

Projetos de Agent independente usam `agent.yaml` por padrão. Use `--format json` para configuração em JSON ou `--format python` para exportar um Agent em Python. Este contrato experimental de projeto e carregamento pode mudar e exige builds de prévia compatíveis da CLI e do SDK. Consulte [Projetos de Agent Independente](https://docs.crewai.com/edge/pt-BR/guides/agents/standalone-agent-projects.md) para configuração, ferramentas, entradas de execução e limites de implantação.

#### Aliases de flags obsoletas

As flags antigas em snake\_case ainda funcionam, mas ficam ocultas no `--help`. Prefira as formas em kebab-case documentadas em cada seção de comando abaixo.

| Obsoleto | Use em vez disso |
| :- | :- |
| `--skip_provider` (em `crewai create crew`) | `--skip-provider` |
| `--n_iterations` (em `crewai train`, `crewai test`) | `--n-iterations` |
| `--task_id` (em `crewai replay`) | `--task-id` |

### 2. Version

Mostre a versão instalada do CrewAI.

```shell Terminal theme={null}
crewai version [OPTIONS]
```

* `--tools`: (Opcional) Mostra a versão instalada das ferramentas do CrewAI

Exemplo:

```shell Terminal theme={null}
crewai version
crewai version --tools
```

### 3. Train

Treine o crew por um número específico de iterações.

```shell Terminal theme={null}
crewai train [OPTIONS]
```

* `-n, --n-iterations INTEGER`: Número de iterações para treinar o crew (padrão: 5)
* `-f, --filename TEXT`: Caminho para um arquivo customizado para treinamento (padrão: "trained\_agents\_data.pkl")

Exemplo:

```shell Terminal theme={null}
crewai train -n 10 -f my_training_data.pkl
```

```python theme={null}
# Exemplo de uso programático do comando train
n_iterations = 2
inputs = {"topic": "Treinamento CrewAI"}
filename = "seu_modelo.pkl"

try:
    SuaCrew().crew().train(
      n_iterations=n_iterations,
      inputs=inputs,
      filename=filename
    )
except Exception as e:
    raise Exception(f"Ocorreu um erro ao treinar a crew: {e}")
```

### 4. Replay

Reexecute a execução do crew a partir de uma tarefa específica.

```shell Terminal theme={null}
crewai replay [OPTIONS]
```

* `-t, --task-id TEXT`: Reexecuta o crew a partir deste task ID, incluindo todas as tarefas subsequentes

Exemplo:

```shell Terminal theme={null}
crewai replay -t task_123456
```

### 5. Log-tasks-outputs

Recupere as saídas mais recentes das tarefas crew\.kickoff() do seu crew.

```shell Terminal theme={null}
crewai log-tasks-outputs
```

### 6. Reset-memories

Redefine as memórias do crew (longa, curta, de entidades, latest\_crew\_kickoff\_outputs).

```shell Terminal theme={null}
crewai reset-memories [OPTIONS]
```

* `-l, --long`: Redefine a memória de LONGO PRAZO
* `-s, --short`: Redefine a memória de CURTO PRAZO
* `-e, --entities`: Redefine a memória de ENTIDADES
* `-k, --kickoff-outputs`: Redefine as OUTPUTS DA TAREFA KICKOFF MAIS RECENTE
* `-kn, --knowledge`: Redefine o armazenamento de CONHECIMENTO
* `-akn, --agent-knowledge`: Redefine o armazenamento de CONHECIMENTO DOS AGENTES
* `-a, --all`: Redefine TODAS as memórias

Exemplo:

```shell Terminal theme={null}
crewai reset-memories --long --short
crewai reset-memories --all
```

### 7. Test

Teste o crew e avalie os resultados.

```shell Terminal theme={null}
crewai test [OPTIONS]
```

* `-n, --n-iterations INTEGER`: Número de iterações para testar o crew (padrão: 3)
* `-m, --model TEXT`: Modelo LLM para executar os testes no Crew (padrão: "gpt-4o-mini")

Exemplo:

```shell Terminal theme={null}
crewai test -n 5 -m gpt-3.5-turbo
```

### 8. Run

Execute o crew ou flow.

```shell Terminal theme={null}
crewai run
```

> [!NOTE]
>
> A partir da versão 0.103.0, o comando `crewai run` pode ser usado para
> executar tanto crews padrão quanto flows. Para flows, ele detecta
> automaticamente o tipo a partir do pyproject.toml e executa o comando
> apropriado. Este é agora o modo recomendado de executar tanto crews quanto
> flows.

Antes de um crew ou um flow em Python começar, o `crewai run` verifica se a chave de API de que cada um dos seus modelos precisa está definida, no seu ambiente ou no `.env` que o crewAI carrega: o do próprio projeto ou, se não houver, o mais próximo em uma pasta acima. Em um crew JSON, ele lê os campos `llm`, `manager_llm` e `function_calling_llm` do `crew.jsonc` e dos arquivos de agentes que ele lista; um agente sem `llm` roda com `MODEL` ou, se não houver, com o modelo padrão do crewAI, `gpt-4.1-mini`, então esse modelo também é verificado. Para um crew ou flow em Python, ele lê `MODEL` e qualquer `llm:` em `config/agents.yaml`, e verifica `gpt-4.1-mini` quando nenhum dos dois indica um modelo. Um valor vazio ou o placeholder `YOUR_API_KEY` conta como ausente.

Em um terminal, o CLI pede cada chave ausente. O que você cola fica oculto, é salvo no `.env` do projeto e é usado pela execução que começa em seguida. Pressione Enter para pular uma chave. Sem um terminal, por exemplo sob um agente de código ou em CI, o CLI imprime a linha a adicionar e inicia a execução mesmo assim. Ele também imprime a linha, em vez de salvar, quando o `.env` está em uma pasta acima ou é um link simbólico:

```text theme={null}
OPENAI_API_KEY is not set. Add OPENAI_API_KEY=<your key> to /path/to/my_crew/.env, then run `crewai run` again.
```

A verificação cobre provedores que usam uma única chave de API, como OpenAI, Anthropic, Gemini e Groq. Ela ignora Azure, Bedrock e watsonx, modelos locais como Ollama e flows declarativos. Ela não lê um `llm` definido em código Python e, quando o código do projeto define um, também não verifica o modelo padrão. Um `.env` que não é um arquivo comum, como um named pipe servido por um gerenciador de segredos, fica para a execução ler e não é verificado. Antes de salvar uma chave, o CLI deixa o `.env` legível apenas por você; quando não consegue, ele usa a chave só nesta execução e avisa, em vez de salvá-la. Quando o `.env` do projeto envia requisições para outro host por meio de uma configuração que o seu próprio ambiente não define, como `OPENAI_BASE_URL`, `OPENAI_API_BASE` ou `HTTPS_PROXY`, ou quando os arquivos de um crew JSON definem `base_url`, `api_base` ou `endpoint` em qualquer lugar, como em um `llm`, no seu `client_params`, em um `planning_llm` ou no `config` de um embedder, o prompt mostra cada host antes de pedir a chave. Cole uma chave apenas se você confiar nesse host.

Se um crew JSON ainda falhar porque uma chave de API não está definida, por exemplo a chave de um modelo que essa verificação ignora, a execução para com a mesma linha em vez de um traceback. Em um terminal, o CLI primeiro pede essa chave como descrito acima, depois monta o crew de novo e o executa mais uma vez a partir da primeira tarefa, então as tarefas que já terminaram rodam de novo; pressione Enter para parar em vez disso.

> [!NOTE]
>
> Certifique-se de executar estes comandos a partir do diretório onde seu
> projeto CrewAI está configurado. Alguns comandos podem exigir configuração ou
> ajustes adicionais dentro da estrutura do seu projeto.

### 9. Chat

A partir da versão `0.98.0`, ao rodar o comando `crewai chat`, você inicia uma sessão interativa com seu crew. O assistente de IA irá guiá-lo solicitando as entradas necessárias para executar o crew. Uma vez que todas as entradas são fornecidas, o crew executará suas tarefas.

Depois de receber os resultados, você pode continuar interagindo com o assistente para instruções ou perguntas adicionais.

```shell Terminal theme={null}
crewai chat
```

> [!NOTE]
>
> Garanta que você execute estes comandos a partir do diretório raiz do seu projeto CrewAI.

> [!NOTE]
>
> IMPORTANTE: Defina a propriedade `chat_llm` na definição da sua crew para habilitar este comando.
>
> Para crews JSON-first, adicione em `crew.jsonc`:
>
> ```jsonc theme={null}
> {
>   "name": "My Crew",
>   "agents": ["researcher"],
>   "tasks": [],
>   "chat_llm": "openai/gpt-4o"
> }
> ```
>
> Para crews clássicas Python/YAML, defina em `crew.py`:
>
> ```python theme={null}
> @crew
> def crew(self) -> Crew:
>     return Crew(
>         agents=self.agents,
>         tasks=self.tasks,
>         process=Process.sequential,
>         verbose=True,
>         chat_llm="gpt-4o",  # LLM para orquestração de chat
>     )
> ```

### 10. Deploy

Implemente o crew ou flow no [CrewAI AMP](https://app.crewai.com).

* **Autenticação**: Você precisa estar autenticado para implementar no CrewAI AMP.
  Você pode fazer login ou criar uma conta com:

  ```shell Terminal theme={null}
  crewai login
  ```

* **Criar um deployment**: Depois de autenticado, você pode criar um deployment para seu crew ou flow a partir da raiz do seu projeto local.
  ```shell Terminal theme={null}
  crewai deploy create
  ```
  * Lê a configuração do seu projeto local.
  * Solicita a confirmação das variáveis de ambiente (como `OPENAI_API_KEY`, `SERPER_API_KEY`) encontradas localmente. Elas serão armazenadas de forma segura junto ao deployment na plataforma Enterprise. Verifique se suas chaves sensíveis estão corretamente configuradas localmente (por exemplo, em um arquivo `.env`) antes de executar este comando.
  * `--zip` envia o projeto como um ZIP mesmo quando ele tem um `origin` git, sem fazer fetch dele.
  * Quando o projeto é um repositório git com pelo menos um commit, todo envio de ZIP, na criação ou no push, mostra o commit local a partir do qual ele foi gerado e se o diretório do projeto tinha alterações não commitadas.

### 11. Gerenciamento de Organização

Gerencie suas organizações no CrewAI AMP.

```shell Terminal theme={null}
crewai org [COMMAND] [OPTIONS]
```

#### Comandos:

* `list`: Liste todas as organizações das quais você faz parte

```shell Terminal theme={null}
crewai org list
```

* `current`: Exibe sua organização ativa atualmente

```shell Terminal theme={null}
crewai org current
```

* `switch`: Mude para uma organização específica

```shell Terminal theme={null}
crewai org switch <organization_id>
```

> [!NOTE]
>
> Você deve estar autenticado no CrewAI AMP para usar estes comandos de
> gerenciamento de organização.

* **Criar um deployment** (continuação):

  * Vincula o deployment ao respectivo repositório remoto do GitHub (normalmente detectado automaticamente).

* **Implantar o Crew**: Depois de autenticado, você pode implantar seu crew ou flow no CrewAI AMP.

  ```shell Terminal theme={null}
  crewai deploy push
  ```

  * Inicia o processo de deployment na plataforma CrewAI AMP.
  * Após a iniciação bem-sucedida, será exibida a mensagem Deployment created successfully! juntamente com o Nome do Deployment e um Deployment ID (UUID) único.
  * O push mantém a origem usada na criação. Adicionar um `origin` git depois não troca um deployment ZIP por git.

* **Status do Deployment**: Você pode verificar o status do seu deployment com:

  ```shell Terminal theme={null}
  crewai deploy status
  ```

  Isso retorna o status mais recente do último deployment iniciado (por exemplo, `Building Images for Crew`, `Deploy Enqueued`, `Online`). Se o deployment falhou, também mostra o erro e uma sugestão de correção.

* **Logs do Deployment**: Você pode checar os logs do seu deployment com:

  ```shell Terminal theme={null}
  crewai deploy logs
  ```

  Isso faz o streaming dos logs do deployment para seu terminal.

* **Listar deployments**: Você pode listar todos os seus deployments com:

  ```shell Terminal theme={null}
  crewai deploy list
  ```

  Isto lista todos os seus deployments.

* **Deletar um deployment**: Você pode deletar um deployment com:

  ```shell Terminal theme={null}
  crewai deploy remove
  ```

  Isto exclui o deployment da plataforma CrewAI AMP.

* **Comando de Ajuda**: Você pode obter ajuda sobre o CLI com:
  ```shell Terminal theme={null}
  crewai deploy --help
  ```
  Isto exibe a mensagem de ajuda para o CLI CrewAI Deploy.

Assista ao vídeo tutorial para uma demonstração passo-a-passo de implantação do seu crew no [CrewAI AMP](https://app.crewai.com) usando o CLI.

[CrewAI Deployment Guide](https://www.youtube.com/embed/3EqSV-CYDZA)

### 11. Chaves de API

Ao executar o comando `crewai create crew`, o CLI mostrará provedores de LLM disponíveis e depois a seleção de modelo para o provedor escolhido. O modelo selecionado é salvo no `.env` gerado, e cada agente JSONC pode definir seu próprio `llm`.

O `crewai create flow` faz as mesmas perguntas em um terminal e salva o modelo como `MODEL` no `.env` do flow, que os agentes da crew inicial usam. Com `--provider`, ele pula as perguntas de provedor e modelo. Passe um provedor da lista, como `anthropic` ou `bedrock`, para usar o primeiro modelo listado dele, ou uma string `provider/model` completa para qualquer outro modelo. Um flow declarativo (`--declarative`) não pergunta nada nem indica nenhuma chave nos próximos passos, porque o seu ponto de partida não chama nenhum modelo.

Após selecionar um provedor de LLM, será solicitado que você informe as chaves de API. Em um terminal, o que você digita para uma chave ou um segredo fica oculto; outros valores, como uma URL de endpoint, uma região ou o nome de um deployment do Azure, continuam visíveis. Pressione Enter para pular um campo.

Uma chave pulada não é salva. A menos que a chave já esteja definida no seu ambiente, o CLI mostra a linha exata a adicionar ao `.env` antes de `crewai run`:

```text theme={null}
  API key not saved. Add this line to my_new_crew/.env before `crewai run`:
    OPENAI_API_KEY=<your key>
```

Valores que têm um padrão, como a região da AWS e a versão da API do Azure, não são listados.

Se seus agentes usam modelos de mais de um provedor, o CLI pede as chaves uma vez por provedor, e o modelo do primeiro agente é salvo como `MODEL`.

O `pyproject.toml` gerado também depende dos extras do crewai que os modelos escolhidos precisam, por exemplo `crewai[tools,anthropic]` para Anthropic, `crewai[tools,google-genai]` para Gemini, ou `crewai[tools,litellm]` para provedores que o crewAI acessa via LiteLLM, como o Groq. O crewAI também executa alguns nomes de modelo via LiteLLM em vez do SDK do provedor, como `bedrock/claude-sonnet-4-5-20250929-v1:0`, então esses adicionam `litellm` também. O `crewai install`, ou o primeiro `crewai run`, os instala. Um projeto que usa apenas OpenAI depende só de `crewai[tools]`. Se depois você trocar um agente para outro modelo, adicione você mesmo o extra que ele precisa, por exemplo `uv add "crewai[anthropic]"`.

Com `--skip-provider`, ou com `CREWAI_DMN=true`, o CLI não pede nem salva nenhuma chave. O `crewai create flow` também não pergunta nada quando não está rodando em um terminal, como quando um agente de código ou um job de CI o executa. Na crew JSON padrão, os agentes usam `openai/gpt-6-luna`, a menos que você passe `--provider`. Um flow salva o modelo do `--provider` como `MODEL` e, sem ele, roda no modelo OpenAI padrão do crewAI. Os próximos passos indicam cada variável que ainda não está definida no seu ambiente:

```text theme={null}
  Set OPENAI_API_KEY in .env before `crewai run`
```

#### Provedores iniciais de chave de API

Inicialmente, o CLI solicitará as chaves de API para os seguintes serviços:

* OpenAI
* Groq
* Anthropic
* Google Gemini
* SambaNova

Ao selecionar um provedor, o CLI solicitará que você insira sua chave de API.

#### Outras opções

Se você selecionar a opção 6, será possível escolher de uma lista de provedores suportados pelo LiteLLM.

Ao escolher um provedor, o CLI solicitará que você informe o nome da chave e a chave de API.

Veja o seguinte link para o nome de chave de cada provedor:

* [LiteLLM Providers](https://docs.litellm.ai/docs/providers)

### 12. Gerenciamento de Configuração

Gerencie as configurações do CLI para CrewAI.

```shell Terminal theme={null}
crewai config [COMANDO] [OPÇÕES]
```

#### Comandos:

* `list`: Exibir todos os parâmetros de configuração do CLI

```shell Terminal theme={null}
crewai config list
```

* `set`: Definir um parâmetro de configuração do CLI

```shell Terminal theme={null}
crewai config set <chave> <valor>
```

* `reset`: Redefinir todos os parâmetros de configuração do CLI para valores padrão

```shell Terminal theme={null}
crewai config reset
```

#### Parâmetros de Configuração Disponíveis

* `enterprise_base_url`: URL base da instância CrewAI AMP
* `oauth2_provider`: Provedor OAuth2 usado para autenticação (ex: workos, okta, auth0)
* `oauth2_audience`: Valor de audiência OAuth2, tipicamente usado para identificar a API ou recurso de destino
* `oauth2_client_id`: ID do cliente OAuth2 emitido pelo provedor, usado durante solicitações de autenticação
* `oauth2_domain`: Domínio do provedor OAuth2 (ex: sua-org.auth0.com) usado para emissão de tokens

#### Exemplos

Exibir configuração atual:

```shell Terminal theme={null}
crewai config list
```

Exemplo de saída:

| Parâmetro | Valor | Descrição |
| :- | :- | :- |
| enterprise\_base\_url | [https://app.crewai.com](https://app.crewai.com) | URL base da instância CrewAI AMP |
| org\_name | Not set | Nome da organização atualmente ativa |
| org\_uuid | Not set | UUID da organização atualmente ativa |
| oauth2\_provider | workos | Provedor OAuth2 (ex.: workos, okta, auth0) |
| oauth2\_audience | client\_01YYY | Audience usada para identificar a API/recurso de destino |
| oauth2\_client\_id | client\_01XXX | Client ID OAuth2 emitido pelo provedor (usado na autenticação) |
| oauth2\_domain | login.crewai.com | Domínio do provedor OAuth2 (ex.: your-org.auth0.com) |

Definir a URL base do enterprise:

```shell Terminal theme={null}
crewai config set enterprise_base_url https://minha-empresa.crewai.com
```

Definir provedor OAuth2:

```shell Terminal theme={null}
crewai config set oauth2_provider auth0
```

Definir domínio OAuth2:

```shell Terminal theme={null}
crewai config set oauth2_domain minha-empresa.auth0.com
```

Redefinir todas as configurações para padrões:

```shell Terminal theme={null}
crewai config reset
```

> [!NOTE]
>
> As configurações são armazenadas em `~/.config/crewai/settings.json`. Algumas
> configurações como nome da organização e UUID são somente leitura e
> gerenciadas através de comandos de autenticação e organização. Configurações
> relacionadas ao repositório de ferramentas são ocultas e não podem ser
> definidas diretamente pelo usuário.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.