Troque uma linha.
Use GPT, Claude, 3D e mídia.

Comece em 3 passos

Do zero à primeira resposta em poucos minutos. Escolha o provedor e a linguagem: os exemplos se ajustam.

1. 1

   Guarde a sua chave

   O nosso time entrega uma chave sk-ctp-... para cada aplicação. Ela é exibida uma única vez: salve em uma variável de ambiente, nunca no código.

   .env Copiar

   CENTOPEIA_API_KEY=sk-ctp-...

2. 2

   Instale o SDK oficial

   Nada de biblioteca nova: use exatamente o SDK que você já conhece.

   Terminal Copiar

   pip install openai anthropic replicate requests

3. 3

   Aponte para a CentopeIA e chame o modelo

   Informe a chave e o endereço base. A partir daqui, é a API de sempre do GPT.

   PythonNode.jscURL

   Copiar

   import os
   from openai import OpenAI
   
   client = OpenAI(
       api_key=os.environ["CENTOPEIA_API_KEY"],
       base_url="https://jukepix.centopeia.io/openai/v1",
   )
   
   resposta = client.chat.completions.create(
       model="gpt-5.5",
       max_completion_tokens=500,
       messages=[{"role": "user", "content": "Diga olá em uma frase."}],
   )
   print(resposta.choices[0].message.content)

Integre só com variáveis de ambiente

Os SDKs oficiais leem a chave e o endereço base direto do ambiente. Com estas quatro linhas, o seu projeto passa a usar a CentopeIA sem tocar no código.

# Os SDKs oficiais leem estas variáveis sozinhos
OPENAI_API_KEY=sk-ctp-...
OPENAI_BASE_URL=https://jukepix.centopeia.io/openai/v1

ANTHROPIC_API_KEY=sk-ctp-...
ANTHROPIC_BASE_URL=https://jukepix.centopeia.io/anthropic

from openai import OpenAI
from anthropic import Anthropic

gpt = OpenAI()        # já aponta para a CentopeIA
claude = Anthropic()  # idem

Ideal para projetos que já usam OpenAI ou Anthropic: troque as variáveis no deploy e pronto.

Usando os modelos da OpenAI

Endereço base: https://jukepix.centopeia.io/openai/v1. Todos os exemplos abaixo partem do cliente configurado no passo 3.

Responses API

A interface mais recente da OpenAI para texto e ferramentas.

resposta = client.responses.create(
    model="gpt-5.5",
    input="Explique o que é uma API em duas frases.",
    max_output_tokens=500,
)
print(resposta.output_text)

Respostas em tempo real (streaming)

Receba o texto à medida que é gerado. O último pedaço da transmissão traz o resumo de consumo, por isso confira se há conteúdo antes de ler.

stream = client.chat.completions.create(
    model="gpt-5.5",
    max_completion_tokens=500,
    messages=[{"role": "user", "content": "Conte uma história curta."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices:  # o último pedaço traz apenas o consumo
        print(chunk.choices[0].delta.content or "", end="", flush=True)

Embeddings

Gere vetores para busca semântica, recomendação e RAG.

resultado = client.embeddings.create(
    model="text-embedding-3-small",
    input=["CentopeIA", "IA em reais"],
)
vetor = resultado.data[0].embedding
print(len(vetor))

Geração de imagens

Crie imagens a partir de texto com o gpt-image-2.5-sunburst, o modelo de imagem mais detalhado da OpenAI. A imagem volta em base64, pronta para salvar.

import base64
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["CENTOPEIA_API_KEY"],
    base_url="https://jukepix.centopeia.io/openai/v1",
)

resposta = client.images.generate(
    model="gpt-image-2.5-sunburst",
    prompt=(
        "Suíte de luxo em um hotel 5 estrelas nos Alpes Suíços, "
        "janelas panorâmicas com vista para montanhas nevadas, "
        "lareira acesa, madeira nobre e pedra, luz quente ao entardecer, "
        "fotografia de arquitetura hiper-realista"
    ),
    size="1536x864",  # 16:9, largura e altura múltiplas de 16
    quality="high",   # low, medium, high, xhigh ou max
    n=1,
)

with open("suite_alpes.png", "wb") as arquivo:
    arquivo.write(base64.b64decode(resposta.data[0].b64_json))
print("Imagem salva em suite_alpes.png")

Modelos disponíveis

for modelo in client.models.list():
    print(modelo.id)

Usando os modelos da Anthropic

Endereço base: https://jukepix.centopeia.io/anthropic. O SDK completa o caminho /v1 sozinho; em chamadas diretas (cURL), use https://jukepix.centopeia.io/anthropic/v1.

Respostas em tempo real (streaming)

with client.messages.stream(
    model="claude-sonnet-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Conte uma história curta."}],
) as stream:
    for texto in stream.text_stream:
        print(texto, end="", flush=True)

