ES ▾
Obtener clave de API

kimiapikey.comGuía

Integración de la clave de API de Kimi con SDK de OpenAI y LangChain

Integrar esta API en una app implica cambiar dos valores en el código que probablemente ya tengas: la URL base y la clave. Esta guía muestra el cambio para los SDK de OpenAI, LangChain y LiteLLM, y luego cubre los reintentos y límites para uso en producción.

Actualizado

Bloques isométricos conectados por líneas brillantes a un centro, mostrando apps integrándose con una API

Puntos clave

  • Cada cliente necesita los mismos tres valores: URL base https://api.kimiapikey.com/v1, tu clave y el modelo uncensored.
  • Almacénalos en variables de entorno para que puedas cambiar de proveedor sin editar el código.
  • Maneja las respuestas 429 por separado: rate_limited, concurrency y una sobrecarga temporal con Retry-After: 5.
  • Una clave con fondos permite 8 peticiones concurrentes y 300 por minuto; una clave de prueba permite 2 y 60.

Qué cambia realmente en tu código

Una integración de clave de API de Kimi suena como un proyecto, pero para este endpoint es un cambio de configuración. El servicio implementa el formato de chat completions de OpenAI, por lo que cualquier biblioteca de clientes que te permita configurar una URL base y una clave funcionará. No hay SDK personalizado que instalar ni una nueva forma de petición que aprender.

AjusteValor
URL basehttps://api.kimiapikey.com/v1
AutenticaciónLa clave de tu panel, enviada como Authorization: Bearer
Modelouncensored
EndpointsPOST /v1/chat/completions, GET /v1/models

Dos puntos ahorran tiempo. Primero, este es un modelo de texto detrás de un endpoint: sin ruta de embeddings, sin generación de imágenes, sin audio. Si tu app llama a esas funciones, mantén otro proveedor para ellas y enruta solo el chat aquí. Segundo, esta no es la API oficial de Kimi ni de ningún otro proveedor; es un proveedor independiente que ejecuta un modelo de pesos abiertos, por lo que los nombres de modelo de otras plataformas no se resolverán. El explicador de clave de API de Kimi cubre esa diferencia con más detalle.

Obtén tu clave en la página de claves de API. Las cuentas nuevas pueden reclamar $0,50 de crédito de prueba allí, que es suficiente para todo lo siguiente.

Configuración y migración de una app existente

Las bibliotecas oficiales de OpenAI para Python y Node leen OPENAI_API_KEY y OPENAI_BASE_URL del entorno cuando no las pasas explícitamente. Eso hace que la integración de menor esfuerzo sea un cambio de shell:

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

El código existente que crea un cliente OpenAI() básico ahora se conecta a este endpoint. Aun así, tienes que cambiar el argumento model a uncensored. También pon el nombre del modelo en una variable, por ejemplo LLM_MODEL, para que un entorno de pruebas y uno de producción puedan diferir sin editar el código.

El hábito vale el minuto que toma. Cuando la URL base, la clave y el modelo viven en la configuración, probar otro proveedor compatible con OpenAI es un cambio de despliegue, y revertirlo es el mismo cambio al revés.

La mayoría de los equipos no empiezan desde un archivo en blanco. Tienen una app que ya llama a una API estilo OpenAI y quieren que llame a esta. La migración es principalmente una búsqueda de tres cadenas.

  1. Busca dónde se construye el cliente y cambia la URL base.
  2. Busca cada argumento model= y reemplaza el nombre antiguo con uncensored.
  3. Busca las funciones que usa tu código que esta API no proporciona, como embeddings, generación de imágenes o audio. Esas llamadas deben permanecer con otro proveedor o eliminarse.

Luego compara el comportamiento, no solo la sintaxis. Un modelo diferente tiene una voz distinta, una longitud predeterminada distinta y hábitos diferentes con el formato. Ejecuta tus prompts de prueba existentes, lee las respuestas lado a lado y ajusta el prompt del sistema donde el tono se haya desviado. El texto del prompt que funcionaba con las peculiaridades de otro modelo a veces no funciona aquí, y a veces empeora las cosas, así que elimina los parches antiguos uno por uno y observa qué cambia.

