PT ▾
Obter chave de API

kimiapikey.comGuia

Integração da chave de API Kimi com SDKs OpenAI e LangChain

Integrar esta API a um app significa alterar dois valores no código que você provavelmente já tem: a URL base e a chave. Este guia mostra a alteração para os SDKs da OpenAI, LangChain e LiteLLM, depois cobre tentativas e limites para uso em produção.

Atualizado

Blocos isométricos conectados por linhas brilhantes a um hub central, mostrando apps integrando-se a uma API

Pontos principais

  • Todo cliente precisa dos mesmos três valores: URL base https://api.kimiapikey.com/v1, sua chave e o modelo uncensored.
  • Armazene-os em variáveis de ambiente para que você possa trocar de provedor sem editar o código.
  • Trate respostas 429 separadamente: rate_limited, concurrency e uma sobrecarga temporária com Retry-After: 5.
  • Uma chave financiada permite 8 requisições simultâneas e 300 por minuto; uma chave de teste permite 2 e 60.

O que realmente muda no seu código

Uma integração da API kimi parece um projeto, mas para este endpoint é uma alteração de configuração. O serviço implementa o formato de chat completions da OpenAI, então qualquer biblioteca de clientes que permita definir uma URL base e uma chave funcionará. Não há SDK personalizado para instalar nem formato de requisição novo para aprender.

ConfiguraçãoValor
URL basehttps://api.kimiapikey.com/v1
AutenticaçãoA chave do seu painel, enviada como Authorization: Bearer
Modelouncensored
EndpointsPOST /v1/chat/completions, GET /v1/models

Dois pontos economizam tempo. Primeiro, este é um modelo de texto por trás de um endpoint: sem rota de embeddings, sem geração de imagem, sem áudio. Se seu app chama esses recursos, mantenha outro provedor para eles e roteie apenas o chat aqui. Segundo, esta não é a API oficial da Kimi ou de qualquer outro fornecedor; é um provedor independente executando um modelo de pesos abertos, então nomes de modelos de outras plataformas não serão resolvidos. O guia da chave de API Kimi aborda essa diferença com mais detalhes.

Obtenha sua chave na página chave de API. Contas novas podem resgatar $0.50 de crédito de teste lá, o que é mais do que suficiente para tudo abaixo.

Configuração e migração de um app existente

As bibliotecas oficiais do OpenAI para Python e Node leem OPENAI_API_KEY e OPENAI_BASE_URL do ambiente quando você não as passa explicitamente. Isso torna a integração de menor esforço uma alteração de shell:

export OPENAI_BASE_URL="https://api.kimiapikey.com/v1"
export OPENAI_API_KEY="YOUR_KEY"

O código existente que cria um cliente OpenAI() agora fala com este endpoint. Você ainda precisa alterar o argumento model para uncensored. Coloque o nome do modelo em uma variável também, por exemplo LLM_MODEL, para que um ambiente de teste e um ambiente de produção possam diferir sem editar o código.

O hábito vale o minuto que leva. Quando a URL base, a chave e o modelo estão na configuração, tentar outro provedor compatível com OpenAI é uma alteração de implantação, e reverter é a mesma alteração ao contrário.

A maioria das equipes não começa a partir de um arquivo em branco. Elas têm um aplicativo que já chama uma API estilo OpenAI e querem que ele chame esta. A migração consiste principalmente em buscar três strings.

  1. Encontre onde o cliente é criado e altere a URL base.
  2. Encontre todos os argumentos model= e substitua o nome antigo por uncensored.
  3. Procure recursos que seu código usa e que esta API não oferece, como embeddings, geração de imagem ou áudio. Essas chamadas devem permanecer com outro provedor ou ser removidas.

Depois compare o comportamento, não apenas a sintaxe. Um modelo diferente tem uma voz diferente, um comprimento padrão diferente e hábitos diferentes de formatação. Execute seus prompts de teste existentes, leia as respostas lado a lado e ajuste o prompt do sistema onde o tom se desviou. Texto de prompt que funcionou contornando peculiaridades de outro modelo às vezes não faz nada aqui, e às vezes piora as coisas, então remova soluções alternativas antigas uma por uma e observe o que muda.

Verifique também os parâmetros que você passa. Temperature, top_p, stop, seed e as penalidades são passadas, então elas se comportam como você espera. Campos que pertencem a outros fornecedores, ou a recursos que esta API não possui, não farão nada útil. Mantenha o corpo da requisição pequeno e padrão. O limite do corpo é 8 MB, o que só importa se você incorporar documentos grandes diretamente.

