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

# Modelos de linguagem grandes

## Capacidades do modelo

Um modelo de linguagem grande (LLM) é um modelo de inteligência artificial baseado em aprendizado profundo e tecnologias de processamento de linguagem natural. Treinado com grandes volumes de dados textuais, ele consegue compreender, gerar e processar a linguagem humana. Suas principais capacidades incluem:

* **Geração de texto**

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

  Capaz de compreender com precisão o significado do texto de entrada e oferecer suporte a conversas combinando o contexto.
* **Tradução de texto**

  Possui capacidades de geração e compreensão multilíngue, permitindo a tradução de textos entre diferentes idiomas.
* **Perguntas e respostas com conhecimento**

  Possui uma ampla base de conhecimento e consegue responder a perguntas em diversas áreas, como cultura, ciência e história.
* **Compreensão e geração de código**

  Capaz de compreender e gerar código (como Python, Java, C++ etc.), oferecer suporte à identificação de erros de código, fornecer sugestões de código e muito mais.
* **Classificação e resumo de texto**

  Capaz de compreender frases complexas, realizar classificação e extração de informações, além de extrair pontos-chave do texto para gerar resumos automáticos.

## Seleção de modelo

Em [JieKou AI](https://jiekou.ai/#model-library), você pode consultar a lista de modelos de linguagem grandes compatíveis com a plataforma e obter informações como introdução básica e preços dos modelos. Ao clicar em um modelo específico, você pode abrir a página de detalhes e testá-lo online conforme necessário. Depois de testá-lo suficientemente com tarefas específicas, você pode comparar o desempenho dos modelos e escolher o modelo mais adequado.

## Chamada da API

JieKou AI fornece um serviço de API compatível com o padrão da OpenAI API, facilitando a integração com seus aplicativos existentes.

* [ChatCompletion](https://platform.openai.com/docs/api-reference/chat), com suporte aos modos streaming e convencional.
* [Completion](https://platform.openai.com/docs/api-reference/completions), com suporte aos modos streaming e convencional.

Se você já usa a API ChatCompletion ou Completion da OpenAI, basta definir a URL base como `https://api.highwayapi.ai/openai`, obter e configurar sua chave de API e atualizar o nome do modelo conforme necessário para acessar o serviço de API de modelos de linguagem grandes.

<Tip>
  Para saber como obter uma chave de API, consulte [Gerenciar chaves de API](/pt/docs/support/quickstart).
</Tip>

### Exemplo de código

#### Python

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

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

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

  chat_completion_res = client.chat.completions.create(
      model=model,
      messages=[
          {
              "role": "system",
              "content": "您是一个专业的 AI 文档助手。",
          },
          {
              "role": "user",
              "content": "JieKou AI 提供的模型能用于哪些场景？",
          }
      ],
      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={null}
  from openai import OpenAI

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

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

  completion_res = client.completions.create(
      model=model,
      prompt="JieKou AI 提供的模型能用于哪些场景？",
      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={null}
  export API_KEY="<Your API Key>"

  curl "https://api.highwayapi.ai/openai/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${API_KEY}" \
    -d '{
      "model": "deepseek/deepseek-r1",
      "messages": [
          {
              "role": "system",
              "content": "您是一个专业的 AI 文档助手。"
          },
         {
              "role": "user",
              "content": "JieKou AI 提供的模型能用于哪些场景？"
          }
      ],
      "max_tokens": 512
  }'
  ```

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

  curl "https://api.highwayapi.ai/openai/v1/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer ${API_KEY}" \
    -d '{
      "model": "deepseek/deepseek-r1",
      "prompt": "JieKou AI 提供的模型能用于哪些场景？",
      "max_tokens": 512
  }'
  ```
</CodeGroup>

### Parâmetros principais

#### Parâmetros básicos

`model`: o modelo a ser chamado. Você pode consultar em [JieKou AI](https://jiekou.ai/#model-library) a lista de modelos de linguagem grandes compatíveis com a plataforma.

#### Papéis das mensagens

> Aplicável apenas ao ChatCompletion.

`messages`: entradas e saídas ao interagir com o modelo grande. Cada mensagem pertence a um papel. As mensagens podem ajudar você a obter melhores saídas; você pode experimentar diferentes abordagens para obter melhores resultados.

* `content`: conteúdo da mensagem.
* `role`: papel do autor da mensagem.
  * `system`: define o papel da IA, informando ao modelo qual papel ou comportamento deve assumir.
  * `user`: texto inserido pelo usuário para o modelo.
  * `assistant`: resposta gerada pelo modelo. O usuário também pode preencher exemplos antecipadamente para informar ao modelo como ele deve responder à solicitação atual.
* `name`: opcional, usado para diferenciar autores de mensagens com o mesmo papel.

#### Prompt

> Aplicável apenas ao Completion.

`prompt`: o prompt para gerar a complementação. É a informação textual inserida pelo usuário para o modelo de linguagem grande, usada para informar claramente ao modelo o problema a ser resolvido ou a tarefa a ser concluída, além de servir como base para o modelo compreender a necessidade e gerar conteúdo relevante e preciso.

#### Controle de geração

Diferentes combinações de parâmetros permitem que o modelo gere conteúdo mais alinhado a necessidades específicas.

**Diversidade do texto**

> `temperature` e `top_p` podem controlar a diversidade do texto gerado. Recomendamos definir apenas um desses valores. Quanto maior o valor definido, mais diverso será o texto gerado. Quanto menor o valor, mais determinístico será o texto gerado.

* `temperature`: temperatura de amostragem, ajusta a aleatoriedade do texto gerado.
* `top_p`: amostragem nuclear, controla a probabilidade acumulada das palavras candidatas.
* `top_k`: limita a quantidade de palavras candidatas.

**Repetição de conteúdo**

* `presence_penalty`: penalidade de presença, controla o grau de repetição de conteúdo quando o modelo gera texto. Se um Token já apareceu no texto, ele será penalizado, o que faz com que o modelo introduza mais Tokens novos.
* `frequency_penalty`: penalidade de probabilidade, controla a frequência de ocorrência de certas palavras no texto gerado. Faz com que o Token seja penalizado cada vez que aparece no texto, reduzindo assim a probabilidade desses Tokens em gerações futuras e impedindo que o modelo reutilize o mesmo Token repetidamente.
* `repetition_penalty`: valor de penalidade de repetição, usado para suprimir ou incentivar repetições.

#### Limites de saída

* `max_tokens`: número máximo de Tokens retornados em uma única solicitação. Se o número de Tokens gerados pelo modelo exceder o valor de `max_tokens`, o conteúdo truncado será retornado.
* `stream`: controla se a saída será em streaming. Para alguns modelos com grande volume de conteúdo de saída, recomenda-se configurar como saída em streaming para evitar que a saída seja longa demais e cause timeout.
  * `true`: saída em streaming, ou seja, gera e exibe ao mesmo tempo; o modelo retorna um fragmento sempre que gera uma parte do conteúdo.
  * `false`: o modelo retorna o resultado de uma só vez depois de gerar todo o conteúdo.
* `stop`: caracteres de término. Quando o texto gerado pelo modelo contiver a string definida em `stop`, o modelo interromperá a saída.
