URL de la API de Kimi Code: Configuración de la URL base para clientes de OpenAI clientes OpenAI

La URL y lo que significa cada parte

Si estás buscando la kimi code api url, es posible que busques la dirección del servicio propio de Kimi. Para eso, usa la documentación del proveedor, ya que no puedo avalarla. Este sitio ejecuta algo diferente: una API compatible con OpenAI alojada frente a un único modelo de pesos abiertos, gestionada por un proveedor independiente. Su dirección es:

Copyhttps://api.kimicode.cc/v1

Esa cadena es la URL base. Es la parte que comparten todas las peticiones. El SDK añade el resto. Cuando llamas a chat.completions.create, la biblioteca OpenAI envía un POST a https://api.kimicode.cc/v1/chat/completions. La lista de modelos está en https://api.kimicode.cc/v1/models y requiere un GET.

Estos dos son los únicos métodos que sirve esta API: POST /v1/chat/completions y GET /v1/models. Si esperabas endpoints de imagen, audio o embeddings, no existen aquí. Es una API de texto.

Tres ajustes importan, y nada más tiene que cambiar en tu código OpenAI existente: la URL base, la clave de API y el ID del modelo uncensored.

Por qué una URL base es el único ajuste

Los clientes estilo OpenAI se construyen alrededor de una idea: el formato de la petición es fijo y el host es un ajuste. La biblioteca tiene un host predeterminado que apunta al proveedor original. Cuando lo reemplazas con otra URL base, el mismo cuerpo de petición va a otro lugar. No tienes que cambiar nada en tus prompts, listas de mensajes ni análisis de respuestas.

Eso también explica por qué una migración desde otro proveedor compatible con OpenAI suele ser solo tres ediciones: la URL base, la clave y el nombre del modelo. Los campos en la respuesta, como choices, message, finish_reason y usage, tienen los mismos nombres, así que el código que los lee sigue funcionando.

También explica los errores extraños que la gente encuentra. Si una herramienta pide una "URL del servidor" y pegas solo el host, falta la ruta. Si una herramienta pide un "endpoint completo" y pegas la URL base, la petición va al lugar equivocado. Cuando una pantalla de configuración no está clara, prueba primero con la URL base y lee el código de estado que devuelve. El inicio rápido en la documentación recorre la misma migración con un ejemplo más.

Variables de entorno para herramientas que no puedes editar

Muchas herramientas de línea de comandos y frameworks crean un cliente OpenAI sin dejarte tocar el constructor. Suelen leer las variables de entorno estándar, así que establecerlas es suficiente:

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

Algunas herramientas antiguas buscan OPENAI_API_BASE en su lugar, así que si una ignora el primer nombre, prueba con el segundo. Después de establecerlas, inicia la herramienta en la misma sesión de shell, ya que las variables establecidas en otra ventana de terminal no se comparten.

La herramienta aún necesitará un nombre de modelo. Si codifica un modelo alojado, busca una bandera o línea de configuración que lo establezca y usa uncensored. Si no se puede cambiar, la herramienta no es adecuada y un pequeño script como los anteriores es un mejor camino.

Obtén una clave primero

Las peticiones se autentican con una cabecera de la forma Authorization: Bearer YOUR_KEY. Cada SDK oficial construye esa cabecera por ti a partir del argumento api_key. Puedes crear la clave después de iniciar sesión con Google o con un correo electrónico y contraseña.

Las cuentas nuevas pueden reclamar $0.50 de crédito de prueba con un solo clic en la página de clave de API. No requiere tarjeta y dura 7 días. Eso es suficiente para ejecutar cada ejemplo de abajo muchas veces. Las claves de prueba permiten 2 solicitudes concurrentes y 60 solicitudes por minuto, así que ejecuta los ejemplos uno a uno.

Almacena la clave en una variable de entorno en lugar de en archivos de código. Una clave confirmada en un repositorio público será encontrada y usada por otra persona en horas, y el crédito que contiene es tuyo.

Primera petición en curl

Curl es la forma más rápida de demostrar que la URL funciona, porque elimina todas las bibliotecas del medio. Si esta llamada tiene éxito, cualquier problema que encuentres después está en la configuración de tu 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."}
    ]
  }'