Verifica también los parámetros que pasas. La temperatura, top_p, stop, seed y las penalizaciones se pasan directamente, por lo que se comportan como esperas. Los campos que pertenecen a otros proveedores o a funciones que esta API no ofrece no tendrán ningún efecto útil. Mantén el cuerpo de la petición pequeño y estándar. El límite del cuerpo es de 8 MB, lo cual solo importa si incrustas documentos grandes directamente.

Python: sincrónico, streaming y asíncrono

La forma explícita, que no depende de variables de entorno:

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, establece stream=True y lee los fragmentos a medida que llegan. La transmisión se entrega mediante eventos enviados por el servidor, y el uso se informa al 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 un servicio que maneja muchos usuarios, usa el cliente asíncrono y limita tu propia paralelización para que nunca excedas el límite de concurrencia de la clave. Un semáforo es la forma más simple:

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())

Establece el semáforo en 2 mientras estés con la clave de prueba, y en 8 con una clave con fondos.

Node y TypeScript

La biblioteca de Node toma las mismas dos opciones con nombres ligeramente 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);

El streaming con el mismo cliente usa stream: true y un iterador asíncrono sobre el resultado. Si usas un framework de frontend que envuelve la biblioteca de OpenAI, como un kit de herramientas de interfaz de chat, busca su opción de URL base y establécela de la misma manera. Mantén la clave en el servidor. Una clave colocada en el código del navegador puede ser copiada por cualquiera que abra las herramientas de desarrollo, y el crédito detrás de ella es dinero real.

LangChain y LiteLLM

Los frameworks que envuelven el cliente de OpenAI suelen exponer los mismos dos parámetros. En LangChain para Python, la clase de modelo de chat de OpenAI los acepta directamente:

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)

Desde allí, cadenas, plantillas de prompt y analizadores de salida funcionan como lo hacen con cualquier modelo de chat. Si vinculas herramientas, la API admite llamadas a funciones con tools y tool_choice, y los resultados de las herramientas vuelven al modelo como mensajes role: "tool", que es lo que produce el framework.

LiteLLM es útil cuando quieres una convención de llamada única entre varios proveedores. Prefija el modelo con openai/ y pasa la 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 datos estructurados, pasa response_format={"type": "json_object"} y di en el prompt que quieres JSON. Siempre analiza el resultado de forma defensiva, porque el modo JSON pide JSON válido pero tu esquema sigue siendo solo una petición en el prompt.

Límites, reintentos y manejo de errores

Una clave con fondos permite 8 peticiones concurrentes y 300 peticiones por minuto. Una clave de prueba permite 2 y 60. El cuerpo puede tener hasta 8 MB, y la ventana es de 100 000 tokens para el prompt y la generación juntos. Cuando excedes un límite, la API responde con HTTP 429 y uno de estos:

  • rate_limited: demasiadas peticiones por minuto. Retrocede durante varios segundos.
  • concurrency: demasiadas peticiones ejecutándose a la vez. Espera a que termine una. Una petición en streaming mantiene su espacio hasta que termina el stream, por lo que un consumidor lento cuenta contra ti.
  • Un 429 con Retry-After: 5: sobrecarga temporal. Espera cinco segundos y vuelve a intentar.

Un pequeño envoltorio de reintentos que honra la cabecera maneja los tres:

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")

Las peticiones fallidas o rechazadas no se cobran, por lo que reintentar no tiene penalización de facturación. Registra la cabecera de respuesta X-Request-Id con cada llamada; es la forma más rápida de señalar una petición si algo parece incorrecto. X-Balance-USD te dice cuánto crédito queda, que puedes alimentar a una alerta. La documentación lista todas las cabeceras de respuesta.

Llamadas a funciones a través de un framework

Los frameworks de agentes dependen de las llamadas a funciones, por lo que vale la pena una prueba corta antes de construir sobre ello. Esta API acepta tools y tool_choice, devuelve tool_calls cuando el modelo quiere ejecutar una función, y espera el resultado como un mensaje role: "tool" que hace referencia al ID de llamada. El streaming funciona con herramientas, con la llamada llegando en fragmentos que el SDK ensambla para ti.

