Geração de Texto Avançada com Modelos de Linguagem Grandes (LLMs)

Os Modelos de Linguagem Grandes (LLMs) são sofisticadas redes neurais treinadas com vastos volumes de dados textuais. Essa arquitetura permite que gerem respostas coesas, contextualmente relevantes e criativas a partir de instruções textuais (prompts). Na plataforma SipPulse AI, oferecemos acesso a uma seleção diversificada de LLMs dos principais desenvolvedores globais, como OpenAI, Google, Anthropic, Meta, Qwen, Deepseek, entre outros. Cada modelo possui características distintas de desempenho, custo e especialização.

Para uma visão completa de todos os modelos, suas especificações técnicas detalhadas e a estrutura de preços, consulte nossa página oficial de Pricing.

Playground Interativo

O Playground de Geração de Texto (acessar aqui) é uma interface web amigável, projetada para facilitar a experimentação e avaliação do comportamento de cada LLM.

Seleção do Modelo

Navegue e escolha qualquer LLM listado no seletor.

Configuração de Parâmetros

Controle parâmetros como temperature, max_tokens, top_p e outros. Veja o Guia de Parâmetros para detalhes.
Importante: Cada modelo suporta parâmetros diferentes. O Playground exibe automaticamente apenas os controles relevantes para o modelo selecionado.

Parâmetros Dinâmicos por Modelo

Modelos de raciocínio (GPT-5.x, Claude, DeepSeek) usam parâmetros especiais como reasoning_effort e thinking em vez de temperature. Modelos tradicionais (GPT-4o) usam temperature, top_p, max_tokens. Selecione um modelo no Playground para ver seus parâmetros disponíveis.

Criação de Prompts e Mensagens

Defina uma Mensagem de Sistema (System Message) para instruir o LLM sobre o tom, estilo, persona ou regras específicas que deve seguir nas respostas.
Insira uma sequência de mensagens de usuário e assistente para simular conversas complexas e testar a capacidade do modelo de manter o contexto.
Para aprender a criar prompts e mensagens de sistema eficazes, consulte nosso Guia de Engenharia de Prompts para LLMs.

Execução e Visualização

Obtenha feedback instantâneo. As respostas do modelo são exibidas imediatamente após cada envio de prompt.

Geração de Código

Com um clique em "Ver Código", o Playground gera automaticamente trechos de código em cURL, Python e JavaScript.
Esses exemplos incluem o modelo e os parâmetros exatos que você configurou, prontos para serem copiados e colados em seus projetos.
Selecione facilmente a linguagem desejada utilizando as abas na parte superior do modal de código.

Atalhos de Teclado

Atalho	Ação
`Cmd/Ctrl + Enter`	Enviar mensagem
`Shift + Enter`	Nova linha (sem enviar)

Gerenciamento de Conversas

O Playground oferece controles para gerenciar sua conversa de teste:

Editar mensagens: Clique no ícone de lápis para editar qualquer mensagem enviada
Alternar role: Troque entre "user" e "assistant" para simular diferentes cenários
Limpar conversa: Use o botão "Clear" para reiniciar a conversa
Múltiplas mensagens: Adicione várias mensagens antes de executar para testar contextos complexos

Informações do Modelo

O card do modelo selecionado exibe informações úteis:

Context window: Tamanho máximo do contexto em tokens
Pricing: Custo por milhão de tokens (input/output)
Badge "Agent": Indica que o modelo suporta tool calling

O Playground é uma ferramenta valiosa tanto para usuários sem experiência em programação, que desejam entender o potencial dos LLMs, quanto para desenvolvedores experientes que buscam validar rapidamente diferentes configurações e modelos antes da implementação.

Consumo via API REST

Integre o poder dos LLMs diretamente em suas aplicações, scripts personalizados e fluxos de trabalho automatizados através de chamadas ao nosso endpoint RESTful.

Para detalhes sobre como usar a API, consulte a documentação da REST API.

cURLPythonJavaScript

bash

# Exemplo de requisição para completar um texto
# Substitua $SIPPULSE_API_KEY pela sua chave de API.
curl -X POST 'https://api.sippulse.ai/v1/llms/completion' \
  -H 'Content-Type: application/json' \
  -H 'api-key: $SIPPULSE_API_KEY' \
  -d '{
  "model": "gpt-4o-mini",
  "messages": [
    { "role": "system", "content": "Você é um assistente de IA especializado em história espacial." },
    { "role": "user",   "content": "Descreva em detalhes a importância da missão Apollo 11." }
  ],
  "temperature": 0.7,
  "max_tokens": 250,
  "stream": false # Defina como true para receber a resposta em partes (streaming)
  }'

