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

# Modelos de Linguagem de Grande Porte

## Capacidades dos modelos

Modelos de Linguagem de Grande Porte (LLMs) são tipos de modelo de IA criados usando técnicas de deep learning e processamento de linguagem natural. Após serem treinados com enormes quantidades de dados de texto, eles conseguem entender, gerar e processar linguagem humana. LLMs têm as seguintes capacidades principais:

* **Geração de texto**

  LLMs podem gerar conteúdo logicamente coerente com base no contexto e ajustar o estilo da saída conforme necessário.
* **Compreensão de linguagem**

  LLMs conseguem entender com precisão o significado do texto de entrada e dar suporte a conversas com consciência de contexto.
* **Tradução de texto**

  LLMs são capazes de compreensão e geração entre idiomas, possibilitando a tradução entre diferentes línguas.
* **Perguntas e respostas baseadas em conhecimento**

  Com uma ampla base de conhecimento, LLMs podem responder perguntas em domínios como cultura, ciência e história.
* **Compreensão e geração de código**

  LLMs podem entender e gerar código (Python, Java, C++ e assim por diante), detectar erros de código e oferecer sugestões.
* **Classificação e sumarização de texto**

  LLMs conseguem entender frases complexas, categorizar e extrair informações, além de resumir pontos-chave.

## Seleção de modelo

Na [Página do serviço LLM](https://novita.ai/models), você pode navegar pela lista de modelos compatíveis, conhecer informações básicas dos modelos e consultar preços. Clique em um modelo específico para abrir sua página de detalhes e acessar uma demonstração online. Depois de testar diferentes modelos com sua tarefa, você pode comparar e escolher o mais adequado.

## Integração de API

A Novita AI fornece APIs rápidas e confiáveis para modelos open-source, combinando a facilidade e a confiabilidade de APIs LLM de primeira linha com a flexibilidade e a eficiência de custo dos LLMs open source.

* [ChatCompletion](https://platform.openai.com/docs/guides/text-generation/chat-completions-api): Compatível com modos streaming e non-streaming.
* [Completion](https://platform.openai.com/docs/guides/text-generation/completions-api): Também compatível com modos streaming e non-streaming.

Se você já usa a API `ChatCompletion` ou `Completion` da OpenAI, basta definir sua URL base como: api.novita.ai/openai , obter e configurar sua chave de API, atualizar o nome do modelo conforme necessário e começar a usar os serviços LLM.

<Tip>
  Para saber como criar, armazenar e usar uma chave de API, consulte [API Keys](/docs/pt-BR/guides/llm-api-keys).
</Tip>

## Exemplos de código

### Python

<CodeGroup>
  ```python ChatCompletion theme={"system"}
  from openai import OpenAI

  client = OpenAI(
      base_url="https://api.novita.ai/openai",
      api_key="<Your API Key>",
  )

  model = "deepseek/deepseek-r1"
  stream = True  # or False
  max_tokens = 512

  chat_completion_res = client.chat.completions.create(
      model=model,
      messages=[
          {
              "role": "system",
              "content": "you are a professional AI helper.",
          },
          {
              "role": "user",
              "content": "Where can the example of GPU provided by novita ai be adapted?",
          }
      ],
      stream=stream,
      max_tokens=max_tokens,
  )

  if stream:
      for chunk in chat_completion_res:
          print(chunk.choices[0].delta.content or "", end="")
  else:
      print(chat_completion_res.choices[0].message.content)
  ```

  ```python Completion theme={"system"}
  from openai import OpenAI

  client = OpenAI(
      base_url="https://api.novita.ai/openai",
      api_key="<Your API Key>",
  )

  model = "deepseek/deepseek-r1"
  stream = True  # or False
  max_tokens = 512

  completion_res = client.completions.create(
      model=model,
      prompt="Where can the example of GPU provided by novita ai be adapted?",
      stream=stream,
      max_tokens=max_tokens,
  )

  if stream:
      for chunk in completion_res:
          print(chunk.choices[0].text or "", end="")
  else:
      print(completion_res.choices[0].text)
  ```
</CodeGroup>

### Curl

<CodeGroup>
  ```bash ChatCompletion theme={"system"}
  export API_KEY="<Your API Key>"

  curl "https://api.novita.ai/openai/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${API_KEY}" \
    -d '{
      "model": "deepseek/deepseek-r1",
      "messages": [
          {
              "role": "system",
              "content": "you are a professional AI helper."
          },
         {
              "role": "user",
              "content": "Where can the example of GPU provided by novita ai be adapted?"
          }
      ],
      "max_tokens": 512
  }'
  ```

  ```bash Completion theme={"system"}
  export API_KEY="<Your API Key>"

  curl "https://api.novita.ai/openai/v1/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${API_KEY}" \
    -d '{
      "model": "deepseek/deepseek-r1",
      "prompt": "Where can the example of GPU provided by novita ai be adapted?",
      "max_tokens": 512
  }'
  ```
</CodeGroup>

## Parâmetros principais

### Parâmetros base

`model`: O LLM de destino. Veja a lista completa na [Página do serviço LLM](https://novita.ai/models).

### Messages

> Somente ChatCompletion

`messages`: Entradas e saídas ao interagir com o LLM. Cada mensagem pertence a um personagem. As mensagens podem ajudar você a obter saídas melhores; você pode testar diferentes métodos para alcançar melhores resultados.

* `content`: conteúdo da mensagem.
* `role`: Define o falante:
  * `system`: Define o papel da IA, informando ao modelo seu papel ou comportamento.
  * `user`: A entrada do usuário.
  * `assistant`: A resposta da IA. Os usuários podem fornecer exemplos de saída antecipadamente, informando ao modelo como responder à solicitação atual.
* `name` (opcional): separa autores de mensagens com o mesmo papel.

### Prompt

> Somente ChatCompletion

`prompt`: Texto de instrução para gerar uma completion, escrito pelo usuário para o LLM a fim de informar claramente ao modelo qual é a tarefa.

### Controle de saída

Diferentes combinações de parâmetros podem ajudar o modelo a gerar conteúdo mais satisfatório.

**Diversidade do texto**

> 'temperature' e 'top\_p' podem controlar a diversidade do texto gerado; recomendamos definir apenas um deles. Quanto maior for o valor definido, mais diverso será o texto. Quanto menor for o valor definido, mais preciso será o texto.

* `temperature`: Controla a aleatoriedade. Maior = mais criativo.
* `top_p`: Amostragem de núcleo. Controla a probabilidade cumulativa.
* `top_k`: Limita a contagem de tokens candidatos.

**Penalidades de repetição**

* `presence_penalty`: Controla tokens repetidos nos textos. Se um token já tiver aparecido no texto, uma penalidade será aplicada, o que resulta em mais tokens diferentes no texto.
* `frequency_penalty`: Controla a frequência de tokens nos textos. Toda vez que o mesmo token existir no texto, uma penalidade será aplicada, resultando em menos ocorrências do mesmo token no futuro do texto.
* `repetition_penalty`: Penaliza ou incentiva repetição.

### Limites de saída

* `max_tokens`: Máximo de tokens em uma resposta. O conteúdo após esse valor no texto será truncado.
* `stream`: Se deve usar streaming. Para saídas longas, recomendamos usar o modo streaming para evitar erro de timeout:
  * `true`: Transmitido por streaming, com resultados parciais conforme são gerados.
  * `false`: Resultado completo após o processamento.
* `stop`: Strings que encerrarão a geração quando encontradas.