Contagem de tokens

Saiba o tamanho de uma mensagem antes de enviá-la. Esta chamada não gera custo de modelo.

contagem = client.messages.count_tokens(
    model="claude-sonnet-5-5",
    messages=[{"role": "user", "content": "Quantos tokens tem esta frase?"}],
)
print(contagem.input_tokens)

Modelos 3D, imagens, vídeos e áudio

Tarefas que levam de segundos a minutos: você cria a tarefa, recebe um identificador e consulta até ficar pronta. A cobrança é pelo que a tarefa produz e sai do mesmo saldo da empresa. Tarefas que falham não são cobradas.

Modelo 3D a partir de uma imagem

Endereço base: https://jukepix.centopeia.io/meshy/openapi/v1, compatível com a API da Meshy. Envie a imagem como URL pública ou data URI. O resultado traz o modelo em GLB, FBX, OBJ e USDZ em model_urls, disponível por 3 dias. Para várias fotos do mesmo objeto, use multi-image-to-3d com image_urls.

import base64, os, sys, time
import requests

BASE = "https://jukepix.centopeia.io/meshy/openapi/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['CENTOPEIA_API_KEY']}"}

# Foto do objeto (JPG, PNG ou WebP, até 20 MB). Também aceita uma URL pública HTTPS.
with open("foto.png", "rb") as arquivo:
    imagem = "data:image/png;base64," + base64.b64encode(arquivo.read()).decode()

r = requests.post(f"{BASE}/image-to-3d", headers=HEADERS, json={
    "image_url": imagem,
    "ai_model": "meshy-6-lite",   # rascunho rápido: 5 créditos
    "should_texture": False,      # True gera textura (mais créditos)
})
if not r.ok:
    sys.exit(f"Erro {r.status_code} ({r.json().get('code')}): {r.json().get('message')}")
tarefa = r.json()["result"]

while True:
    t = requests.get(f"{BASE}/image-to-3d/{tarefa}", headers=HEADERS).json()
    print(t.get("status"), t.get("progress"), "%")
    if t.get("status") in ("SUCCEEDED", "FAILED", "CANCELED"):
        break
    time.sleep(5)

if t["status"] == "SUCCEEDED":
    print("Modelo GLB:", t["model_urls"]["glb"])  # baixe em até 3 dias
else:
    print("A tarefa não foi concluída:", t.get("task_error", {}).get("message"))

Imagem, vídeo, áudio e modelos abertos

Use o SDK oficial do Replicate com o endereço https://jukepix.centopeia.io/replicate/v1. Os modelos liberados para sua empresa, com preços em reais, ficam na aba Modelos do painel. Envie arquivos de entrada como URL ou data URI; webhooks não são aceitos, então consulte a predição ou use o cabeçalho Prefer: wait.

import os
import urllib.request
import replicate

client = replicate.Client(
    api_token=os.environ["CENTOPEIA_API_KEY"],
    base_url="https://jukepix.centopeia.io/replicate",
)

links = client.run(
    "black-forest-labs/flux-schnell",
    input={"prompt": "Uma centopeia verde lendo um livro, ilustração"},
    use_file_output=False,  # devolve os links dos arquivos gerados
)
urllib.request.urlretrieve(links[0], "imagem.webp")  # o link expira: guarde o arquivo
print("Imagem salva em imagem.webp")

Tarefas longas: vídeo e transcrição

Crie a predição, guarde o id e espere o resultado. Os arquivos gerados ficam disponíveis por 1 hora: baixe e guarde no seu armazenamento.

import os
import replicate

client = replicate.Client(
    api_token=os.environ["CENTOPEIA_API_KEY"],
    base_url="https://jukepix.centopeia.io/replicate",
)

# Tarefas longas (vídeo, transcrição): crie, guarde o id e espere o resultado.
predicao = client.models.predictions.create(
    model="bytedance/seedance-1-lite",
    input={"prompt": "Drone sobrevoando uma floresta ao amanhecer", "duration": 5},
)
predicao.wait()
print(predicao.status, predicao.output)  # links dos arquivos: baixe em até 1 hora

Modelos disponíveis

Use o identificador do modelo na chamada. Os parâmetros de input são os mesmos da página de cada modelo no Replicate. Os liberados para sua empresa, com preço em reais, aparecem na aba Modelos do painel.

Funciona com os frameworks que você usa

Qualquer ferramenta que aceite um endereço base personalizado para OpenAI ou Anthropic funciona com a CentopeIA.

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

gpt = ChatOpenAI(
    model="gpt-5.5",
    api_key=CHAVE_CENTOPEIA,
    base_url="https://jukepix.centopeia.io/openai/v1",
    max_tokens=500,
)
claude = ChatAnthropic(
    model="claude-sonnet-5-5",
    api_key=CHAVE_CENTOPEIA,
    base_url="https://jukepix.centopeia.io/anthropic",
    max_tokens=1024,
)
print(claude.invoke("Olá!").content)