python

import os
import requests
import json

def generate_text_completion(messages: list, model: str = "gpt-4o-mini", temperature: float = 0.7, max_tokens: int = 250, stream: bool = False) -> dict:
  """
  Chama o endpoint /v1/llms/completion para gerar texto com um LLM.

  Args:
    messages: Lista de mensagens (histórico da conversa).
    model: Identificador do modelo a ser usado.
    temperature: Controla a aleatoriedade da saída.
    max_tokens: Número máximo de tokens a serem gerados.
    stream: Se true, a resposta será enviada em partes.

  Returns:
    Dicionário contendo a resposta da API.
  """
  api_url = "https://api.sippulse.ai/v1/llms/completion"
  api_key = os.getenv("SIPPULSE_API_KEY")

  if not api_key:
    raise ValueError("A variável de ambiente SIPPULSE_API_KEY não está definida.")

  headers = {
    "Content-Type": "application/json",
    "api-key": api_key
  }
  payload = {
    "model": model,
    "messages": messages,
    "temperature": temperature,
    "max_tokens": max_tokens,
    "stream": stream
  }

  try:
    response = requests.post(api_url, headers=headers, json=payload)
    response.raise_for_status()  # Lança uma exceção para respostas de erro (4xx ou 5xx)
    return response.json()
  except requests.exceptions.RequestException as e:
    print(f"Erro na requisição API: {e}")
    if response is not None:
      print(f"Detalhes do erro: {response.text}")
    return None

if __name__ == "__main__":
  convo_messages = [
    {"role": "system", "content": "Você é um assistente de IA especializado em história espacial."},
    {"role": "user", "content": "Descreva em detalhes a importância da missão Apollo 11."}
  ]
  completion_result = generate_text_completion(convo_messages, model="gpt-4o-mini")

  if completion_result:
    # A estrutura da resposta pode variar dependendo do modelo e se stream=true
    # Geralmente, o conteúdo gerado está em completion_result['choices'][0]['message']['content']
    print(json.dumps(completion_result, indent=2, ensure_ascii=False))

javascript

// Exemplo usando a Fetch API no Node.js ou navegador
async function getTextCompletion(messages, model = "gpt-4o-mini", temperature = 0.7, maxTokens = 250, stream = false) {
  const apiUrl = "https://api.sippulse.ai/v1/llms/completion";
  const apiKey = process.env.SIPPULSE_API_KEY; // Certifique-se que SIPPULSE_API_KEY está no ambiente

  if (!apiKey) {
  throw new Error("A variável de ambiente SIPPULSE_API_KEY não está definida.");
  }

  try {
  const response = await fetch(apiUrl, {
    method: "POST",
    headers: {
    "Content-Type": "application/json",
    "api-key": apiKey
    },
    body: JSON.stringify({
    model,
    messages,
    temperature,
    max_tokens: maxTokens,
    stream
    })
  });

  if (!response.ok) {
    const errorBody = await response.text();
    throw new Error(`Erro na API: ${response.status} ${response.statusText} - ${errorBody}`);
  }
  return response.json();
  } catch (error) {
  console.error("Falha ao chamar a API de completion:", error);
  throw error;
  }
}

// Exemplo de uso
const conversationMessages = [
  { role: "system", content: "Você é um assistente de IA especializado em história espacial." },
  { role: "user",   content: "Descreva em detalhes a importância da missão Apollo 11." }
];

getTextCompletion(conversationMessages)
  .then(result => console.log(JSON.stringify(result, null, 2)))
  .catch(error => console.error(error));

Estrutura da Resposta

A API retorna um objeto com a resposta gerada, informações de uso e métricas de desempenho:

json

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "A missão Apollo 11 foi um marco histórico..."
      },
      "finish_reason": "stop"
    }
  ],
  "created": 1704067200000,
  "model": "gpt-4o-mini",
  "usage": {
    "input_tokens": 45,
    "output_tokens": 120,
    "total_tokens": 165
  },
  "performance": {
    "delay": 150,
    "execution_time": 1200,
    "relative_execution_time": 100.0
  }
}