Python: síncrono, streaming e assíncrono

A forma explícita, que não depende de variáveis de ambiente:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.kimiapikey.com/v1",
    api_key="YOUR_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You answer in plain English."},
        {"role": "user", "content": "Explain idempotency in two sentences."},
    ],
    temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Para streaming, defina stream=True e leia os chunks conforme chegam. O stream é entregue via server-sent events, e o uso é reportado no final.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a limerick about retries."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Para um serviço que lida com muitos usuários, use o cliente assíncrono e limite sua própria paralelização para nunca exceder o limite de concorrência da chave. Um semáforo é a maneira mais simples:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.kimiapikey.com/v1",
    api_key="YOUR_KEY",
)
gate = asyncio.Semaphore(8)

async def ask(prompt: str) -> str:
    async with gate:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Give one fact about the number {n}." for n in range(20)]
    answers = await asyncio.gather(*(ask(p) for p in prompts))
    print(len(answers), "answers")

asyncio.run(main())

Defina o semáforo para 2 enquanto estiver na chave de teste, e 8 em uma chave financiada.

Node e TypeScript

A biblioteca Node usa as mesmas duas opções com nomes ligeiramente diferentes:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.kimiapikey.com/v1",
  apiKey: process.env.API_KEY,
});

const completion = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Name three HTTP status codes." }],
});

console.log(completion.choices[0].message.content);

O streaming com o mesmo cliente usa stream: true e um iterador assíncrono sobre o resultado. Se você usar um framework front-end que envolve a biblioteca OpenAI, como um kit de UI de chat, procure sua opção de URL base e defina-a da mesma forma. Mantenha a chave no servidor. Uma chave colocada no código do navegador pode ser copiada por qualquer pessoa que abra as ferramentas de desenvolvedor, e o crédito por trás dela é dinheiro real.

LangChain e LiteLLM

Frameworks que envolvem o cliente OpenAI geralmente expõem os mesmos dois parâmetros. No LangChain para Python, a classe de modelo de chat OpenAI os aceita diretamente:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.kimiapikey.com/v1",
    api_key="YOUR_KEY",
    temperature=0.5,
)

reply = llm.invoke("Summarize what a message queue does in one sentence.")
print(reply.content)

A partir daí, cadeias, modelos de prompt e analisadores de saída funcionam como fazem com qualquer modelo de chat. Se você vincular ferramentas, a API suporta chamada de funções com tools e tool_choice, e os resultados das ferramentas voltam para o modelo como mensagens role: "tool", que é o que o framework produz.

LiteLLM é útil quando você quer uma convenção de chamada única entre vários provedores. Prefixe o modelo com openai/ e passe a URL base como api_base:

import litellm

resp = litellm.completion(
    model="openai/uncensored",
    api_base="https://api.kimiapikey.com/v1",
    api_key="YOUR_KEY",
    messages=[{"role": "user", "content": "Say hello in French."}],
)
print(resp.choices[0].message.content)

Para dados estruturados, passe response_format={"type": "json_object"} e diga no prompt que você quer JSON. Sempre analise o resultado de forma defensiva, porque o modo JSON pede JSON válido, mas seu schema ainda é apenas uma solicitação no prompt.

Limites, tentativas e tratamento de erros

Uma chave financiada permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 e 60. O corpo pode ter até 8 MB, e a janela é de 100.000 tokens para prompt e conclusão juntos. Quando você excede um limite, a API responde com HTTP 429 e um destes:

  • rate_limited: muitas requisições por minuto. Aguarde alguns segundos.
  • concurrency: muitas requisições em execução ao mesmo tempo. Aguarde uma terminar. Uma solicitação streaming mantém seu slot até o stream terminar, então um consumidor lento conta contra você.
  • Um 429 com Retry-After: 5: sobrecarga temporária. Aguarde cinco segundos e tente novamente.

Um pequeno wrapper de retry que honra o header lida com os três:

import time
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.kimiapikey.com/v1", api_key="YOUR_KEY", max_retries=0)

def chat(messages, tries=4):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = int(e.response.headers.get("retry-after", 2 ** attempt))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

Requisições falhas ou recusadas não são cobradas, então fazer retry não tem penalidade de cobrança. Registre o header de resposta X-Request-Id com cada chamada; é a maneira mais rápida de apontar para uma solicitação se algo parecer errado. X-Balance-USD diz quanto crédito resta, o que você pode alimentar em um alerta. A documentação lista todos os headers de resposta.

