PT ▾
Obter chave de API

API LLM em Python: Chat, Streaming e Chamadas de Função

Este guia de API LLM em Python usa o SDK oficial OpenAI apontado para um endpoint compatível com OpenAI. Você obtém uma primeira chamada, streaming, uma chamada de função e lógica de retry em código que pode ser colado e executado.

Atualizado

Fita de blocos de código fluindo de um laptop para balões de chat, ilustrando uma chamada de API LLM em Python
01

Pontos principais

  • Instale openai, defina a URL base e a chave, e use o ID do modelo uncensored.
  • Faça streaming com stream=True e encerre o stream antecipadamente para liberar o slot de concorrência.
  • Chamadas de função retornam argumentos que você deve analisar e validar antes de executar qualquer coisa.
  • Trate 429 com Retry-After e limite requisições simultâneas a 8 com uma chave completa.

Instale o SDK e faça a primeira chamada

Se você quer uma configuração de API LLM em Python que funcione em cinco minutos, o SDK OpenAI é tudo que você precisa. A API é compatível com OpenAI, então você mantém o cliente oficial e altera dois valores: a URL base e a chave. O ID do modelo é uncensored.

Primeiro, obtenha uma chave. Crie sua conta na página de chave de API, resgate o crédito de teste com um clique e copie a chave. Em seguida, instale o cliente e mantenha a chave fora do seu código-fonte.

pip install openai
export LLM_API_KEY="your-key-here"

Agora o programa útil mais simples:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.llmmodelsapi.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
)

print(resp.choices[0].message.content)
print(resp.usage)

Essa é a integração completa. resp.usage fornece as contagens de tokens de prompt e conclusão, que você pode multiplicar pelas tarifas na página de preços ($0,15 por 1M de tokens de entrada, $0,50 por 1M de tokens de saída) para ver quanto cada requisição custa. O mesmo endpoint também aceita POST /v1/responses se seu código já usa esse formato, e GET /v1/models lista o ID do modelo.

Como a requisição e a resposta se parecem

O cliente OpenAI esconde os detalhes HTTP, mas ajuda conhecê-los quando algo dá errado. O SDK envia um POST para /v1/chat/completions com um token bearer. Você pode reproduzir a chamada com curl e comparar.

curl https://api.llmmodelsapi.com/v1/chat/completions \
  -H "Authorization: Bearer $LLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello"}]}'

Parâmetros úteis que são passados diretamente para o modelo: temperature, top_p, stop, seed e as penalidades de frequência e presença. max_tokens é opcional. Se você não o definir, a conclusão pode usar o que restar da janela de 100.000 tokens (prompt e conclusão juntos).

Dois cabeçalhos de resposta valem a pena registrar em toda chamada: X-Request-Id para perguntas de suporte, e X-Balance-USD para seu crédito restante. Com o SDK Python, você os acessa através da resposta bruta:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Ping"}],
    max_tokens=20,
)
print(raw.headers.get("X-Request-Id"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

Streaming de tokens conforme chegam

Para interfaces de chat e qualquer coisa que uma pessoa está esperando, faça streaming da resposta. Defina stream=True e itere sobre os chunks. A API os envia via server-sent events, e o último chunk carrega o uso quando você solicita.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a mechanical keyboard."}],
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage)

Dois detalhes confundem as pessoas. Primeiro, alguns blocos têm uma lista choices vazia (o bloco de uso, por exemplo), então faça uma verificação antes de acessar o índice. Segundo, uma requisição em streaming mantém sua vaga de concorrência até o fim do streaming. Se você abrir um streaming e abandoná-lo sem fechar, essa vaga fica ocupada e chamadas posteriores podem falhar com um erro de concurrency. Use o streaming em um bloco with ou chame stream.close() se parar de ler antecipadamente.

Se um streaming for interrompido com uma mensagem pouco clara, o artigo sobre como usar um modelo LLM neste site cobre o básico de leitura de erros e retentativas.

Uma chamada de função contra o modelo

Chamadas de função permitem que o modelo peça ao seu código para executar uma função e depois continuar com o resultado. O fluxo tem três etapas: enviar as definições de função, executar o que o modelo solicitar e enviar a saída de volta com role: "tool".

import json

def get_order_status(order_id: str) -> str:
    # Replace with a real lookup
    return json.dumps({"order_id": order_id, "status": "shipped"})

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its ID",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

msg = first.choices[0].message
if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": get_order_status(**args),
        })
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