Campo	Descrição
`choices`	Array de respostas geradas pelo modelo
`choices[].message`	Mensagem do assistente com role e content
`choices[].finish_reason`	Motivo do término: `stop`, `length`, `tool_calls`
`usage.input_tokens`	Tokens consumidos pelo prompt de entrada
`usage.output_tokens`	Tokens gerados na resposta
`performance.execution_time`	Tempo de execução em milissegundos

Streaming de Respostas

Para respostas em tempo real conforme são geradas, defina stream: true. A API retorna chunks no formato Server-Sent Events (SSE), ideal para interfaces de chat.

Quando Usar Streaming

Cenário	Recomendação
Chat interativo	✅ Usar streaming
Processamento em batch	❌ Não usar
Respostas longas	✅ Usar streaming
Integração simples	❌ Não usar

Formato dos Chunks

Cada chunk segue o formato SSE:

data: {"choices":[{"delta":{"content":"texto"}}]}
data: {"choices":[{"delta":{"content":" parcial"}}]}
data: [DONE]

Campo	Descrição
`delta.content`	Fragmento de texto gerado
`delta.role`	Presente apenas no primeiro chunk
`delta.tool_calls`	Presente quando há tool calls em streaming

Exemplos Completos

JavaScriptPython

javascript

async function streamCompletion(messages) {
  const response = await fetch('https://api.sippulse.ai/v1/llms/completion', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'api-key': process.env.SIPPULSE_API_KEY
    },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages,
      stream: true
    })
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let fullContent = '';

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    const chunk = decoder.decode(value);
    const lines = chunk.split('\n');

    for (const line of lines) {
      if (line.startsWith('data: ') && line !== 'data: [DONE]') {
        try {
          const data = JSON.parse(line.slice(6));
          const content = data.choices[0]?.delta?.content || '';
          fullContent += content;
          process.stdout.write(content); // Exibe em tempo real
        } catch (e) {
          // Ignora linhas mal formatadas
        }
      }
    }
  }

  return fullContent;
}

python

import requests
import json
import os

def stream_completion(messages):
    response = requests.post(
        'https://api.sippulse.ai/v1/llms/completion',
        headers={
            'Content-Type': 'application/json',
            'api-key': os.environ['SIPPULSE_API_KEY']
        },
        json={
            'model': 'gpt-4o-mini',
            'messages': messages,
            'stream': True
        },
        stream=True
    )

    full_content = ''

    for line in response.iter_lines():
        if line:
            line_text = line.decode('utf-8')
            if line_text.startswith('data: ') and line_text != 'data: [DONE]':
                try:
                    data = json.loads(line_text[6:])
                    content = data['choices'][0]['delta'].get('content', '')
                    full_content += content
                    print(content, end='', flush=True)
                except json.JSONDecodeError:
                    pass

    return full_content

Streaming com Tool Calls

Em streaming, tool calls são enviados incrementalmente:

data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_abc","function":{"name":"get_weather"}}]}}]}
data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\"ci"}}]}}]}
data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"ty\": \"SP\"}"}}]}}]}
data: [DONE]

Você deve acumular os fragmentos de arguments até receber [DONE].

Chunk Final com Uso de Tokens

O último chunk antes de [DONE] inclui informações de uso:

json

{
  "choices": [{"delta": {}, "finish_reason": "stop"}],
  "usage": {
    "input_tokens": 45,
    "output_tokens": 120
  }
}

Tool Calling (Function Calling)

Modelos com a capability tools: true suportam chamadas de ferramentas, permitindo que o modelo solicite a execução de funções externas e use os resultados para gerar respostas.

Verificar Compatibilidade

Verifique se o modelo suporta tools consultando o array resources na resposta de /v1/llms/models. Se resources contém "tools", o modelo suporta tool calling.

Definindo Ferramentas

json

{
  "model": "gpt-4o",
  "messages": [
    { "role": "user", "content": "Qual a previsão do tempo em São Paulo?" }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Obtém a previsão do tempo para uma cidade",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {
              "type": "string",
              "description": "Nome da cidade"
            }
          },
          "required": ["city"]
        }
      }
    }
  ]
}

Resposta com Tool Call

Quando o modelo decide usar uma ferramenta, a resposta inclui tool_calls:

json

{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": null,
      "tool_calls": [{
        "id": "call_abc123",
        "type": "function",
        "function": {
          "name": "get_weather",
          "arguments": "{\"city\": \"São Paulo\"}"
        }
      }]
    },
    "finish_reason": "tool_calls"
  }]
}