Chamada de funções através de um framework

Frameworks de agent dependem de chamada de funções, então vale a pena um teste curto antes de construir sobre isso. Esta API aceita tools e tool_choice, retorna tool_calls quando o modelo quer executar uma função, e espera o resultado como uma mensagem role: "tool" que referencia o ID da chamada. O streaming funciona com tools, com a chamada chegando em fragmentos que o SDK monta para você.

Um bom primeiro teste é um agent de uma ferramenta com uma função cujo resultado você pode verificar a olho, como uma calculadora ou uma consulta em um pequeno dicionário. Execute-o dez vezes. Se o modelo escolher a ferramenta e preencher seus argumentos corretamente cada vez, você pode adicionar uma segunda ferramenta. Se às vezes ele responder de memória em vez de chamar a função, torne a descrição da ferramenta mais específica, ou defina tool_choice para forçar a chamada para essa etapa. Modelos diferem na confiabilidade com que conduzem longas cadeias de chamadas, então mantenha as cadeias curtas e adicione um limite de etapa a qualquer loop para que uma execução confusa não gire para sempre e gaste crédito.

Uma lista de verificação curta de pré-lançamento

  1. Execute uma solicitação via curl ou SDK e confirme que o bloco de uso está presente.
  2. Teste o streaming com o cliente que será usado em produção, incluindo o que acontece quando o usuário fecha a página durante o streaming.
  3. Limite sua própria concorrência abaixo do limite da chave.
  4. Defina max_tokens onde respostas curtas são esperadas, e limpe o histórico de chat antes que ele cresça além do que você quer pagar.
  5. Mantenha a chave na configuração do lado do servidor e faça rotação se ela aparecer em um log.
  6. Verifique o custo no tráfego real. A $0.15 por 1M de entrada e $0.50 por 1M de saída, uma requisição com 3.000 tokens de entrada e 700 de saída custa $0.0008, então 10.000 delas custam cerca de $8. Os detalhes estão na página de preços.

Prompts enviados para a API não são usados para treinamento. A única regra de conteúdo que nunca muda é o limite rígido de conteúdo sexual envolvendo menores de idade; o modelo é ajustado para responder sem recusas para uso adulto legal, então apps que servem o público ainda devem adicionar sua própria moderação e verificações de idade onde a lei ou seus usuários esperarem.

Perguntas frequentes

O modelo é o mesmo que o Kimi oficial da Moonshot?
Não, hospedamos um modelo de pesos abertos que é ajustado para ser sem censura. Não é GPT, Claude, Gemini, Grok, DeepSeek ou qualquer outro modelo de fornecedor. É um modelo distinto executado em nossos próprios servidores.

Você treina com meus dados?
Não. Seus prompts e completions não são usados para treinamento. Valorizamos privacidade e transparência, então seus dados permanecem seus.

Quais são os limites de requisições?
Você está limitado a 300 requisições por minuto por chave. O tamanho máximo do corpo da requisição é 8 MB. Esses limites são projetados para garantir desempenho estável para todos os usuários.

Qual é a política de conteúdo?
O modelo é sem censura em relação a temas adultos, controversos e criativos. No entanto, bloqueamos conteúdo sexual envolvendo menores. Este é um limite rígido que sempre se aplica, independentemente do seu nível de assinatura.

Perguntas e respostas

Preciso de um SDK especial?

Não. As bibliotecas padrão do OpenAI para Python e Node funcionam após você definir a URL base como https://api.kimiapikey.com/v1 e usar sua chave. LangChain e LiteLLM funcionam da mesma forma.

Qual nome de modelo meu código deve usar?

Use uncensored. É o único identificador do modelo que a API serve, e GET /v1/models o lista.

Como evito erros 429?

Limite suas requisições simultâneas a 8 em uma chave financiada ou 2 em uma chave de teste, e tente novamente após o atraso Retry-After quando a API solicitar.

Suporta chamada de funções e modo JSON?

Sim. Use tools e tool_choice para chamadas de funções, e response_format com type json_object para saída JSON. O streaming também funciona.

Posso usar embeddings ou geração de imagem pela mesma chave?

Não. A API é apenas para chat de texto, sem endpoints de embeddings, imagem, áudio ou vídeo.

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 APILer a documentação