Sempre analise call.function.arguments como JSON dentro de um bloco try no código real, porque modelos ocasionalmente produzem argumentos que não correspondem ao seu esquema. Valide antes de executar qualquer coisa com efeitos colaterais. Para loops de agente mais longos, consulte o guia para usar esta API para agentes.

Chamadas de função também podem ser transmitidas: os argumentos chegam em pedaços em delta.tool_calls, e você os concatena por índice até o streaming terminar.

Modo JSON para saída estruturada

Quando você precisa de saída legível por máquina em vez de texto corrido, defina response_format para um objeto JSON. Descreva a forma desejada no prompt, já que o modo JSON garante sintaxe JSON válida, mas não o seu esquema específico.

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"sentiment\": \"positive|negative|neutral\", \"confidence\": 0-1}"},
        {"role": "user", "content": "The setup took ten minutes and everything just worked."},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)
data = json.loads(resp.choices[0].message.content)
print(data["sentiment"])

Use temperature=0 para extração e classificação para que execuções repetidas forneçam os mesmos rótulos. Adicione seed se quiser fixar ainda mais a amostragem, e ainda valide o resultado analisado contra seu próprio esquema.

Limites, retentativas e tratamento de erros

Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 simultâneas e 60 por minuto. Ultrapassar qualquer um desses limites retorna HTTP 429. O código de erro indica qual limite você atingiu: rate_limited para requisições por minuto e concurrency para muitas ao mesmo tempo. Em sobrecarga temporária, você também recebe um 429 com um cabeçalho Retry-After: 5.

O SDK da OpenAI já tenta novamente algumas falhas, mas você deve definir a política sozinho:

import os
import time
from openai import OpenAI, RateLimitError, APIConnectionError

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key=os.environ["LLM_API_KEY"], max_retries=0, timeout=120)

def ask(messages, tries=5):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("gave up after retries")

Se você distribuir o trabalho com threads ou asyncio, limite o conjunto a 8 (ou 2 com uma chave de teste) usando um semáforo. Isso mantém você abaixo do limite de concorrência sem depender de novas tentativas. Requisições falhas ou recusadas não são cobradas, então repetir não custa extra para as tentativas falhas.

Verifique seu saldo via código com GET /v1/balance, ou leia X-Balance-USD de qualquer resposta. A lista completa de parâmetros está na documentação da API.

Quanto custa executar estes exemplos

Os exemplos acima são pequenos. Uma chamada com 300 tokens de prompt e 200 tokens de conclusão custa 300 x $0.15 / 1M mais 200 x $0.50 / 1M, o que dá $0.000045 mais $0.0001, ou $0.000145. Aproximadamente 6.900 chamadas assim cabem em um dólar. O crédito de teste de $0.50 cobre cerca de 3.400 delas, e é válido por 7 dias sem necessidade de detalhes de pagamento.

Após o teste, recarregue qualquer valor inteiro de $20 a $500, com um bônus de 5% a partir de $50, 10% a partir de $100 e 15% a partir de $200. O crédito não expira e não há assinatura. Os prompts não são usados para treinamento.

02

Perguntas e respostas

Posso usar a biblioteca oficial OpenAI em Python?

Sim. Defina base_url para o endereço da API e api_key para sua chave, depois chame chat.completions.create com o modelo uncensored.

A API suporta Python assíncrono?

Sim, use AsyncOpenAI com a mesma URL base e chave. Mantenha as tarefas simultâneas em no máximo 8 com uma chave completa, ou 2 com uma chave de teste.

Como vejo quantos tokens uma chamada usou?

Leia resp.usage em uma chamada normal, ou passe stream_options com include_usage em uma chamada com streaming. Multiplique por $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída.

Qual o tamanho máximo do meu prompt?

A janela de contexto é de 100.000 tokens, incluindo prompt e conclusão. O corpo da requisição é limitado a 8 MB.

Sua chave está a um formulário de distância

Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.

Obter chave de API