Enviando Resultado da Ferramenta

Após executar a ferramenta em seu sistema, envie o resultado de volta:

json

{
  "model": "gpt-4o",
  "messages": [
    { "role": "user", "content": "Qual a previsão do tempo em São Paulo?" },
    {
      "role": "assistant",
      "tool_calls": [{
        "id": "call_abc123",
        "type": "function",
        "function": { "name": "get_weather", "arguments": "{\"city\": \"São Paulo\"}" }
      }]
    },
    {
      "role": "tool",
      "tool_call_id": "call_abc123",
      "content": "{\"temperature\": 25, \"condition\": \"ensolarado\", \"humidity\": 60}"
    }
  ]
}

O modelo então gera uma resposta usando os dados da ferramenta:

json

{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "Em São Paulo, a temperatura está em 25°C com céu ensolarado e umidade de 60%."
    },
    "finish_reason": "stop"
  }]
}

Modelos Disponíveis

Para manter sua aplicação atualizada com os LLMs habilitados para sua organização, utilize o endpoint /v1/llms/models. Isso permite que sua aplicação se adapte dinamicamente aos modelos disponíveis sem necessidade de atualizações manuais de código.

cURLPythonJavaScript

bash

# Lista todos os modelos de LLM disponíveis para sua chave de API
curl -X GET 'https://api.sippulse.ai/v1/llms/models' \
  -H 'api-key: $SIPPULSE_API_KEY'

python

import os
import requests
import json

def list_available_models() -> dict:
  """
  Recupera a lista de LLMs disponíveis para a organização associada à chave API.
  """
  api_url = "https://api.sippulse.ai/v1/llms/models"
  api_key = os.getenv("SIPPULSE_API_KEY")

  if not api_key:
    raise ValueError("A variável de ambiente SIPPULSE_API_KEY não está definida.")

  headers = { "api-key": api_key }

  try:
    response = requests.get(api_url, headers=headers)
    response.raise_for_status()
    return response.json()
  except requests.exceptions.RequestException as e:
    print(f"Erro na requisição API para listar modelos: {e}")
    if response is not None:
      print(f"Detalhes do erro: {response.text}")
    return None

if __name__ == "__main__":
  models_data = list_available_models()
  if models_data:
    print("Modelos Disponíveis:")
    print(json.dumps(models_data, indent=2, ensure_ascii=False))

javascript

// Exemplo usando a Fetch API para listar modelos
async function listAvailableModels() {
  const apiUrl = "https://api.sippulse.ai/v1/llms/models";
  const apiKey = process.env.SIPPULSE_API_KEY;

  if (!apiKey) {
  throw new Error("A variável de ambiente SIPPULSE_API_KEY não está definida.");
  }

  try {
  const response = await fetch(apiUrl, {
    method: "GET",
    headers: { "api-key": apiKey }
  });

  if (!response.ok) {
    const errorBody = await response.text();
    throw new Error(`Erro na API ao listar modelos: ${response.status} ${response.statusText} - ${errorBody}`);
  }
  return response.json();
  } catch (error) {
  console.error("Falha ao chamar a API para listar modelos:", error);
  throw error;
  }
}

listAvailableModels()
  .then(models => console.log("Modelos Disponíveis:", JSON.stringify(models, null, 2)))
  .catch(error => console.error(error));

Exemplo de Resposta

json

[
  {
    "name": "gpt-4o",
    "status": "active",
    "execution_type": "cloud",
    "resources": ["tools", "json_schema"]
  },
  {
    "name": "gpt-4o-mini",
    "status": "active",
    "execution_type": "cloud",
    "resources": ["tools", "json_schema"]
  },
  {
    "name": "claude-sonnet-4-20250514",
    "status": "active",
    "execution_type": "cloud",
    "resources": ["tools", "json_schema"]
  }
]

Campo	Descrição
`name`	Identificador do modelo para uso na API
`status`	Status do modelo: `active`, `inactive`, `deprecated`
`execution_type`	Tipo de execução (sempre `cloud`)
`resources`	Array de capabilities: `tools`, `json_schema`

Campo Resources

O campo resources indica capabilities suportadas pelo modelo:

"tools" - Suporta tool calling (function calling)
"json_schema" - Suporta structured output com JSON Schema

