---
title: 'LLMs'
description: 'Um guia abrangente para configurar e usar Modelos de Linguagem de Grande Escala (LLMs) em seus projetos CrewAI'
icon: 'microchip-ai'
mode: "wide"
---

## Visão Geral

O CrewAI integra-se com múltiplos provedores de LLM através do LiteLLM, oferecendo flexibilidade para você escolher o modelo certo para o seu caso de uso específico. Este guia irá ajudá-lo a entender como configurar e usar diferentes provedores de LLM em seus projetos CrewAI.

## O que são LLMs?

Modelos de Linguagem de Grande Escala (LLMs) são a inteligência central por trás dos agentes CrewAI. Eles permitem que os agentes compreendam o contexto, tomem decisões e gerem respostas semelhantes às humanas. Veja o que você precisa saber:

<CardGroup cols={2}>
  <Card title="Noções Básicas de LLM" icon="brain">
    Modelos de Linguagem de Grande Escala são sistemas de IA treinados em grandes volumes de dados textuais. Eles potencializam a inteligência dos agentes CrewAI, permitindo compreender e gerar textos de voz humana.
  </Card>
  <Card title="Janela de Contexto" icon="window">
    A janela de contexto determina quanto texto um LLM pode processar de uma só vez. Janelas maiores (por exemplo, 128K tokens) permitem mais contexto, porém podem ser mais caras e lentas.
  </Card>
  <Card title="Temperatura" icon="temperature-three-quarters">
    A temperatura (0.0 a 1.0) controla a aleatoriedade das respostas. Valores mais baixos (ex.: 0.2) produzem respostas mais focadas e determinísticas, enquanto valores mais altos (ex.: 0.8) aumentam criatividade e variabilidade.
  </Card>
  <Card title="Seleção de Provedor" icon="server">
    Cada provedor de LLM (ex.: OpenAI, Anthropic, Google) oferece modelos diferentes, com capacidades, preços e recursos variados. Escolha conforme suas necessidades de precisão, velocidade e custo.
  </Card>
</CardGroup>

## Configurando seu LLM