import { createOpenAI } from "@ai-sdk/openai";
import { createAnthropic } from "@ai-sdk/anthropic";
import { generateText } from "ai";

const openai = createOpenAI({
  apiKey: process.env.CENTOPEIA_API_KEY,
  baseURL: "https://jukepix.centopeia.io/openai/v1",
});
const anthropic = createAnthropic({
  apiKey: process.env.CENTOPEIA_API_KEY,
  baseURL: "https://jukepix.centopeia.io/anthropic/v1",
});

const { text } = await generateText({
  model: anthropic("claude-sonnet-5-5"),
  maxOutputTokens: 500,
  prompt: "Olá!",
});

Servidor MCP (Model Context Protocol): conecte Claude, Cursor, VS Code, ChatGPT e outros projetos

O servidor MCP nativo da CentopeIA implementa a especificação oficial Model Context Protocol (transporte HTTP/SSE). Com ele, assistentes de código e chat acessam os modelos da plataforma (texto, imagem, embeddings, vídeo, áudio e 3D), consultam preços em tempo real, gerenciam chaves, acompanham o saldo da empresa e operam com as permissões do seu papel. Você também pode conectar seus próprios agentes, pipelines ou projetos externos usando qualquer cliente MCP oficial.

https://jukepix.centopeia.io/mcp

claude mcp add --transport http centopeia https://jukepix.centopeia.io/mcp

{
  "mcpServers": {
    "centopeia": {
      "url": "https://jukepix.centopeia.io/mcp"
    }
  }
}

{
  "servers": {
    "centopeia": {
      "type": "http",
      "url": "https://jukepix.centopeia.io/mcp"
    }
  }
}

Para scripts, agentes customizados ou ferramentas sem login pelo navegador, gere um token pessoal sk-ctp-mcp-... no painel e envie no cabeçalho Authorization: Bearer <token>.

• Ações que não têm volta, recargas Pix e chamadas a modelos acima de R$ 1,00 pedem confirmação em duas etapas: o assistente mostra um resumo e só executa depois que você concordar.
• Chaves novas e senhas provisórias chegam por um link seguro de uso único, válido por 10 minutos, nunca pelo chat.
• O uso de modelos pelos assistentes respeita um teto diário por pessoa (padrão R$ 5,00), ajustável por Owner e Admin, além dos limites da chave escolhida.
• Tudo o que cada assistente faz fica registrado na aba Assistentes de IA.

Endereços, autenticação e endpoints

Recursos que armazenam dados no provedor, como arquivos, batches e respostas salvas, não estão disponíveis. Assim, nada do que você envia fica guardado fora da sua aplicação. Em mídia e 3D, cada tarefa só pode ser consultada pela empresa que a criou, e os resultados expiram (1 hora para mídia, 3 dias para 3D).

Chaves com limite de gasto

Se a sua chave ou empresa tem um limite mensal, cada chamada é conferida antes de chegar ao modelo. Para isso, alguns cuidados simples:

• Informe sempre o limite de saída. max_completion_tokens no Chat Completions, max_output_tokens na Responses API e max_tokens no Claude.
• Ferramentas do tipo função. Function calling funciona normalmente; ferramentas hospedadas pelo provedor não.
• Conversas enviadas a cada chamada. Mande o histórico em messages ou input, em vez de previous_response_id ou conversation.
• Imagens com tamanho e qualidade. Use size e quality explícitos e até uma imagem por chamada em streaming.

• Mídia e 3D cobram pelo que foi produzido. O custo máximo estimado é reservado ao criar a tarefa. Tarefas que falham não são cobradas. Sem saldo para a reserva, a criação retorna 402.

Quando algo dá errado

Os erros seguem o mesmo formato de cada provedor, então os SDKs lançam as exceções que você já trata hoje.

import openai

try:
    resposta = client.chat.completions.create(...)
except openai.AuthenticationError:
    print("Confira a chave CentopeIA configurada.")
except openai.PermissionDeniedError as erro:
    print(erro.message)  # ex.: saldo de créditos ou limite da chave atingido
except openai.RateLimitError:
    print("Muitas chamadas ao mesmo tempo. Tente de novo em instantes.")

Boas práticas

Catálogo atualizado

Modelos publicados, parâmetros e exemplos compartilham a mesma revisão. Seu painel mostra os modelos habilitados para sua empresa.

Saldo e conversão

Recargas permanecem em reais. Novas chamadas usam a referência USDT/BRL e o preço vigentes na admissão. A cotação fica preservada até a conclusão, inclusive em tarefas demoradas. Consulte o extrato no painel.