URL da API Kimi Code: Configuração da URL base para clientes OpenAI OpenAI

A URL e o que cada parte significa

Se você está procurando a kimi code api url, talvez esteja procurando o endereço do serviço próprio do Kimi. Para isso, use a documentação do fornecedor, já que não posso garantir. Este site oferece algo diferente: uma API compatível com OpenAI hospedada na frente de um único modelo de pesos abertos, operada por um provedor independente. Seu endereço é:

Copyhttps://api.kimicode.cc/v1

Essa string é a URL base. É a parte compartilhada por todas as requisições. O SDK adiciona o restante. Quando você chama chat.completions.create, a biblioteca OpenAI envia um POST para https://api.kimicode.cc/v1/chat/completions. A lista de modelos está em https://api.kimicode.cc/v1/models e usa GET.

Esses dois são os únicos métodos que esta API oferece: POST /v1/chat/completions e GET /v1/models. Se você esperava endpoints de imagem, áudio ou embedding, eles não existem aqui. É uma API de texto.

Três configurações importam, e nada mais precisa ser alterado no seu código OpenAI existente: a URL base, a chave de API e o ID do modelo uncensored.

Por que a URL base é a única configuração

Clientes estilo OpenAI são construídos em torno de uma ideia: o formato da requisição é fixo e o host é uma configuração. A biblioteca tem um host padrão que aponta para o fornecedor original. Quando você o substitui por outra URL base, o mesmo corpo de requisição vai para outro lugar. Nada nos seus prompts, arrays de mensagens ou análise de resposta precisa mudar.

Isso também explica por que a migração de outro provedor compatível com OpenAI geralmente envolve três edições: a URL base, a chave e o nome do modelo. Os campos na resposta, como choices, message, finish_reason e usage, têm os mesmos nomes, então o código que os lê continua funcionando.

Isso também explica os erros estranhos que as pessoas encontram. Se uma ferramenta pedir uma "URL do servidor" e você colar apenas o host, o caminho faltará. Se uma ferramenta pedir um "endpoint completo" e você colar a URL base, a requisição irá para o lugar errado. Quando uma tela de configuração não está clara, tente a URL base primeiro e leia o código de status retornado. O quickstart na documentação percorre a mesma migração com mais um exemplo.

Variáveis de ambiente para ferramentas que você não pode editar

Muitas ferramentas de linha de comando e frameworks criam um cliente OpenAI sem permitir que você toque no construtor. Eles geralmente leem as variáveis de ambiente padrão, então defini-las é suficiente:

Copyexport OPENAI_BASE_URL="https://api.kimicode.cc/v1"
export OPENAI_API_KEY="YOUR_KEY"

Algumas ferramentas mais antigas procuram por OPENAI_API_BASE em vez disso, então se uma ignorar o primeiro nome, tente o segundo. Após defini-las, inicie a ferramenta na mesma sessão de shell, já que variáveis definidas em outra janela de terminal não são compartilhadas.

A ferramenta ainda precisará de um nome de modelo. Se ela codificar um modelo hospedado, procure uma flag ou linha de configuração que o defina e use uncensored. Se não puder ser alterada, a ferramenta não é compatível e um pequeno script como os acima é um caminho melhor.

Obtenha uma chave primeiro

As requisições são autenticadas com um cabeçalho no formato Authorization: Bearer YOUR_KEY. Cada SDK oficial constrói esse cabeçalho para você a partir do argumento api_key. Você pode criar a chave após fazer login com Google ou com um e-mail e senha.

Novas contas podem reivindicar $0,50 de crédito de teste com um clique na página da chave de API. Não precisa de cartão e dura 7 dias. Isso é suficiente para executar todos os exemplos abaixo várias vezes. Chaves de teste permitem 2 requisições simultâneas e 60 requisições por minuto, então execute os exemplos um de cada vez.

Armazene a chave em uma variável de ambiente em vez de em arquivos de código. Uma chave confirmada em um repositório público será encontrada e usada por outra pessoa em poucas horas, e o crédito que ela contém é seu.

Primeira requisição em curl

Curl é a maneira mais rápida de provar que a URL funciona, porque remove todas as bibliotecas da equação. Se essa chamada tiver sucesso, qualquer problema que você encontrar depois está na configuração do seu cliente.

Copyexport KIMICODE_KEY="YOUR_KEY"

curl https://api.kimicode.cc/v1/models   -H "Authorization: Bearer $KIMICODE_KEY"

curl https://api.kimicode.cc/v1/chat/completions   -H "Authorization: Bearer $KIMICODE_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "messages": [
      {"role": "user", "content": "Say hello in five words."}
    ]
  }'

A primeira chamada retorna a lista de modelos, que deve incluir uncensored. A segunda retorna um objeto padrão de conclusão de chat. Veja os cabeçalhos de resposta com curl -i e você verá X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency. Mantenha o ID da requisição se entrar em contato com suporte sobre uma chamada específica.

Python com o SDK OpenAI

Instale a biblioteca com pip install openai, depois altere dois argumentos no construtor do cliente.

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.kimicode.cc/v1",
    api_key=os.environ["KIMICODE_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain what a base URL is in two sentences."},
    ],
    temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage)