Una buena primera prueba es un agente de una sola herramienta con una función cuyo resultado puedes verificar a ojo, como una calculadora o una búsqueda en un diccionario pequeño. Ejecútalo diez veces. Si el modelo selecciona la herramienta y llena sus argumentos correctamente cada vez, puedes añadir una segunda herramienta. Si a veces responde desde la memoria en lugar de llamar a la función, haz la descripción de la herramienta más específica, o establece tool_choice para forzar la llamada para ese paso. Los modelos difieren en cuán confiablemente impulsan largas cadenas de llamadas, así que mantén las cadenas cortas y añade un límite de pasos a cualquier bucle para que una ejecución confundida no gire para siempre y gaste crédito.

Una lista de verificación breve antes del lanzamiento

  1. Ejecuta una petición a través de curl o el SDK y confirma que el bloque de uso está presente.
  2. Prueba el streaming con el cliente que se usará en producción, incluyendo lo que sucede cuando el usuario cierra la página a mitad del stream.
  3. Limita tu propia concurrencia por debajo del límite de la clave.
  4. Establece max_tokens donde se esperan respuestas cortas, y recorta el historial de chat antes de que crezca más allá de lo que quieres pagar.
  5. Mantén la clave en la configuración del lado del servidor y rótala si aparece en un registro.
  6. Verifica el costo con tráfico real. A $0,15 por 1M de entrada y $0,50 por 1M de salida, una petición con 3.000 tokens de entrada y 700 de salida cuesta $0,0008, por lo que 10.000 de ellos cuestan unos $8. Los detalles están en la página de precios.

Los prompts enviados a la API no se usan para entrenamiento. La única regla de contenido que nunca cambia es el límite estricto sobre contenido sexual que involucre menores; el modelo está ajustado, por lo demás, para responder sin rechazos para uso adulto lícito, por lo que las apps que sirven al público aún deben añadir su propia moderación y verificaciones de edad donde la ley o tus usuarios las esperen.

Preguntas frecuentes

¿Es el modelo el mismo que el Kimi oficial de Moonshot?
No, alojamos un modelo de pesos abiertos que está ajustado para ser sin censura. No es GPT, Claude, Gemini, Grok, DeepSeek ni ningún otro modelo de proveedor. Es un modelo distinto ejecutado en nuestros propios servidores.

¿Entrenan con mis datos?
No. Tus prompts y completados no se utilizan para el entrenamiento. Valoramos la privacidad y la transparencia, por lo que tus datos siguen siendo tuyos.

¿Cuáles son los límites de peticiones?
Estás limitado a 300 peticiones por minuto por clave. El tamaño máximo del cuerpo de la petición es de 8 MB. Estos límites están diseñados para garantizar un rendimiento estable para todos los usuarios.

¿Cuál es la política de contenido?
El modelo es sin censura respecto a temas adultos, controversiales y creativos. Sin embargo, bloqueamos contenido sexual que involucre menores. Este es un límite estricto que siempre se aplica, independientemente de tu nivel de suscripción.

Preguntas y respuestas

¿Necesito un SDK especial?

No. Las bibliotecas estándar de OpenAI para Python y Node funcionan tras configurar la URL base en https://api.kimiapikey.com/v1 y usar tu clave. LangChain y LiteLLM funcionan de la misma manera.

¿Qué nombre de modelo debe usar mi código?

Usa uncensored. Es el único ID del modelo que sirve la API, y GET /v1/models lo lista.

¿Cómo evito los errores 429?

Limita tus peticiones simultáneas a 8 en una clave con fondos o a 2 en una clave de prueba, y reintenta después del retraso Retry-After cuando la API lo solicite.

¿Admite llamadas a funciones y modo JSON?

Sí. Usa tools y tool_choice para llamadas a funciones, y response_format con type json_object para salida JSON. El streaming también funciona.

¿Puedo usar embeddings o generación de imágenes con la misma clave?

No. La API es solo de chat de texto, sin endpoints de embeddings, imagen, audio o video.

Tu clave está a un formulario de distancia

Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.

Obtener clave de APILeer la documentación