Português

English

Português

English

Tema Escuro

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 cruciais como Temperatura (aleatoriedade), Max Tokens (tamanho da resposta), Top P (amostragem nucleus), Frequency Penalty (penalidade por frequência) e Presence Penalty (penalidade por presença). Veja o Guia Parâmetros para detalhes sobre cada parâmetro.
  • Apenas os controles relevantes e suportados pelo modelo escolhido são exibidos, garantindo uma configuração precisa.

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.

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, veja Como usar a API.

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));

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.

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));

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.

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.

Guia Parâmetros ​

O ajuste fino dos parâmetros de geração é essencial para moldar as respostas do LLM de acordo com suas necessidades. Compreender o impacto de cada parâmetro permite otimizar a qualidade, criatividade e relevância das saídas.

  • temperature (Temperatura):

  • O que é: Este parâmetro controla o nível de aleatoriedade ou "criatividade" da saída do modelo. Valores mais altos (ex: 1.0) tornam a saída mais aleatória e diversificada, enquanto valores mais baixos (ex: 0.2) a tornam mais determinística, focada e previsível.

  • Faixa Comum: 0.0 a 2.0. Alguns modelos podem ter faixas diferentes.

  • Casos de Uso: * 0.0 – 0.3: Ideal para tarefas que exigem alta precisão, respostas factuais e consistência, como extração de informações, respostas a perguntas diretas (QA), tradução factual ou geração de código. * 0.7 – 1.3: Recomendado para tarefas criativas, como escrita de histórias, brainstorming de ideias, resumo de textos com um toque de originalidade ou geração de diálogos mais naturais e variados. * > 1.3: Pode levar a respostas muito incoerentes, "nonsense" ou excessivamente criativas. Use com cautela, geralmente para exploração de extrema criatividade, geração de texto abstrato ou para "quebrar" padrões repetitivos.

  • max_tokens (Máximo de Tokens):

  • O que é: Define o número máximo de tokens (unidades de texto, que podem ser palavras, partes de palavras ou caracteres) que o modelo pode gerar na resposta.

  • Importância: Crucial para controlar o comprimento da saída e gerenciar custos (já que muitos modelos cobram por token).

  • Quando usar: Ajuste conforme a extensão da resposta desejada. * Respostas curtas e concisas (ex: classificação, resposta sim/não): Use um valor baixo (ex: 5-50). * Respostas detalhadas, artigos, histórias: Aumente o valor (ex: 500-2000), respeitando o limite de contexto do modelo.

  • Atenção: O total de tokens (tokens do prompt de entrada + max_tokens da saída) não pode exceder o limite máximo de contexto do modelo (ex: 4096, 8192, 128000 tokens, dependendo do modelo).

  • frequency_penalty (Penalidade de Frequência):

  • O que é: Penaliza tokens que já apareceram na resposta, proporcionalmente à frequência com que surgem. Valores positivos diminuem a probabilidade de o modelo repetir as mesmas palavras ou frases excessivamente.

  • Faixa Comum: -2.0 a 2.0.

  • Quando usar: * Valores positivos (ex: 0.1 a 1.0): Útil para reduzir a monotonia e a repetição literal, tornando o texto mais diversificado e interessante. * Valores negativos: Podem aumentar a repetição de certos termos, o que raramente é desejável, mas pode ser usado experimentalmente para enfatizar palavras-chave.

  • presence_penalty (Penalidade de Presença):

  • O que é: Penaliza tokens que já apareceram na resposta, independentemente da frequência. Uma vez que um token aparece, ele recebe uma penalidade fixa se reaparecer. Valores positivos incentivam o modelo a introduzir novos tópicos ou conceitos.

  • Faixa Comum: -2.0 a 2.0.

  • Quando usar: * Valores positivos (ex: 0.1 a 1.0): Útil para evitar que o modelo se fixe em um único tópico ou conjunto de ideias, encorajando a exploração de conceitos diferentes dentro da mesma resposta. Ajuda a aumentar a amplitude temática.

  • top_p (Nucleus Sampling):

  • O que é: Uma técnica de amostragem que controla a diversidade da saída. O modelo considera apenas o menor conjunto de tokens cuja probabilidade cumulativa excede o valor top_p. A partir desse "núcleo" de tokens, o modelo escolhe aleatoriamente o próximo token.

  • Faixa: 0.0 a 1.0. Um valor de 1.0 significa que todos os tokens são considerados.

  • Quando usar: * Valores mais baixos (ex: 0.1 a 0.5): Restringem a escolha a tokens de alta probabilidade, resultando em respostas mais focadas, conservadoras e previsíveis. * Valores mais altos (ex: 0.9 a 1.0, sendo 0.9 um valor comum): Permitem uma gama maior de tokens, levando a respostas mais criativas, diversificadas, mas potencialmente menos coerentes ou mais surpreendentes.

  • Relação com temperature: top_p é uma alternativa à temperature para controlar a aleatoriedade. Geralmente, recomenda-se ajustar um ou outro, e não ambos drasticamente ao mesmo tempo. Por exemplo, usar temperature=1.0 e top_p=0.2 pode gerar resultados inesperados. Muitos preferem definir temperature para 1.0 e controlar a aleatoriedade apenas com top_p, ou vice-versa.

  • top_k (Top-K Sampling):

  • O que é: Restringe a seleção do próximo token aos k tokens mais prováveis em cada etapa da geração. O modelo então escolhe aleatoriamente (geralmente ponderado por suas probabilidades) entre esses k tokens.

  • Faixa: Inteiro positivo (ex: 1, 10, 50).

  • Quando usar: * Valores baixos (ex: 1 a 10): Tornam a saída mais previsível e menos diversificada, focando nos tokens mais óbvios. top_k=1 resulta em uma amostragem puramente "gananciosa" (greedy), escolhendo sempre o token mais provável, o que pode levar a respostas repetitivas ou sem brilho. * Valores altos (ex: 50 ou mais): Permitem mais diversidade, aproximando-se do efeito de top_p alto.

  • Comparação com top_p: top_p é frequentemente preferido sobre top_k porque top_p se adapta dinamicamente ao número de tokens a considerar com base na distribuição de probabilidade, enquanto top_k usa um número fixo. Se a distribuição de probabilidade for muito "achatada" (muitos tokens com probabilidade similar), top_k pode ser muito restritivo ou muito permissivo.

A melhor maneira de dominar esses parâmetros é através da experimentação prática. Utilize o Playground de Geração de Texto para testar diferentes combinações e observar seus efeitos em tempo real. Isso permitirá que você desenvolva uma intuição sobre como ajustá-los para alcançar os resultados ideais para cada aplicação específica.