Para informações detalhadas sobre cada modelo (context window, pricing, parâmetros), consulte a página de Pricing.

SDK da OpenAI

Para desenvolvedores familiarizados com o SDK oficial da OpenAI, o SipPulse AI oferece uma integração simplificada. Basta configurar o baseURL do cliente OpenAI para apontar para o nosso endpoint compatível: https://api.sippulse.ai/v1/openai.

Isso permite que você utilize todas as funcionalidades e convenções do SDK da OpenAI, enquanto as requisições são processadas pela infraestrutura do SipPulse AI, aproveitando nossa seleção de modelos e otimizações.

PythonJavaScript

python

# Exemplo de uso com o SDK Python da OpenAI
import os
from openai import OpenAI

# Configura o cliente OpenAI para usar o endpoint do SipPulse AI
client = OpenAI(
  api_key=os.environ.get("SIPPULSE_API_KEY"),
  base_url="https://api.sippulse.ai/v1/openai"
)

try:
  chat_completion = client.chat.completions.create(
    model="gpt-4o-mini", # Ou qualquer outro modelo compatível disponível no SipPulse AI
    messages=[
      {"role": "system", "content": "Você é um assistente prestativo que adora trocadilhos."},
      {"role": "user", "content": "Conte uma piada sobre programação."}
    ],
    temperature=0.6,
    max_tokens=100
  )
  print(chat_completion.choices[0].message.content)
except Exception as e:
  print(f"Ocorreu um erro: {e}")

javascript

// Exemplo de uso com o SDK JavaScript da OpenAI
import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: process.env.SIPPULSE_API_KEY, // Sua chave SipPulse AI
  baseURL: "https://api.sippulse.ai/v1/openai" // Endpoint compatível do SipPulse AI
});

async function main() {
  try {
  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini", // Ou qualquer outro modelo compatível
    messages: [
    { role: "system", content: "Você é um assistente prestativo que adora trocadilhos." },
    { role: "user",   content: "Conte uma piada sobre programação." }
    ],
    temperature: 0.6,
    max_tokens: 100
  });

  console.log(response.choices[0].message.content);
  } catch (error) {
  console.error("Ocorreu um erro:", error);
  }
}

main();

Benefício: Esta abordagem permite que você mantenha a familiaridade e as conveniências do SDK da OpenAI, como tipagem e métodos específicos, enquanto suas chamadas são roteadas e executadas através da plataforma SipPulse AI. Você pode alternar entre modelos da OpenAI e outros modelos oferecidos pelo SipPulse AI, se suportado pelo endpoint de compatibilidade.

Tratamento de Erros

Códigos HTTP

Código	Erro	Descrição
400	`bad_request`	Requisição malformada ou parâmetros inválidos
401	`unauthorized`	API key inválida ou ausente
404	`model_not_found`	Modelo não existe ou não disponível
429	`rate_limit_exceeded`	Limite de requisições excedido
500	`internal_error`	Erro interno do servidor
503	`service_unavailable`	Serviço temporariamente indisponível
504	`timeout`	Tempo limite excedido

Estrutura de Erro

json

{
  "error": {
    "code": "model_not_found",
    "message": "The model 'gpt-99' does not exist or is not available for your organization."
  }
}

Erros Comuns e Soluções

Código	Causa Comum	Solução
`invalid_api_key`	Chave API incorreta	Verifique a chave em Configurações > API Keys
`model_does_not_support_json_schema`	Modelo incompatível com structured output	Use modelo com `structured_output: true`
`context_length_exceeded`	Prompt muito longo	Reduza o tamanho das mensagens ou use modelo com context maior
`rate_limit_exceeded`	Muitas requisições	Aguarde ou integre sua própria chave API

Integração de Chave API Própria

Se você frequentemente atinge limites de taxa, considere integrar sua própria chave API de provedores como OpenAI ou Anthropic. Isso permite usar seus próprios limites e faturamento direto.

Exemplo de Tratamento

JavaScriptPython

javascript

try {
  const response = await fetch('https://api.sippulse.ai/v1/llms/completion', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'api-key': apiKey },
    body: JSON.stringify({ model, messages })
  });

  if (!response.ok) {
    const error = await response.json();

    switch (error.error?.code) {
      case 'rate_limit_exceeded':
        // Implementar retry com backoff
        await sleep(5000);
        return retry();
      case 'context_length_exceeded':
        // Truncar mensagens
        return retryWithShorterContext();
      default:
        throw new Error(error.error?.message || 'Unknown error');
    }
  }

  return response.json();
} catch (e) {
  console.error('API Error:', e.message);
}

