Fluxo de API LLM em Python: Configuração passo a passo
Aponte o SDK OpenAI para uma nova URL base, use o ID do modelo uncensored e adicione retentativas, execuções paralelas e chamadas de ferramentas uma camada por vez.
Atualizado

Pontos principais
- Instale openai, defina base_url para https://api.veo3apis.com/v1 e use o modelo uncensored.
- Trate 429 aguardando Retry-After; requisições falhas não são cobradas.
- Dimensione seu pool de threads para a chave: 8 threads para uma chave completa, 2 para a chave de teste.
- Leia X-Balance-USD nos cabeçalhos da resposta para rastrear o gasto por execução.
O resumo
Para construir um script de fluxo de API LLM em Python, instale o SDK oficial da OpenAI, defina a URL base para https://api.veo3apis.com/v1, use sua chave como chave de API e chame o modelo uncensored. Nada mais muda. O serviço é compatível com OpenAI, então todos os padrões que você já conhece do SDK funcionam: chamadas de chat simples, streaming, modo JSON e chamada de ferramentas.
Este artigo constrói um pequeno fluxo de trabalho em camadas. Você começa com uma única chamada, depois adiciona configuração de variáveis de ambiente, um wrapper de retentativa, um executor paralelo, uma chamada de ferramenta e rastreamento de saldo. Cada camada é curta e você pode parar em qualquer uma que atenda às suas necessidades.
O modelo é um open-weight model executado por um provedor independente. Não é a API oficial de nenhum grande fornecedor e não é um roteador, então há apenas um ID de modelo para lembrar. Ele processa apenas texto. Não há geração de imagem, áudio ou vídeo, nem embeddings nem fine-tuning.
Instale o SDK e faça a primeira chamada
Você precisa do Python 3.9 ou mais recente. Instale o SDK:
pip install openai
Crie uma chave na página chave de API após entrar com Google ou com e-mail e senha. A página também oferece uma reivindicação com um clique de $0,50 de crédito de teste, válido por 7 dias, um por pessoa, sem necessidade de cartão. Em seguida, execute a chamada mínima possível:
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "List three uses for a hosted text API."},
],
)
print(resp.choices[0].message.content)
print(resp.usage)
Se isso imprimir texto e um objeto de uso, autenticação, roteamento e o ID do modelo estão corretos. O SDK envia sua chave como Authorization: Bearer, e a requisição vai para POST /v1/chat/completions. Você pode verificar quais IDs de modelo sua chave vê com client.models.list(), que chama GET /v1/models.
Uma versão curl pura é útil quando você depura a partir de um servidor sem Python:
curl https://api.veo3apis.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello."}]}'
Mantenha a configuração em um único cliente
Codificar uma chave em um script é a maneira mais rápida de vazá-la para um repositório. Leia ambos os valores do ambiente e crie o cliente em um único lugar para que todas as etapas do fluxo de trabalho o compartilhem.
import os
from openai import OpenAI
client = OpenAI(
base_url=os.environ.get("LLM_BASE_URL", "https://api.veo3apis.com/v1"),
api_key=os.environ["LLM_API_KEY"],
max_retries=0,
timeout=120,
)
MODEL = "uncensored"
def ask(system: str, user: str, **kwargs) -> str:
resp = client.chat.completions.create(
model=MODEL,
messages=[
{"role": "system", "content": system},
{"role": "user", "content": user},
],
**kwargs,
)
return resp.choices[0].message.content
Duas escolhas aqui são deliberadas. max_retries=0 desativa as tentativas automáticas do SDK para que a lógica de nova tentativa na próxima seção seja a única, o que facilita o raciocínio sobre o comportamento. O tempo limite de 120 segundos deixa margem para conclusões longas; a janela de contexto é de 100.000 tokens para prompt mais conclusão, e uma resposta grande leva tempo para ser transmitida. Parâmetros de amostragem como temperature, top_p, stop, seed e as penalidades passam por **kwargs como de costume.
Retente os erros corretos
Todo fluxo de trabalho real atinge limites de taxa em algum momento. Uma chave completa permite 300 requisições por minuto e 8 simultâneas. Uma chave de teste permite 60 por minuto e 2 simultâneas. Exceder qualquer um deles faz a API retornar HTTP 429. O código de erro indica qual limite você atingiu: rate_limited para requisições por minuto, concurrency para muitas simultâneas. Durante sobrecarga temporária, a API também envia 429 com um cabeçalho Retry-After: 5.
Os três casos têm a mesma cura: aguarde e tente novamente. Este wrapper honra o cabeçalho e faz backoff quando ele está ausente.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import time
from openai import RateLimitError, APIConnectionError, APIStatusError
def call_with_retry(messages, tries=5, **kwargs):
delay = 2
for attempt in range(tries):
try:
return client.chat.completions.create(
model="uncensored", messages=messages, **kwargs
)
except RateLimitError as err:
wait = err.response.headers.get("Retry-After")
time.sleep(int(wait) if wait else delay)
delay = min(delay * 2, 30)
except APIConnectionError:
time.sleep(delay)
delay = min(delay * 2, 30)
except APIStatusError as err:
if err.status_code < 500:
raise
time.sleep(delay)
delay = min(delay * 2, 30)
raise RuntimeError("request failed after retries")
Retente apenas erros que podem mudar. Um 400 significa que sua requisição está malformada e enviá-la novamente falhará da mesma forma, então o wrapper re-levanta qualquer erro de cliente exceto 429. Requisições falhas ou recusadas não são cobradas, então retentar não custa nada a mais.
Execute várias entradas em paralelo
Para um loop sobre muitas entradas, um pool de threads é suficiente. O cliente SDK é seguro para ser compartilhado entre threads. Dimensione o pool para sua chave: 8 threads para uma chave completa, 2 para a chave de teste.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import time
from concurrent.futures import ThreadPoolExecutor
from openai import RateLimitError
def summarize(text: str) -> str:
for _ in range(5):
try:
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "Summarize the text in two sentences."},
{"role": "user", "content": text},
],
max_tokens=150,
)
return resp.choices[0].message.content.strip()
except RateLimitError as err:
time.sleep(int(err.response.headers.get("Retry-After", "5")))
return ""
documents = ["First long text...", "Second long text...", "Third long text..."]
with ThreadPoolExecutor(max_workers=8) as pool:
summaries = list(pool.map(summarize, documents))
for s in summaries:
print(s)
O tamanho do pool não é igual à taxa de requisições. Oito threads, cada um finalizando uma chamada em meio segundo, gerariam 960 requisições por minuto, bem acima de 300. Se suas chamadas forem rápidas, adicione um pequeno sleep ou um limitador de bucket de tokens para permanecer abaixo do limite por minuto. Se suas chamadas forem lentas, a concorrência é o limite que você encontrará primeiro. Requisições com streaming mantêm sua posição até que o streaming termine.
Saída estruturada e chamadas de ferramentas
Dois recursos transformam uma chamada de chat em uma etapa de fluxo de trabalho que outro código pode confiar. O modo JSON garante saída analisável. A chamada de ferramentas permite que o modelo peça ao seu código para fazer algo e depois use a resposta.
Modo JSON
Defina response_format para um objeto JSON e descreva as chaves no prompt.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON: {\"title\": string, \"tags\": [string]}"},
{"role": "user", "content": "A short post about nightly backups."},
],
)
post = json.loads(resp.choices[0].message.content)
print(post["title"], post["tags"])
Chamada de funções
Declare ferramentas com tools, force opcionalmente uma escolha com tool_choice, execute a função você mesmo e envie o resultado de volta como uma mensagem com role: "tool".
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import json
tools = [{
"type": "function",
"function": {
"name": "word_count",
"description": "Count the words in a piece of text.",
"parameters": {
"type": "object",
"properties": {"text": {"type": "string"}},
"required": ["text"],
},
},
}]
messages = [{"role": "user", "content": "How many words are in 'the quick brown fox'?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"words": len(args["text"].split())}
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)
Sempre verifique se tool_calls está presente antes de lê-lo. O modelo pode responder diretamente e seu código deve lidar com ambos os resultados.
Encadeie etapas em um pipeline
Fluxos de trabalho reais raramente param em uma única chamada. Um formato comum é rascunho, revisão, reescrita: a primeira chamada produz algo, a segunda critica contra uma lista de verificação e a terceira aplica a crítica. Cada etapa é uma requisição separada com sua própria mensagem de sistema, o que mantém as instruções curtas e facilita localizar falhas.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
def step(system: str, user: str, temperature: float = 0.7) -> str:
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": system},
{"role": "user", "content": user},
],
temperature=temperature,
max_tokens=800,
)
return resp.choices[0].message.content.strip()
topic = "a changelog entry for a new export feature"
draft = step("Write the requested text in under 120 words.", topic)
review = step(
"List at most three concrete problems with this text: vague wording, missing detail, wrong tone.",
draft,
temperature=0.2,
)
final = step(
"Rewrite the text so it fixes every listed problem. Reply with the text only.",
"TEXT:\n" + draft + "\n\nPROBLEMS:\n" + review,
)
print(final)
Observe a temperatura mais baixa na etapa de revisão. A crítica deve ser consistente de execução para execução, enquanto o rascunho se beneficia de alguma variedade. Se você executar o pipeline sobre muitas entradas, coloque toda a função de três etapas dentro do worker do pool de threads da seção anterior, para que cada worker possua um item do início ao fim e o teto de 8 requisições seja respeitado.
Mantenha os resultados intermediários. Quando o texto final está errado, o rascunho e a revisão indicam qual etapa falhou, e você pode corrigir uma única mensagem de sistema em vez de reescrever todo o pipeline. Escrever cada etapa em um arquivo JSON-lines com a entrada, as três saídas e os IDs de requisição torna isso fácil e fornece um ponto de retomada se o processo parar no meio.
Rastreie saldo e IDs de requisição
Cada resposta traz cabeçalhos que valem a pena registrar: X-Request-Id identifica a chamada se você entrar em contato com o suporte, X-Balance-USD mostra o que resta do seu crédito, e os dois cabeçalhos X-RateLimit-Limit reportam os limites de requisição e concorrência para sua chave. O SDK oculta cabeçalhos por padrão; use o wrapper de resposta bruta para lê-los.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Reply with the single word ready."}],
max_tokens=10,
)
print("request id:", raw.headers.get("X-Request-Id"))
print("balance usd:", raw.headers.get("X-Balance-USD"))
print("req limit:", raw.headers.get("X-RateLimit-Limit-Requests"))
print("concurrency limit:", raw.headers.get("X-RateLimit-Limit-Concurrency"))
resp = raw.parse()
print(resp.choices[0].message.content)
O preço é $0,15 por milhão de tokens de entrada e $0,50 por milhão de tokens de saída, então uma chamada com 1.000 tokens de entrada e 500 tokens de saída custa $0,00015 + $0,00025 = $0,0004. Um fluxo de trabalho que executa 5.000 dessas chamadas gasta $2,00. Imprima o saldo no início e no fim de uma execução e você saberá quanto cada lote custa sem nenhuma ferramenta extra. Para taxas e bônus de recarga, consulte a página de preços; para cada parâmetro suportado, leia a documentação da API.
Mais um hábito que vale a pena adotar: mantenha os prompts fora dos seus logs a menos que você precise deles. Prompts enviados para esta API não são usados para treinamento, mas seus próprios arquivos de log são sua responsabilidade.
Solução de problemas de uma nova configuração
A maioria dos problemas de primeira execução vem de uma lista curta de causas.
- A chamada trava ou gera erro na conexão. Verifique a URL base. Ela deve terminar em
/v1e o SDK anexa/chat/completionssozinho. Um caminho duplicado é o erro comum. - Um erro de autenticação. A chave está faltando, truncada ou tem um espaço ou nova linha estranhos de uma cópia e cola. Imprima seu comprimento, não a chave em si, e compare com o que a página da chave mostra.
- Modelo não encontrado. O ID do modelo é
uncensored, em minúsculas. Chame o endpoint de modelos para ver exatamente o que sua chave pode usar. - 429 constante em um script pequeno. Você pode estar na chave de teste, que permite 2 requisições simultâneas e 60 por minuto. Reduza o pool para 2 trabalhadores, ou recarregue para obter uma chave completa.
- Respostas cortadas. Um
max_tokensbaixo encerra a resposta cedo. Aumente-o ou remova-o e deixe a conclusão usar o resto da janela. - Requisição muito grande. O limite do corpo é 8 MB e a janela de tokens é de 100.000 tokens para prompt e conclusão juntos. Divida entradas grandes em pedaços e processe-as como chamadas separadas.
Quando algo parece errado no lado do serviço, envie o valor de X-Request-Id para o contato no site. Um ID de requisição permite que o operador encontre sua chamada exata, o que é muito mais útil do que uma descrição do que você viu.
Mais guias
Perguntas e respostas
Preciso de um SDK especial?
Não. O SDK Python oficial da OpenAI funciona assim que você define a URL base e sua chave.
Qual ID de modelo eu uso?
Use uncensored. Você pode listar os IDs disponíveis com GET /v1/models.
Quantas requisições podem ser executadas em paralelo?
Uma chave completa permite 8 requisições simultâneas e 300 por minuto. Uma chave de teste permite 2 e 60.
O streaming funciona no SDK Python?
Sim. Passe stream=True e itere sobre os chunks. O consumo é reportado no final do streaming.
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.