Parâmetros como temperature, top_p, stop, seed e as penalidades de frequência e presença são repassados ao modelo. O valor max_tokens é opcional. Sem ele, a conclusão pode usar o que restar da janela de 100.000 tokens, que é o prompt e a conclusão combinados.

O SDK também lê duas variáveis de ambiente se você não passar argumentos: OPENAI_BASE_URL e OPENAI_API_KEY. Isso é útil para ferramentas que você não pode editar. Defina ambas, inicie a ferramenta e ela falará com esta API.

Node, streaming e modo JSON

A configuração do Node espelha Python. Instale com npm install openai.

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.kimicode.cc/v1",
  apiKey: process.env.KIMICODE_KEY,
});

// Streaming over SSE
const stream = await client.chat.completions.create({
  model: "uncensored",
  stream: true,
  messages: [{ role: "user", content: "Write a four-line poem about routers." }],
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

// JSON mode
const json = await client.chat.completions.create({
  model: "uncensored",
  response_format: { type: "json_object" },
  messages: [
    { role: "system", content: "Reply with a JSON object only." },
    { role: "user", content: "Give me keys name and port for a local dev server." },
  ],
});
console.log(JSON.parse(json.choices[0].message.content));

O streaming usa eventos enviados pelo servidor e o uso é relatado no final do fluxo. Uma solicitação em streaming mantém seu slot de concorrência até que o fluxo termine, então um cliente que abre um fluxo e nunca o lê bloqueará um slot. Com o modo JSON, ainda diga ao modelo no prompt para responder em JSON. A flag restringe o formato de saída, mas uma instrução clara fornece nomes de campo melhores.

Chamada de ferramentas

As ferramentas usam o formato padrão do OpenAI: uma lista tools, um tool_choice opcional e os resultados das ferramentas enviados de volta como mensagens com role: "tool". Ao fazer streaming, os tool_calls chegam em partes nos chunks.

Copyimport json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.kimicode.cc/v1", api_key=os.environ["KIMICODE_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_port",
        "description": "Look up the port of a named local service",
        "parameters": {
            "type": "object",
            "properties": {"service": {"type": "string"}},
            "required": ["service"],
        },
    },
}]

messages = [{"role": "user", "content": "Which port does the api service use?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]

messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": call.id,
    "content": json.dumps({"service": "api", "port": 8080}),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)

Trate os argumentos do modelo como entrada não confiável. Valide-os antes de executar qualquer coisa. O modelo pode pular uma chamada de função ou chamá-la com um campo errado, como qualquer modelo pode, então mantenha um caminho de fallback no seu loop.

Quando a URL falha

A maioria das falhas se enquadra em uma lista curta.

• 404 Not Found. O caminho está errado. Causas comuns: a URL base foi definida para https://api.kimicode.cc sem /v1, ou para https://api.kimicode.cc/v1/chat/completions, então o cliente anexa o caminho duas vezes. Use exatamente a URL base acima.
• 401 Unauthorized. A chave está ausente, tem um espaço ou nova linha estranhos, ou o cabeçalho não é um token Bearer. Imprima o comprimento da variável para verificar.
• 429 com código rate_limited. Você passou do limite por minuto: 300 requisições para uma chave completa, 60 para uma chave de teste.
• 429 com código concurrency. Muitas requisições ao mesmo tempo: 8 para uma chave completa, 2 para uma chave de teste.
• 429 com um cabeçalho Retry-After: 5. Sobrecarga temporária. Aguarde cinco segundos e tente novamente.
• Requisição muito grande. O limite do corpo é 8 MB, e o prompt mais a conclusão devem caber em 100.000 tokens.

Um loop de retry que respeita o Retry-After e aplica backoff nos outros dois códigos lida com quase tudo isso. O custo por chamada é baixo; a página de preços tem as taxas por token, e o guia de início rápido mostra os passos de migração de outro provedor estilo OpenAI.

Retentativas e hábitos de produção

Depois que a primeira chamada funcionar, adicione um adaptador de retry antes de enviar para produção. Respeite o cabeçalho Retry-After quando presente e aplique backoff com um atraso aleatório curto caso contrário.

Copyimport os, time, random
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.kimicode.cc/v1", api_key=os.environ["KIMICODE_KEY"])

def ask(messages, tries=5):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as err:
            retry_after = 5
            if getattr(err, "response", None) is not None:
                retry_after = int(err.response.headers.get("retry-after", 5))
            time.sleep(retry_after + random.random())
    raise RuntimeError("still rate limited after retries")

Limite sua própria concorrência para corresponder à sua chave: um pool de threads de 8 para uma chave completa, 2 para uma chave de teste. Isso impede o erro concurrency antes que ele comece, e também mantém você dentro do limite de 300 requisições por minuto quando cada chamada leva mais de alguns segundos.

Finalmente, lembre-se de que você paga por token. Registre o objeto usage para cada chamada e observe o cabeçalho X-Balance-USD. A $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída, uma rodada típica de chat custa uma fração de centavo, mas loops e históricos longos somam, e o log diz onde.

Mais guias

• Preços da API Kimi Code vs Tokens Pay-as-You-Go
• Kimicode no Cursor Alternative: Configuração de Endpoint Personalizado
• API Groq: Mitos vs Fatos para LLMs sem censura