python

import time

def call_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(
                'https://api.sippulse.ai/v1/llms/completion',
                headers={'api-key': api_key, 'Content-Type': 'application/json'},
                json={'model': 'gpt-4o-mini', 'messages': messages}
            )

            if response.status_code == 429:
                # Rate limited - esperar e tentar novamente
                time.sleep(2 ** attempt)
                continue

            response.raise_for_status()
            return response.json()

        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)

Guia de Parâmetros

Os parâmetros de geração variam de acordo com o modelo selecionado. O Playground exibe automaticamente apenas os controles relevantes para o modelo escolhido.

Parâmetros por Tipo de Modelo

Modelos de raciocínio (GPT-5.x, Claude, DeepSeek): usam reasoning_effort em vez de temperature
Modelos tradicionais (GPT-4o): usam temperature, top_p, max_tokens

Parâmetros Comuns

Parâmetro	Faixa	Descrição
`temperature`	0-2	Controla aleatoriedade. Baixo = focado, alto = criativo
`max_tokens`	1-128k	Limite máximo de tokens na resposta
`top_p`	0-1	Amostragem nucleus. Alternativa ao temperature
`top_k`	1-100	Limita seleção aos K tokens mais prováveis
`frequency_penalty`	-2 a 2	Penaliza repetição de tokens
`presence_penalty`	-2 a 2	Incentiva novos tópicos

Dicas de Uso

Tarefas precisas (código, extração): use temperature baixo (0.0-0.3)
Tarefas criativas (escrita, brainstorming): use temperature mais alto (0.7-1.0)
Ajuste temperature ou top_p, não ambos ao mesmo tempo
O max_tokens total (prompt + resposta) não pode exceder o limite do modelo

A melhor forma de entender esses parâmetros é experimentar no Playground.

Raciocínio (reasoning)

Modelos de raciocínio produzem uma cadeia de pensamento antes da resposta final. A plataforma normaliza esse texto em um único campo, qualquer que seja o provedor:

choices[0].message.reasoning_content na resposta sem streaming;
choices[0].delta.reasoning_content em cada chunk do streaming. Um chunk pode trazer só reasoning_content, sem content.

O parâmetro que liga o raciocínio depende da família do modelo:

Família	Parâmetro	Valores
OpenAI (GPT-5.x)	`reasoning_effort`	níveis que o modelo aceita
DeepSeek	`reasoning_effort`	`none`, `high`, `max`
OpenRouter	`reasoning_effort`	níveis que o modelo aceita
Claude	`thinking`	orçamento manual de tokens ou adaptativo ligado/desligado
Qwen	`enable_thinking`	ligado/desligado

Os valores efetivos de cada modelo saem do card do modelo no catálogo, no Playground. Modelos de raciocínio usam reasoning_effort em vez de temperature.

Exemplo de requisição

json

{
  "model": "gpt-5.4-nano",
  "messages": [{ "role": "user", "content": "Quanto é 17 x 23?" }],
  "reasoning_effort": "medium",
  "stream": false
}

Exemplo de resposta sem streaming

json

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "reasoning_content": "17 x 23 = 17 x 20 + 17 x 3 = 340 + 51 = 391.",
        "content": "391"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "input_tokens": 18,
    "output_tokens": 42,
    "output_tokens_details": { "reasoning_tokens": 31 }
  },
  "performance": {
    "first_reasoning_ms": 210,
    "first_content_ms": 780,
    "ttfb_ms": 210
  }
}

Exemplo de chunk em streaming

data: {"choices":[{"delta":{"reasoning_content":"Vou calcular 17 x 23 passo a passo."}}]}
data: {"choices":[{"delta":{"reasoning_content":" 17 x 20 = 340."}}]}
data: {"choices":[{"delta":{"content":"391"}}]}
data: [DONE]

Campos relacionados:

usage.output_tokens_details.reasoning_tokens só existe quando o provedor reporta a contagem. Quando ele não informa, o campo não aparece; a plataforma nunca sintetiza um zero.
performance.first_reasoning_ms e performance.first_content_ms chegam no chunk final do stream: milissegundos até o primeiro chunk de raciocínio e até o primeiro de conteúdo. ttfb_ms continua significando "primeiro chunk de qualquer tipo", que com raciocínio ligado chega bem antes da resposta; first_content_ms diz quanto tempo a resposta de verdade demorou. Respostas sem streaming não trazem essa divisão.