Existem diferentes locais no código do CrewAI onde você pode especificar o modelo a ser utilizado. Após definir o modelo usado, será necessário fornecer a configuração (como uma chave de API) para cada provedor de modelo. Veja a seção de [exemplos de configuração de provedores](#provider-configuration-examples) para seu provedor.

<Tabs>
  <Tab title="1. Variáveis de Ambiente">
    A maneira mais simples de começar. Defina o modelo diretamente em seu ambiente, usando um arquivo `.env` ou no código do seu aplicativo. Se você utilizou `crewai create` para iniciar seu projeto, já estará configurado.

    ```bash .env
    MODEL=model-id  # e.g. gpt-4o, gemini-2.0-flash, claude-3-sonnet-...

    # Lembre-se de definir suas chaves de API aqui também. Veja a seção
    # do Provedor abaixo.
    ```

    <Warning>
      Nunca envie chaves de API para controle de versão. Use arquivos de ambiente (.env) ou o gerenciamento de segredos do seu sistema.
    </Warning>
  </Tab>
  <Tab title="2. Configuração YAML">
    Crie um arquivo YAML para definir as configurações dos seus agentes. Este método é ótimo para controle de versão e colaboração em equipe:

    ```yaml agents.yaml {6}
    researcher:
        role: Research Specialist
        goal: Conduct comprehensive research and analysis
        backstory: A dedicated research professional with years of experience
        verbose: true
        llm: provider/model-id  # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
        # (veja exemplos de configuração de provedores abaixo para mais)
    ```

    <Info>
      A configuração YAML permite:
      - Controlar versões das configurações dos agentes
      - Trocar facilmente entre diferentes modelos
      - Compartilhar configurações entre membros da equipe
      - Documentar escolhas de modelos e seus propósitos
    </Info>
  </Tab>
  <Tab title="3. Código Direto">
    Para máxima flexibilidade, configure os LLMs diretamente no seu código Python:

    ```python {4,8}
    from crewai import LLM

    # Configuração básica
    llm = LLM(model="model-id-here")  # gpt-4o, gemini-2.0-flash, anthropic/claude...

    # Configuração avançada com parâmetros detalhados
    llm = LLM(
        model="openai/gpt-4",
        temperature=0.8,
        max_tokens=150,
        top_p=0.9,
        frequency_penalty=0.1,
        presence_penalty=0.1,
        response_format={"type":"json"},
        stop=["FIM"],
        seed=42
    )
    ```

    <Info>
      Explicações dos parâmetros:
      - `temperature`: Controla a aleatoriedade (0.0-1.0)
      - `timeout`: Tempo máximo de espera pela resposta
      - `max_tokens`: Limita o comprimento da resposta
      - `top_p`: Alternativa à temperatura para amostragem
      - `frequency_penalty`: Reduz repetição de palavras
      - `presence_penalty`: Incentiva novos tópicos
      - `response_format`: Especifica formato de saída
      - `seed`: Garante resultados consistentes
    </Info>
  </Tab>
</Tabs>

<Info>
  O CrewAI oferece integrações nativas via SDK para OpenAI, Anthropic, Google (Gemini API), Azure e AWS Bedrock — sem necessidade de instalação extra além dos extras específicos do provedor (ex.: `uv add "crewai[openai]"`).

  Todos os outros provedores são alimentados pelo **LiteLLM**. Se você planeja usar algum deles, adicione-o como dependência ao seu projeto:
  ```bash
  uv add 'crewai[litellm]'
  ```
</Info>

## Exemplos de Configuração de Provedores

O CrewAI suporta uma grande variedade de provedores de LLM, cada um com recursos, métodos de autenticação e capacidades de modelo únicos.
Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, configurar e otimizar o LLM que melhor atende às necessidades do seu projeto.

<AccordionGroup>
  <Accordion title="OpenAI">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:

    ```toml Code
    # Obrigatório
    OPENAI_API_KEY=sk-...

    # Opcional
    OPENAI_API_BASE=<custom-base-url>
    OPENAI_ORGANIZATION=<your-org-id>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    from crewai import LLM

    llm = LLM(
        model="openai/gpt-4",
        temperature=0.8,
        max_tokens=150,
        top_p=0.9,
        frequency_penalty=0.1,
        presence_penalty=0.1,
        stop=["FIM"],
        seed=42
    )
    ```

    OpenAI é um dos líderes em modelos LLM com uma ampla gama de modelos e recursos.

    | Modelo               | Janela de Contexto   | Melhor Para                              |
    |----------------------|---------------------|------------------------------------------|
    | GPT-4                | 8.192 tokens        | Tarefas de alta precisão, raciocínio complexo |
    | GPT-4 Turbo          | 128.000 tokens      | Conteúdo longo, análise de documentos    |
    | GPT-4o & GPT-4o-mini | 128.000 tokens      | Processamento de contexto amplo com bom custo-benefício |
    | o3-mini              | 200.000 tokens      | Raciocínio rápido, tarefas complexas     |
    | o1-mini              | 128.000 tokens      | Raciocínio rápido, tarefas complexas     |
    | o1-preview           | 128.000 tokens      | Raciocínio rápido, tarefas complexas     |
    | o1                   | 200.000 tokens      | Raciocínio rápido, tarefas complexas     |

    **Responses API:**

    A OpenAI oferece duas APIs: Chat Completions (padrão) e a nova Responses API. A Responses API foi projetada desde o início com suporte multimodal nativo—texto, imagens, áudio e chamadas de função são todos cidadãos de primeira classe. Ela oferece melhor performance com modelos de raciocínio e suporta recursos adicionais como auto-encadeamento e ferramentas integradas.

    ```python Code
    from crewai import LLM

    # Usar Responses API em vez de Chat Completions
    llm = LLM(
        model="openai/gpt-4o",
        api="responses",  # Habilitar Responses API
        store=True,  # Armazenar respostas para multi-turno (opcional)
        auto_chain=True,  # Auto-encadeamento para modelos de raciocínio (opcional)
    )
    ```

    **Parâmetros da Responses API:**
    - `api`: Defina como `"responses"` para usar a Responses API (padrão: `"completions"`)
    - `instructions`: Instruções de nível de sistema (apenas Responses API)
    - `store`: Se deve armazenar respostas para conversas multi-turno
    - `previous_response_id`: ID da resposta anterior para multi-turno
    - `include`: Dados adicionais para incluir na resposta (ex: `["reasoning.encrypted_content"]`)
    - `builtin_tools`: Lista de ferramentas integradas da OpenAI: `"web_search"`, `"file_search"`, `"code_interpreter"`, `"computer_use"`
    - `parse_tool_outputs`: Retornar `ResponsesAPIResult` estruturado com saídas de ferramentas integradas parseadas
    - `auto_chain`: Rastrear e usar automaticamente IDs de resposta para conversas multi-turno
    - `auto_chain_reasoning`: Rastrear itens de raciocínio criptografados para conformidade ZDR (Zero Data Retention)

    <Tip>
      Use a Responses API para novos projetos, especialmente ao trabalhar com modelos de raciocínio (o1, o3, o4) ou quando precisar de suporte multimodal nativo para [arquivos](/pt-BR/concepts/files).
    </Tip>
  </Accordion>

  <Accordion title="Meta-Llama">
    A API Llama da Meta fornece acesso à família de modelos de linguagem de grande escala da Meta.
    A API está disponível através da [Meta Llama API](https://llama.developer.meta.com?utm_source=partner-crewai&utm_medium=website).
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:

    ```toml Code
    # Configuração chave da API Meta Llama
    LLAMA_API_KEY=LLM|your_api_key_here
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    from crewai import LLM

    # Inicializar Meta Llama LLM
    llm = LLM(
        model="meta_llama/Llama-4-Scout-17B-16E-Instruct-FP8",
        temperature=0.8,
        stop=["FIM"],
        seed=42
    )
    ```

    Todos os modelos listados em https://llama.developer.meta.com/docs/models/ são suportados.

    | ID do Modelo | Comprimento contexto entrada | Comprimento contexto saída | Modalidades de entrada | Modalidades de saída |
    | --- | --- | --- | --- | --- |
    | `meta_llama/Llama-4-Scout-17B-16E-Instruct-FP8` | 128k | 4028 | Texto, Imagem | Texto |
    | `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | Texto, Imagem | Texto |
    | `meta_llama/Llama-3.3-70B-Instruct` | 128k | 4028 | Texto | Texto |
    | `meta_llama/Llama-3.3-8B-Instruct` | 128k | 4028 | Texto | Texto |

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Anthropic">
    ```toml Code
    # Obrigatório
    ANTHROPIC_API_KEY=sk-ant-...

    # Opcional
    ANTHROPIC_API_BASE=<custom-base-url>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="anthropic/claude-3-sonnet-20240229-v1:0",
        temperature=0.7
    )
    ```
  </Accordion>

  <Accordion title="Google (Gemini API)">
    Defina sua chave de API no seu arquivo `.env`. Se precisar de uma chave, ou encontrar uma existente, verifique o [AI Studio](https://aistudio.google.com/apikey).

    ```toml .env
    # Para API Gemini (uma das seguintes)
    GOOGLE_API_KEY=<your-api-key>
    GEMINI_API_KEY=<your-api-key>

    # Para Vertex AI Express mode (autenticação por chave de API)
    GOOGLE_GENAI_USE_VERTEXAI=true
    GOOGLE_API_KEY=<your-api-key>

    # Para Vertex AI com conta de serviço
    GOOGLE_CLOUD_PROJECT=<your-project-id>
    GOOGLE_CLOUD_LOCATION=<location>  # Padrão: us-central1
    ```

    **Uso Básico:**
    ```python Code
    from crewai import LLM

    llm = LLM(
        model="gemini/gemini-2.0-flash",
        temperature=0.7,
    )
    ```

    **Vertex AI Express Mode (Autenticação por Chave de API):**

    O Vertex AI Express mode permite usar o Vertex AI com autenticação simples por chave de API, em vez de credenciais de conta de serviço. Esta é a maneira mais rápida de começar com o Vertex AI.

    Para habilitar o Express mode, defina ambas as variáveis de ambiente no seu arquivo `.env`:
    ```toml .env
    GOOGLE_GENAI_USE_VERTEXAI=true
    GOOGLE_API_KEY=<your-api-key>
    ```

    Em seguida, use o LLM normalmente:
    ```python Code
    from crewai import LLM

    llm = LLM(
        model="gemini/gemini-2.0-flash",
        temperature=0.7
    )
    ```

    <Info>
      Para obter uma chave de API do Express mode:
      - Novos usuários do Google Cloud: Obtenha uma [chave de API do Express mode](https://cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey)
      - Usuários existentes do Google Cloud: Obtenha uma [chave de API do Google Cloud vinculada a uma conta de serviço](https://cloud.google.com/docs/authentication/api-keys)

      Para mais detalhes, consulte a [documentação do Vertex AI Express mode](https://docs.cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey).
    </Info>

    ### Modelos Gemini

    O Google oferece uma variedade de modelos poderosos otimizados para diferentes casos de uso.

    | Modelo                          | Janela de Contexto | Melhor Para                                                         |
    |----------------------------------|--------------------|---------------------------------------------------------------------|
    | gemini-2.5-flash-preview-04-17   | 1M tokens          | Pensamento adaptativo, eficiência de custo                          |
    | gemini-2.5-pro-preview-05-06     | 1M tokens          | Pensamento e raciocínio avançados, compreensão multimodal, codificação avançada, etc. |
    | gemini-2.0-flash                 | 1M tokens          | Próxima geração de recursos, velocidade, raciocínio e streaming em tempo real |
    | gemini-2.0-flash-lite            | 1M tokens          | Eficiência de custo e baixa latência                                 |
    | gemini-1.5-flash                 | 1M tokens          | Modelo multimodal equilibrado, bom para maioria das tarefas          |
    | gemini-1.5-flash-8B              | 1M tokens          | Mais rápido, mais eficiente em custo, adequado para tarefas de alta frequência |
    | gemini-1.5-pro                   | 2M tokens          | Melhor desempenho para uma ampla variedade de tarefas de raciocínio, incluindo lógica, codificação e colaboração criativa |

    A lista completa de modelos está disponível na [documentação dos modelos Gemini](https://ai.google.dev/gemini-api/docs/models).

    ### Gemma

    A API Gemini também permite uso de sua chave de API para acessar [modelos Gemma](https://ai.google.dev/gemma/docs) hospedados na infraestrutura Google.

    | Modelo          | Janela de Contexto |
    |----------------|-------------------|
    | gemma-3-1b-it  | 32k tokens        |
    | gemma-3-4b-it  | 32k tokens        |
    | gemma-3-12b-it | 32k tokens        |
    | gemma-3-27b-it | 128k tokens       |

  </Accordion>
  <Accordion title="Google (Vertex AI)">
    Obtenha as credenciais pelo Google Cloud Console, salve em um arquivo JSON e carregue com o código a seguir:
    ```python Code
    import json

    file_path = 'path/to/vertex_ai_service_account.json'

    # Carregar o arquivo JSON
    with open(file_path, 'r') as file:
        vertex_credentials = json.load(file)

    # Converter credenciais em string JSON
    vertex_credentials_json = json.dumps(vertex_credentials)
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    from crewai import LLM

    llm = LLM(
        model="gemini-1.5-pro-latest", # or vertex_ai/gemini-1.5-pro-latest
        temperature=0.7,
        vertex_credentials=vertex_credentials_json
    )
    ```

    O Google oferece uma variedade de modelos poderosos otimizados para diferentes casos de uso:

    | Modelo                          | Janela de Contexto | Melhor Para                                                         |
    |----------------------------------|--------------------|---------------------------------------------------------------------|
    | gemini-2.5-flash-preview-04-17   | 1M tokens          | Pensamento adaptativo, eficiência de custo                          |
    | gemini-2.5-pro-preview-05-06     | 1M tokens          | Pensamento e raciocínio avançados, compreensão multimodal, codificação avançada, etc. |
    | gemini-2.0-flash                 | 1M tokens          | Próxima geração de recursos, velocidade, raciocínio e streaming em tempo real |
    | gemini-2.0-flash-lite            | 1M tokens          | Eficiência de custo e baixa latência                                |
    | gemini-1.5-flash                 | 1M tokens          | Modelo multimodal equilibrado, bom para maioria das tarefas         |
    | gemini-1.5-flash-8B              | 1M tokens          | Mais rápido, mais eficiente em custo, adequado para tarefas de alta frequência |
    | gemini-1.5-pro                   | 2M tokens          | Melhor desempenho para uma ampla variedade de tarefas de raciocínio, incluindo lógica, codificação e colaboração criativa |

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Azure">
    ```toml Code
    # Obrigatório
    AZURE_API_KEY=<your-api-key>
    AZURE_API_BASE=<your-resource-url>
    AZURE_API_VERSION=<api-version>

    # Opcional
    AZURE_AD_TOKEN=<your-azure-ad-token>
    AZURE_API_TYPE=<your-azure-api-type>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="azure/gpt-4",
        api_version="2023-05-15"
    )
    ```
  </Accordion>

  <Accordion title="AWS Bedrock">
    ```toml Code
    AWS_ACCESS_KEY_ID=<your-access-key>
    AWS_SECRET_ACCESS_KEY=<your-secret-key>
    AWS_DEFAULT_REGION=<your-region>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0"
    )
    ```

    Antes de usar o Amazon Bedrock, certifique-se de ter o boto3 instalado em seu ambiente

    [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) é um serviço gerenciado que fornece acesso a múltiplos modelos fundamentais dos principais provedores de IA através de uma API unificada, permitindo o desenvolvimento seguro e responsável de aplicações de IA.

    | Modelo                   | Janela de Contexto      | Melhor Para                                                         |
    |--------------------------|------------------------|---------------------------------------------------------------------|
    | Amazon Nova Pro          | Até 300k tokens        | Alto desempenho, equilíbrio entre precisão, velocidade e custo em tarefas diversas. |
    | Amazon Nova Micro        | Até 128k tokens        | Modelo texto-only de alta performance, custo-benefício, otimizado para baixa latência. |
    | Amazon Nova Lite         | Até 300k tokens        | Alto desempenho, processamento multimodal acessível para texto, imagem, vídeo em tempo real. |
    | Claude 3.7 Sonnet        | Até 128k tokens        | Alto desempenho para raciocínio complexo, programação & agentes de IA|
    | Claude 3.5 Sonnet v2     | Até 200k tokens        | Modelo avançado especializado em engenharia de software, capacidades agenticas e interação computacional com custo otimizado. |
    | Claude 3.5 Sonnet        | Até 200k tokens        | Alto desempenho com inteligência e raciocínio excepcionais, equilíbrio entre velocidade-custo. |
    | Claude 3.5 Haiku         | Até 200k tokens        | Modelo multimodal rápido e compacto, otimizado para respostas rápidas e interações humanas naturais |
    | Claude 3 Sonnet          | Até 200k tokens        | Modelo multimodal equilibrando inteligência e velocidade para grandes volumes de uso. |
    | Claude 3 Haiku           | Até 200k tokens        | Compacto, multimodal, otimizado para respostas rápidas e diálogo natural |
    | Claude 3 Opus            | Até 200k tokens        | Modelo multimodal mais avançado para tarefas complexas com raciocínio humano e entendimento contextual superior. |
    | Claude 2.1               | Até 200k tokens        | Versão aprimorada com janela de contexto aumentada, maior confiabilidade, menos alucinações para aplicações longas e RAG |
    | Claude                   | Até 100k tokens        | Modelo versátil para diálogos sofisticados, conteúdo criativo e instruções precisas. |
    | Claude Instant           | Até 100k tokens        | Modelo rápido e de baixo custo para tarefas diárias, como diálogos, análise, sumarização e Q&A em documentos |
    | Llama 3.1 405B Instruct  | Até 128k tokens        | LLM avançado para geração de dados sintéticos, distilação e inferência para chatbots, programação, tarefas de domínio específico. |
    | Llama 3.1 70B Instruct   | Até 128k tokens        | Potencializa conversas complexas com entendimento contextual superior, raciocínio e geração de texto. |
    | Llama 3.1 8B Instruct    | Até 128k tokens        | Modelo de última geração, entendimento de linguagem, raciocínio e geração de texto. |
    | Llama 3 70B Instruct     | Até 8k tokens          | Potencializa conversas complexas com entendimento contextual superior, raciocínio e geração de texto. |
    | Llama 3 8B Instruct      | Até 8k tokens          | LLM de última geração com excelente desempenho em linguagem e geração de texto. |
    | Titan Text G1 - Lite     | Até 4k tokens          | Modelo leve e econômico para tarefas em inglês e ajuste fino, focado em sumarização e geração de conteúdo. |
    | Titan Text G1 - Express  | Até 8k tokens          | Modelo versátil para tarefas gerais de linguagem, chat e aplicações RAG com suporte a inglês e 100+ línguas. |
    | Cohere Command           | Até 4k tokens          | Modelo especializado em seguir comandos do usuário e entregar soluções empresariais práticas. |
    | Jurassic-2 Mid           | Até 8.191 tokens       | Modelo econômico equilibrando qualidade e custo para tarefas como Q&A, sumarização e geração de conteúdo. |
    | Jurassic-2 Ultra         | Até 8.191 tokens       | Geração avançada de texto e compreensão, excelente em análise e criação de conteúdo complexo. |
    | Jamba-Instruct           | Até 256k tokens        | Modelo com janela de contexto extendida para geração de texto, sumarização e Q&A de baixo custo. |
    | Mistral 7B Instruct      | Até 32k tokens         | LLM atende instruções, solicitações e gera texto criativo. |
    | Mistral 8x7B Instruct    | Até 32k tokens         | MOE LLM que atende instruções, solicitações e gera texto criativo. |
  </Accordion>

  <Accordion title="Amazon SageMaker">
    ```toml Code
    AWS_ACCESS_KEY_ID=<your-access-key>
    AWS_SECRET_ACCESS_KEY=<your-secret-key>
    AWS_DEFAULT_REGION=<your-region>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="sagemaker/<my-endpoint>"
    )
    ```

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Mistral">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:
    ```toml Code
    MISTRAL_API_KEY=<your-api-key>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="mistral/mistral-large-latest",
        temperature=0.7
    )
    ```

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Nvidia NIM">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:
    ```toml Code
    NVIDIA_API_KEY=<your-api-key>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="nvidia_nim/meta/llama3-70b-instruct",
        temperature=0.7
    )
    ```

    O Nvidia NIM oferece uma suíte abrangente de modelos para diversos usos, desde tarefas gerais até aplicações especializadas.

    | Modelo                                                                   | Janela de Contexto | Melhor Para                                                         |
    |--------------------------------------------------------------------------|--------------------|---------------------------------------------------------------------|
    | nvidia/mistral-nemo-minitron-8b-8k-instruct                              | 8.192 tokens       | Modelo pequeno de linguagem topo de linha para chatbots, assistentes virtuais e geração de conteúdo. |
    | nvidia/nemotron-4-mini-hindi-4b-instruct                                 | 4.096 tokens       | SLM bilíngue Hindi-Inglês para inferência no dispositivo, específico para língua hindi. |
    | nvidia/llama-3.1-nemotron-70b-instruct                                   | 128k tokens        | Personalizado para respostas mais úteis                             |
    | nvidia/llama3-chatqa-1.5-8b                                              | 128k tokens        | LLM avançado para respostas contextuais de alta qualidade em chatbots e mecanismos de busca. |
    | nvidia/llama3-chatqa-1.5-70b                                             | 128k tokens        | LLM avançado para respostas contextuais de alta qualidade para chatbots e mecanismos de busca. |
    | nvidia/vila                                                              | 128k tokens        | Modelo multmodal visão-linguagem para compreensão de texto/img/vídeo com respostas informativas |
    | nvidia/neva-22                                                           | 4.096 tokens       | Modelo de visão-linguagem multimodal para compreensão textos/imagens e respostas informativas |
    | nvidia/nemotron-mini-4b-instruct                                         | 8.192 tokens       | Tarefas gerais                                                     |
    | nvidia/usdcode-llama3-70b-instruct                                       | 128k tokens        | LLM de ponta para queries OpenUSD e geração de código USD-Python.   |
    | nvidia/nemotron-4-340b-instruct                                          | 4.096 tokens       | Gera dados sintéticos diversos simulando características reais.     |
    | meta/codellama-70b                                                       | 100k tokens        | LLM capaz de gerar código a partir de linguagem natural e vice-versa.|
    | meta/llama2-70b                                                          | 4.096 tokens       | Modelo de IA avançado para geração de textos e códigos.             |
    | meta/llama3-8b-instruct                                                  | 8.192 tokens       | LLM de última geração, entendimento de linguagem, raciocínio e geração de texto. |
    | meta/llama3-70b-instruct                                                 | 8.192 tokens       | Potencializa conversas complexas com entendimento contextual superior, raciocínio e geração de texto.|
    | meta/llama-3.1-8b-instruct                                               | 128k tokens        | Modelo compacto de última geração, com compreensão, raciocínio e geração de texto superior. |
    | meta/llama-3.1-70b-instruct                                              | 128k tokens        | Potencializa conversas complexas com entendimento contextual superior, raciocínio e geração de texto. |
    | meta/llama-3.1-405b-instruct                                             | 128k tokens        | LLM avançado para geração sintética de dados, destilação e inferência para chatbots, código, tarefas de domínio específico. |
    | meta/llama-3.2-1b-instruct                                               | 128k tokens        | Pequeno modelo de linguagem de última geração, entendimento, raciocínio e geração textual.|
    | meta/llama-3.2-3b-instruct                                               | 128k tokens        | Pequeno modelo de linguagem de última geração, entendimento, raciocínio e geração textual.|
    | meta/llama-3.2-11b-vision-instruct                                       | 128k tokens        | Pequeno modelo de linguagem de última geração, entendimento, raciocínio e geração textual multimodal.|
    | meta/llama-3.2-90b-vision-instruct                                       | 128k tokens        | Pequeno modelo de linguagem de última geração, entendimento, raciocínio e geração textual multimodal.|
    | google/gemma-7b                                                          | 8.192 tokens       | Modelo avançado de geração de texto, compreensão, transformação e programação.|
    | google/gemma-2b                                                          | 8.192 tokens       | Modelo avançado de geração de texto, compreensão, transformação e programação.|
    | google/codegemma-7b                                                      | 8.192 tokens       | Modelo avançado baseado no Gemma-7B do Google, especializado em geração de códigos e autocomplete.|
    | google/codegemma-1.1-7b                                                  | 8.192 tokens       | Modelo avançado para geração, complemento, raciocínio e instrução em código.|
    | google/recurrentgemma-2b                                                 | 8.192 tokens       | Modelo baseado em arquitetura recorrente para inferência mais rápida em sequências longas.|
    | google/gemma-2-9b-it                                                     | 8.192 tokens       | Modelo avançado de geração de texto, compreensão, transformação e programação.|
    | google/gemma-2-27b-it                                                    | 8.192 tokens       | Modelo avançado de geração de texto, compreensão, transformação e programação.|
    | google/gemma-2-2b-it                                                     | 8.192 tokens       | Modelo avançado de geração de texto, compreensão, transformação e programação.|
    | google/deplot                                                            | 512 tokens         | Modelo visual por linguagem para entender gráficos e converter em tabelas.|
    | google/paligemma                                                         | 8.192 tokens       | Modelo visão-linguagem experto em compreender texto e visual, gerando respostas informativas.|
    | mistralai/mistral-7b-instruct-v0.2                                       | 32k tokens         | LLM que segue instruções, completa pedidos e gera texto criativo.   |
    | mistralai/mixtral-8x7b-instruct-v0.1                                     | 8.192 tokens       | MOE LLM para seguir instruções e gerar versões criativas de texto.  |
    | mistralai/mistral-large                                                  | 4.096 tokens       | Geração de dados sintéticos.                                        |
    | mistralai/mixtral-8x22b-instruct-v0.1                                    | 8.192 tokens       | Geração de dados sintéticos.                                        |
    | mistralai/mistral-7b-instruct-v0.3                                       | 32k tokens         | LLM que segue instruções, completa pedidos e gera texto criativo.   |
    | nv-mistralai/mistral-nemo-12b-instruct                                   | 128k tokens        | Modelo de linguagem avançado para raciocínio, código, tarefas multilíngues; roda em uma única GPU.|
    | mistralai/mamba-codestral-7b-v0.1                                        | 256k tokens        | Modelo para escrita e interação com código em múltiplas linguagens e tarefas.|
    | microsoft/phi-3-mini-128k-instruct                                       | 128K tokens        | LLM leve, de última geração, com habilidades de lógica e matemática.|
    | microsoft/phi-3-mini-4k-instruct                                         | 4.096 tokens       | LLM leve, de última geração, com habilidades de lógica e matemática.|
    | microsoft/phi-3-small-8k-instruct                                        | 8.192 tokens       | LLM leve, de última geração, com habilidades de lógica e matemática.|
    | microsoft/phi-3-small-128k-instruct                                      | 128K tokens        | LLM leve, de última geração, com habilidades de lógica e matemática.|
    | microsoft/phi-3-medium-4k-instruct                                       | 4.096 tokens       | LLM leve, de última geração, com habilidades de lógica e matemática.|
    | microsoft/phi-3-medium-128k-instruct                                     | 128K tokens        | LLM leve, de última geração, com habilidades de lógica e matemática.|
    | microsoft/phi-3.5-mini-instruct                                          | 128K tokens        | LLM multilíngue leve para aplicações de IA restritas em memória e tempo.|
    | microsoft/phi-3.5-moe-instruct                                           | 128K tokens        | LLM avançada baseada em Mixture of Experts para geração eficiente de conteúdo.|
    | microsoft/kosmos-2                                                       | 1.024 tokens       | Modelo multimodal revolucionário para compreender e raciocinar elementos visuais em imagens.|
    | microsoft/phi-3-vision-128k-instruct                                     | 128k tokens        | Modelo multimodal aberto de ponta para raciocínio de alta qualidade a partir de imagens.|
    | microsoft/phi-3.5-vision-instruct                                        | 128k tokens        | Modelo multimodal aberto de ponta para raciocínio de alta qualidade a partir de imagens.|
    | databricks/dbrx-instruct                                                 | 12k tokens         | LLM de uso geral com desempenho no estado da arte para linguagem, programação e RAG.|
    | snowflake/arctic                                                         | 1.024 tokens       | Inferência eficiente para aplicações empresariais focadas em SQL e programação.|
    | aisingapore/sea-lion-7b-instruct                                         | 4.096 tokens       | LLM para representação e diversidade linguística e cultural do sudeste asiático.|
    | ibm/granite-8b-code-instruct                                             | 4.096 tokens       | LLM para programação: geração, explicação e diálogo multi-turn de código.|
    | ibm/granite-34b-code-instruct                                            | 8.192 tokens       | LLM para programação: geração, explicação e diálogo multi-turn de código.|
    | ibm/granite-3.0-8b-instruct                                              | 4.096 tokens       | Pequeno modelo avançado, com suporte a RAG, sumário, classificação, código e IA agentica.|
    | ibm/granite-3.0-3b-a800m-instruct                                        | 4.096 tokens       | Modelo Mixture of Experts eficiente para RAG, sumário, extração de entidades, classificação.|
    | mediatek/breeze-7b-instruct                                              | 4.096 tokens       | Gera dados sintéticos diversos.|
    | upstage/solar-10.7b-instruct                                             | 4.096 tokens       | Excelente em tarefas de PLN, especialmente seguir instruções, raciocínio e matemática.|
    | writer/palmyra-med-70b-32k                                               | 32k tokens         | LLM líder para respostas médicas precisas e contextuais.|
    | writer/palmyra-med-70b                                                   | 32k tokens         | LLM líder para respostas médicas precisas e contextuais.|
    | writer/palmyra-fin-70b-32k                                               | 32k tokens         | LLM especializada em análise financeira, relatórios e processamento de dados.|
    | 01-ai/yi-large                                                           | 32k tokens         | Poderoso para inglês e chinês, incluindo chatbot e escrita criativa.|
    | deepseek-ai/deepseek-coder-6.7b-instruct                                 | 2k tokens          | Modelo avançado para geração de código, autocomplete, infilling.|
    | rakuten/rakutenai-7b-instruct                                            | 1.024 tokens       | LLM topo de linha, compreensão, raciocínio e geração textual.|
    | rakuten/rakutenai-7b-chat                                                | 1.024 tokens       | LLM topo de linha, compreensão, raciocínio e geração textual.|
    | baichuan-inc/baichuan2-13b-chat                                          | 4.096 tokens       | Suporte a chat em chinês/inglês, programação, matemática, seguir instruções, resolver quizzes.|

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Local NVIDIA NIM Deployed using WSL2">

    O NVIDIA NIM permite rodar LLMs potentes localmente em máquinas Windows usando WSL2 (Windows Subsystem for Linux).
    Este método aproveita o GPU NVIDIA para inferência privativa, segura e econômica, sem depender de serviços em nuvem.
    Perfeito para desenvolvimento, testes ou produção onde privacidade ou funcionalidades offline são necessárias.

    Aqui está um guia passo a passo para configurar um modelo local NVIDIA NIM:

    1. Siga as instruções de instalação no [site da NVIDIA](https://docs.nvidia.com/nim/wsl2/latest/getting-started.html)

    2. Instale o modelo local. Para Llama 3.1-8b siga as [instruções](https://build.nvidia.com/meta/llama-3_1-8b-instruct/deploy)

    3. Configure seus modelos locais crewai:

    ```python Code
    from crewai.llm import LLM

    local_nvidia_nim_llm = LLM(
        model="openai/meta/llama-3.1-8b-instruct", # é compatível com openai-api
        base_url="http://localhost:8000/v1",
        api_key="<your_api_key|any text if you have not configured it>", # api_key obrigatório, pode usar qualquer texto
    )

    # Então pode usá-lo no seu crew:

    @CrewBase
    class MyCrew():
        # ...

        @agent
        def researcher(self) -> Agent:
            return Agent(
                config=self.agents_config['researcher'], # type: ignore[index]
                llm=local_nvidia_nim_llm
            )

        # ...
    ```

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Groq">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:

    ```toml Code
    GROQ_API_KEY=<your-api-key>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="groq/llama-3.2-90b-text-preview",
        temperature=0.7
    )
    ```
    | Modelo            | Janela de Contexto   | Melhor Para                             |
    |-------------------|---------------------|------------------------------------------|
    | Llama 3.1 70B/8B  | 131.072 tokens      | Alta performance e tarefas de contexto grande|
    | Llama 3.2 Série   | 8.192 tokens        | Tarefas gerais                          |
    | Mixtral 8x7B      | 32.768 tokens       | Equilíbrio entre performance e contexto  |

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="IBM watsonx.ai">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:
    ```toml Code
    # Obrigatório
    WATSONX_URL=<your-url>
    WATSONX_APIKEY=<your-apikey>
    WATSONX_PROJECT_ID=<your-project-id>

    # Opcional
    WATSONX_TOKEN=<your-token>
    WATSONX_DEPLOYMENT_SPACE_ID=<your-space-id>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="watsonx/meta-llama/llama-3-1-70b-instruct",
        base_url="https://api.watsonx.ai/v1"
    )
    ```

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Ollama (LLMs Locais)">
    1. Instale o Ollama: [ollama.ai](https://ollama.ai/)
    2. Rode um modelo: `ollama run llama3`
    3. Configure:

    ```python Code
    llm = LLM(
        model="ollama/llama3:70b",
        base_url="http://localhost:11434"
    )
    ```

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Fireworks AI">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:
    ```toml Code
    FIREWORKS_API_KEY=<your-api-key>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="fireworks_ai/accounts/fireworks/models/llama-v3-70b-instruct",
        temperature=0.7
    )
    ```

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Perplexity AI">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:
    ```toml Code
    PERPLEXITY_API_KEY=<your-api-key>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="llama-3.1-sonar-large-128k-online",
        base_url="https://api.perplexity.ai/"
    )
    ```

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Hugging Face">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:
    ```toml Code
    HF_TOKEN=<your-api-key>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
    )
    ```

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="SambaNova">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:

    ```toml Code
    SAMBANOVA_API_KEY=<your-api-key>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="sambanova/Meta-Llama-3.1-8B-Instruct",
        temperature=0.7
    )
    ```
    | Modelo            | Janela de Contexto         | Melhor Para                                  |
    |-------------------|---------------------------|----------------------------------------------|
    | Llama 3.1 70B/8B  | Até 131.072 tokens        | Alto desempenho, tarefas com grande contexto |
    | Llama 3.1 405B    | 8.192 tokens              | Desempenho e qualidade de saída elevada      |
    | Llama 3.2 Série   | 8.192 tokens              | Tarefas gerais e multimodais                 |
    | Llama 3.3 70B     | Até 131.072 tokens        | Desempenho e qualidade de saída elevada      |
    | Família Qwen2     | 8.192 tokens              | Desempenho e qualidade de saída elevada      |

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Cerebras">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:
    ```toml Code
    # Obrigatório
    CEREBRAS_API_KEY=<your-api-key>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="cerebras/llama3.1-70b",
        temperature=0.7,
        max_tokens=8192
    )
    ```

    <Info>
      Recursos do Cerebras:
      - Altas velocidades de inferência
      - Preços competitivos
      - Equilíbrio entre velocidade e qualidade
      - Suporte a longas janelas de contexto
    </Info>

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>

  <Accordion title="Open Router">
    Defina as seguintes variáveis de ambiente no seu arquivo `.env`:
    ```toml Code
    OPENROUTER_API_KEY=<your-api-key>
    ```

    Exemplo de uso em seu projeto CrewAI:
    ```python Code
    llm = LLM(
        model="openrouter/deepseek/deepseek-r1",
        base_url="https://openrouter.ai/api/v1",
        api_key=OPENROUTER_API_KEY
    )
    ```

    <Info>
      Modelos do Open Router:
      - openrouter/deepseek/deepseek-r1
      - openrouter/deepseek/deepseek-chat
    </Info>

    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
    ```bash
    uv add 'crewai[litellm]'
    ```
  </Accordion>
</AccordionGroup>

## Respostas em streaming

O CrewAI suporta respostas em streaming de LLMs, permitindo que sua aplicação receba e processe saídas em tempo real assim que são geradas.

<Tabs>
  <Tab title="Configuração Básica">
    Ative o streaming definindo o parâmetro `stream` como `True` ao inicializar seu LLM:

    ```python
    from crewai import LLM

    # Crie um LLM com streaming ativado
    llm = LLM(
        model="openai/gpt-4o",
        stream=True  # Ativar streaming
    )
    ```

    Quando o streaming está ativado, as respostas são entregues em partes à medida que vão sendo geradas, criando uma experiência mais responsiva para o usuário.
  </Tab>

  <Tab title="Manipulação de Eventos">
    O CrewAI emite eventos para cada chunk recebido durante o streaming:

    ```python
    from crewai.events import (
      LLMStreamChunkEvent
    )
    from crewai.events import BaseEventListener

    class MyCustomListener(BaseEventListener):
        def setup_listeners(self, crewai_event_bus):
            @crewai_event_bus.on(LLMStreamChunkEvent)
            def on_llm_stream_chunk(self, event: LLMStreamChunkEvent):
              # Clique para cada chunk assim que chegar
              print(f"Received chunk: {event.chunk}")

    my_listener = MyCustomListener()
    ```

    <Tip>
      [Clique aqui](/pt-BR/concepts/event-listener#event-listeners) para mais detalhes
    </Tip>
  </Tab>
</Tabs>

## Chamada Estruturada de LLM

O CrewAI suporta respostas estruturadas de LLMs permitindo que você defina um `response_format` usando um modelo Pydantic. Isso permite que o framework automaticamente faça o parsing e valide a saída, facilitando a integração da resposta em sua aplicação sem pós-processamento manual.

Por exemplo, é possível definir um modelo Pydantic para representar a resposta esperada e passá-lo como `response_format` ao instanciar o LLM. O modelo será utilizado para converter a resposta do LLM em um objeto Python estruturado.

```python Code
from crewai import LLM