La primera llamada devuelve la lista de modelos, que debería incluir uncensored. La segunda devuelve un objeto estándar de respuesta de chat. Mira las cabeceras de respuesta con curl -i y verás X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests y X-RateLimit-Limit-Concurrency. Guarda el ID de petición si alguna vez contactas con soporte sobre una llamada específica.

Python con el SDK de OpenAI

Instala la biblioteca con pip install openai, luego cambia dos argumentos en el constructor del 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 y las penalizaciones de frecuencia y presencia se pasan al modelo. El valor max_tokens es opcional. Sin él, la completación puede usar lo que quede de la ventana de 100.000 tokens, que es el prompt y la completación combinados.

El SDK también lee dos variables de entorno si no pasas argumentos: OPENAI_BASE_URL y OPENAI_API_KEY. Eso es útil para herramientas que no puedes editar. Establece ambas, lanza la herramienta y esta hablará con esta API.

Node, streaming y modo JSON

La configuración de Node se parece a la de Python. Instala con 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));

El streaming usa eventos enviados por el servidor y el uso se informa al final del flujo. Una petición en streaming mantiene su ranura de concurrencia hasta que el flujo termina, así que un cliente que abre un flujo y nunca lo lee bloqueará una ranura. Con el modo JSON, sigue indicándole al modelo en el prompt que responda en JSON. La bandera restringe el formato de salida, pero una instrucción clara te da mejores nombres de campos.

Llamada de herramientas

Las herramientas usan la forma habitual de OpenAI: una lista tools, un tool_choice opcional y resultados de herramientas enviados de vuelta como mensajes con role: "tool". Al transmitir, los tool_calls llegan en piezas a través de fragmentos.

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)

Trata los argumentos del modelo como entrada no confiable. Valídalos antes de ejecutar cualquier cosa. El modelo puede omitir una llamada a función o llamarla con un campo incorrecto, como cualquier modelo puede, así que mantén una ruta de respaldo en tu bucle.

Cuando la URL falla

La mayoría de las fallas entran en una lista corta.

• 404 No encontrado. La ruta es incorrecta. Causas comunes: la base URL se configuró como https://api.kimicode.cc sin /v1, o como https://api.kimicode.cc/v1/chat/completions por lo que el cliente añade la ruta dos veces. Usa exactamente la base URL de arriba.
• 401 No autorizado. Falta la clave, tiene un espacio o salto de línea extra, o el encabezado no es un token Bearer. Imprime la longitud de la variable para verificar.
• 429 con código rate_limited. Superaste el límite por minuto: 300 solicitudes para una clave completa, 60 para una clave de prueba.
• 429 con código concurrency. Demasiadas peticiones a la vez: 8 para una clave completa, 2 para una clave de prueba.
• 429 con un encabezado Retry-After: 5. Sobrecarga temporal. Espera cinco segundos y reintenta.
• Petición demasiado grande. El límite del cuerpo es 8 MB, y el prompt más la completación deben caber en 100.000 tokens.

Un bucle de reintento que honra Retry-After y aplica backoff en los otros dos códigos maneja casi todo esto. El costo por llamada es pequeño; la página de precios tiene las tarifas por token, y el inicio rápido de la documentación muestra los pasos de migración desde otro proveedor estilo OpenAI.

Reintentos y hábitos de producción

Una vez que la primera llamada funciona, añade un envoltorio de reintento antes de enviar. Honra el encabezado Retry-After cuando esté presente y retrocede con un retraso aleatorio corto en caso contrario.

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

Limita tu propia concurrencia para que coincida con tu clave: un grupo de hilos de 8 para una clave completa, 2 para una clave de prueba. Eso evita el error concurrency antes de que empiece, y te mantiene dentro del límite de 300 peticiones por minuto también cuando cada llamada tarda más de un par de segundos.

Finalmente, recuerda que pagas por token. Registra el objeto usage para cada llamada y vigila el encabezado X-Balance-USD. A $0,15 por 1M de tokens de entrada y $0,50 por 1M de tokens de salida, un turno de chat típico es una fracción de centavo, pero los bucles y los historiales largos se acumulan, y el registro te dice dónde.

Más guías

• Precios de la API Kimi Code vs Tokens de Pago por Uso
• Kimicode en Cursor Alternative: Configuración de endpoint personalizado
• API Groq: Mitos vs. Hechos para LLMs sin censura