Visibilidade do raciocínio

O card do modelo traz reasoning_visibility:

Valor	O que o provedor devolve
`full`	O texto do raciocínio
`tokens_only`	Apenas a contagem de tokens, sem texto
`none`	Nada

Valor ausente ou unprobed significa que o modelo ainda não foi testado para isso; summary é reservado. Veja o Bloco Pensando para o que aparece na conversa.

Cache de prompt

Provedores reutilizam um prefixo idêntico de prompt entre requisições e cobram menos por esses tokens. A plataforma normaliza a leitura em usage.input_tokens_details:

usage.input_tokens_details?: {
  cached_tokens?: number
  cache_write_tokens?: number
}

cached_tokens: tokens de entrada lidos do cache.
cache_write_tokens: tokens gravados no cache, quando o provedor cobra a gravação.

Regras:

O objeto só existe quando o provedor reporta cache. A plataforma nunca inventa um zero; um zero reportado é preservado como 0.
prompt_tokens (e input_tokens) continua incluindo os tokens cacheados por inteiro: o total não muda, só aparece a quebra.
Em streaming, o chunk final de usage carrega input_tokens_details.
O objeto pode trazer só a leitura ou só a gravação; o lado ausente é omitido, nunca preenchido com zero.

Exemplo de usage (sintético):

json

{
  "usage": {
    "input_tokens": 1200,
    "output_tokens": 80,
    "input_tokens_details": {
      "cached_tokens": 1024,
      "cache_write_tokens": 0
    }
  }
}

Neste exemplo o provedor reportou 1024 tokens lidos do cache e um zero explícito de gravação. O zero é um dado reportado, não um valor inventado.

Configuração

Ferramentas

Avançado

Implantando Agentes

Geração de Texto Avançada com Modelos de Linguagem Grandes (LLMs) ​

Playground Interativo ​

Seleção do Modelo ​

Configuração de Parâmetros ​

Criação de Prompts e Mensagens ​

Execução e Visualização ​

Geração de Código ​

Atalhos de Teclado ​

Gerenciamento de Conversas ​

Informações do Modelo ​

Consumo via API REST ​

Estrutura da Resposta ​

Streaming de Respostas ​

Quando Usar Streaming ​

Formato dos Chunks ​

Exemplos Completos ​

Streaming com Tool Calls ​

Chunk Final com Uso de Tokens ​

Tool Calling (Function Calling) ​

Definindo Ferramentas ​

Resposta com Tool Call ​

Enviando Resultado da Ferramenta ​

Modelos Disponíveis ​

Exemplo de Resposta ​

SDK da OpenAI ​

Tratamento de Erros ​

Códigos HTTP ​

Estrutura de Erro ​

Erros Comuns e Soluções ​

Exemplo de Tratamento ​

Guia de Parâmetros ​

Parâmetros Comuns ​

Dicas de Uso ​

Raciocínio (reasoning) ​

Exemplo de requisição ​

Exemplo de resposta sem streaming ​

Exemplo de chunk em streaming ​

Visibilidade do raciocínio ​

Cache de prompt ​

Geração de Texto Avançada com Modelos de Linguagem Grandes (LLMs)

Playground Interativo

Seleção do Modelo

Configuração de Parâmetros

Criação de Prompts e Mensagens

Execução e Visualização

Geração de Código

Atalhos de Teclado

Gerenciamento de Conversas

Informações do Modelo

Consumo via API REST

Estrutura da Resposta

Streaming de Respostas

Quando Usar Streaming

Formato dos Chunks

Exemplos Completos

Streaming com Tool Calls

Chunk Final com Uso de Tokens

Tool Calling (Function Calling)

Definindo Ferramentas

Resposta com Tool Call

Enviando Resultado da Ferramenta

Modelos Disponíveis

Exemplo de Resposta

SDK da OpenAI

Tratamento de Erros

Códigos HTTP

Estrutura de Erro

Erros Comuns e Soluções

Exemplo de Tratamento

Guia de Parâmetros

Parâmetros Comuns

Dicas de Uso

Raciocínio (reasoning)

Exemplo de requisição

Exemplo de resposta sem streaming

Exemplo de chunk em streaming

Visibilidade do raciocínio

Cache de prompt