class Dog(BaseModel):
    name: str
    age: int
    breed: str


llm = LLM(model="gpt-4o", response_format=Dog)

response = llm.call(
    "Analyze the following messages and return the name, age, and breed. "
    "Meet Kona! She is 3 years old and is a black german shepherd."
)
print(response)

# Output:
# Dog(name='Kona', age=3, breed='black german shepherd')
```

## Recursos Avançados e Otimização

Saiba como obter o máximo da configuração do seu LLM:

<AccordionGroup>
  <Accordion title="Gestão da Janela de Contexto">
    O CrewAI inclui recursos inteligentes para gerenciamento de contexto:

    ```python
    from crewai import LLM

    # O CrewAI automaticamente gerencia:
    # 1. Contagem e acompanhamento de tokens
    # 2. Resumo de conteúdo quando necessário
    # 3. Divisão de tarefas para grandes contextos

    llm = LLM(
        model="gpt-4",
        max_tokens=4000,  # Limitar tamanho da resposta
    )
    ```

    <Info>
      Boas práticas para o gerenciamento de contexto:
      1. Prefira modelos com janelas apropriadas
      2. Pré-processe entradas muito longas
      3. Utilize divisão para documentos grandes
      4. Monitore tokens para otimizar custos
    </Info>
  </Accordion>

  <Accordion title="Otimização de Performance">
    <Steps>
      <Step title="Otimização do Uso de Tokens">
        Escolha a janela de contexto certa para sua tarefa:
        - Tarefas pequenas (até 4K tokens): Modelos padrão
        - Tarefas médias (entre 4K-32K): Modelos aprimorados
        - Tarefas grandes (acima de 32K): Modelos com contexto expandido

        ```python
        # Configure o modelo com as opções certas
        llm = LLM(
            model="openai/gpt-4-turbo-preview",
            temperature=0.7,    # Ajuste conforme a tarefa
            max_tokens=4096,    # Defina conforme a necessidade da saída
            timeout=300        # Timeout maior para tarefas complexas
        )
        ```
        <Tip>
          - Temperaturas baixas (0.1 a 0.3) para respostas factuais
          - Temperaturas altas (0.7 a 0.9) para tarefas criativas
        </Tip>
      </Step>

      <Step title="Boas Práticas">
        1. Monitore o uso de tokens
        2. Implemente limites de taxa (rate limiting)
        3. Use cache quando possível
        4. Defina limites apropriados para max_tokens
      </Step>
    </Steps>

    <Info>
      Lembre-se de monitorar regularmente o uso de tokens e ajustar suas configurações para otimizar custos e desempenho.
    </Info>
  </Accordion>

  <Accordion title="Descartar Parâmetros Adicionais">
    O CrewAI usa Litellm internamente para chamadas LLM, permitindo descartar parâmetros adicionais desnecessários para seu caso de uso. Isso pode simplificar seu código e reduzir a complexidade da configuração do LLM.
    Por exemplo, se não precisar enviar o parâmetro <code>stop</code>, basta omiti-lo na chamada do LLM:

    ```python
    from crewai import LLM
    import os

    os.environ["OPENAI_API_KEY"] = "<api-key>"

    o3_llm = LLM(
        model="o3",
        drop_params=True,
        additional_drop_params=["stop"]
    )
    ```
  </Accordion>
</AccordionGroup>

## Problemas Comuns e Soluções

<Tabs>
  <Tab title="Autenticação">
    <Warning>
      A maioria dos problemas de autenticação pode ser resolvida verificando o formato da chave da API e os nomes das variáveis de ambiente.
    </Warning>

    ```bash
    # OpenAI
    OPENAI_API_KEY=sk-...

    # Anthropic
    ANTHROPIC_API_KEY=sk-ant-...
    ```
  </Tab>
  <Tab title="Nomes dos Modelos">
    <Check>
      Sempre inclua o prefixo do provedor nos nomes dos modelos
    </Check>

    ```python
    # Correto
    llm = LLM(model="openai/gpt-4")

    # Incorreto
    llm = LLM(model="gpt-4")
    ```
  </Tab>
  <Tab title="Comprimento do Contexto">
    <Tip>
      Use modelos de contexto expandido para tarefas extensas
    </Tip>

    ```python
    # Modelo com contexto expandido
    llm = LLM(model="openai/gpt-4o")  # 128K tokens
    ```
  </Tab>
</Tabs>
