Kimi Code API-URL: Basis-URL-instelling voor OpenAI-clients

De URL en wat elk onderdeel betekent

Als je op zoek bent naar de kimi code api url, zoek je misschien het adres van de eigen service van Kimi. Gebruik daarvoor de documentatie van de leverancier, want daar kan ik niet voor instaan. Deze site draait iets anders: een gehoste, OpenAI-compatible API voor één open-weight model, beheerd door een onafhankelijke provider. Het adres is:

Copyhttps://api.kimicode.cc/v1

Die string is de basis-URL. Het is het deel dat elk verzoek deelt. De SDK voegt de rest toe. Als je chat.completions.create aanroept, stuurt de OpenAI-bibliotheek een POST naar https://api.kimicode.cc/v1/chat/completions. De modellijst staat op https://api.kimicode.cc/v1/models en vereist een GET.

Dat zijn de enige methoden die deze API aanbiedt: POST /v1/chat/completions en GET /v1/models. Als je hoopte op image-, audio- of embedding-endpoints, die bestaan hier niet. Het is een tekst-API.

Drie instellingen zijn belangrijk, en verder hoef je niets te wijzigen in je bestaande OpenAI-code: de basis-URL, de API-sleutel en de model-ID uncensored.

Waarom een basis-URL de enige schakelaar is

OpenAI-style clients zijn gebouwd rond één idee: het verzoekformaat is vast, en de host is een instelling. De bibliotheek heeft een standaardhost die naar de oorspronkelijke leverancier verwijst. Als je deze vervangt door een andere basis-URL, gaat hetzelfde verzoeklichaam ergens anders heen. Er hoeft niets te veranderen in je prompts, berichtarrays of het parseren van de respons.

Dat is ook waarom een migratie van een andere OpenAI-compatibele provider meestal uit drie bewerkingen bestaat: de basis-URL, de sleutel en de modelnaam. De velden in de respons, zoals choices, message, finish_reason en usage, hebben dezelfde namen, dus code die ze uitleest blijft werken.

Het verklaart ook de vreemde fouten die mensen tegenkomen. Als een tool om een "server-URL" vraagt en je plakt alleen de host, ontbreekt het pad. Als een tool om een "volledig endpoint" vraagt en je plakt de basis-URL, gaat het verzoek naar de verkeerde plek. Als een instellingenscherm onduidelijk is, probeer dan eerst de basis-URL en lees de statuscode die terugkomt. De quickstart in de docs doorloopt dezelfde migratie met nog een voorbeeld.

Omgevingsvariabelen voor tools die je niet kunt bewerken

Veel command-line tools en frameworks bouwen een OpenAI-client zonder dat je de constructor kunt aanpassen. Ze lezen meestal de standaard omgevingsvariabelen, dus het instellen daarvan is genoeg:

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

Sommige oudere tools zoeken naar OPENAI_API_BASE in plaats daarvan, dus als de eerste naam wordt genegeerd, probeer dan de tweede. Start de tool na het instellen in dezelfde shellsessie, omdat variabelen die in een ander terminalvenster zijn ingesteld, niet worden gedeeld.

De tool heeft nog steeds een modelnaam nodig. Als deze een gehost model hardcodeert, zoek dan naar een vlag of configuratieregel die deze instelt, en gebruik uncensored. Als dit niet kan gewijzigd worden, is de tool niet geschikt en is een klein script zoals de bovenstaande voorbeelden een betere weg.

Haal eerst een sleutel

Verzoeken worden geauthenticeerd met een header van de vorm Authorization: Bearer YOUR_KEY. Elke officiële SDK bouwt die header voor je op basis van het api_key argument. Je kunt de sleutel aanmaken na het inloggen met Google of met een e-mailadres en wachtwoord.

Nieuwe accounts kunnen $0,50 aan proeftegoed claimen met één klik op de API-sleutelpagina. Er is geen kaart nodig en het duurt 7 dagen. Dat is genoeg om alle onderstaande voorbeelden vele malen uit te voeren. Proefsleutels staan 2 gelijktijdige verzoeken en 60 verzoeken per minuut toe, dus voer de voorbeelden één voor één uit.

Sla de sleutel op in een omgevingsvariabele in plaats van in bronbestanden. Een sleutel die in een openbare repository is vastgelegd, wordt binnen enkele uren gevonden en gebruikt door iemand anders, en het tegoed dat deze bevat, is van jou.

Eerste verzoek in curl

Curl is de snelste manier om te bewijzen dat de URL werkt, omdat het elke bibliotheek uit de weg ruimt. Als deze aanroep slaagt, ligt elk probleem dat je later tegenkomt in je clientconfiguratie.

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."}
    ]
  }'

Het eerste verzoek retourneert de modellijst, die uncensored moet bevatten. Het tweede retourneert een standaard chat-completion-object. Bekijk de antwoordheaders met curl -i en je ziet X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests en X-RateLimit-Limit-Concurrency. Bewaar de request-ID als je ooit contact opneemt met support over een specifiek verzoek.

Python met de OpenAI SDK

Installeer de bibliotheek met pip install openai, en wijzig dan twee argumenten in de clientconstructor.

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)

Parameters zoals temperature, top_p, stop, seed en de frequentie- en aanwezigheidsstraffen worden doorgegeven aan het model. De waarde van max_tokens is optioneel. Zonder deze waarde kan de completion gebruikmaken van wat er overblijft van het 100.000-token contextvenster, wat de prompt en de completion samen is.

De SDK leest ook twee omgevingsvariabelen als je geen argumenten doorgeeft: OPENAI_BASE_URL en OPENAI_API_KEY. Dat is handig voor tools die je niet kunt bewerken. Stel beide in, start de tool en deze praat met deze API.

Node, streaming en JSON-modus

De Node-opstelling lijkt op Python. Installeer met 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));

Streaming gebruikt serververzonden gebeurtenissen en het verbruik wordt aan het einde van de stream gerapporteerd. Een gestreamd verzoek houdt zijn gelijktijdigheidsslot vast totdat de stream klaar is, dus een client die een stream opent en deze nooit leest, blokkeert een slot. Geef in de JSON-modus nog steeds aan in de prompt dat het model in JSON moet antwoorden. De vlag beperkt het uitvoerformaat, maar een duidelijke instructie geeft je betere veldnamen.

Function calling

Tools gebruiken de gebruikelijke OpenAI-vorm: een tools lijst, een optionele tool_choice, en toolresultaten die terug worden gestuurd als berichten met role: "tool". Bij streaming komen de tool_calls in stukken binnen over 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)

Behandel argumenten van het model als onbetrouwbare invoer. Valideer ze voordat je iets uitvoert. Het model kan een toolaanroep overslaan of deze uitvoeren met een verkeerd veld, zoals elk model kan, dus houd een fallback-pad in je lus.

Wanneer de URL faalt

De meeste fouten vallen onder een korte lijst.

• 404 Not Found. Het pad is verkeerd. Veelvoorkomende oorzaken: de base URL was ingesteld op https://api.kimicode.cc zonder /v1, of op https://api.kimicode.cc/v1/chat/completions zodat de client het pad twee keer toevoegt. Gebruik exact de bovenstaande base URL.
• 401 Unauthorized. De sleutel ontbreekt, heeft een losse spatie of newline, of de header is geen Bearer-token. Print de lengte van de variabele om te controleren.
• 429 met code rate_limited. Je hebt de minuutlimiet overschreden: 300 verzoeken voor een volledige sleutel, 60 voor een proefsleutel.
• 429 met code concurrency. Te veel verzoeken tegelijk: 8 voor een volledige sleutel, 2 voor een proefsleutel.
• 429 met een Retry-After: 5 header. Tijdelijke overbelasting. Wacht vijf seconden en probeer het opnieuw.
• Verzoek te groot. De bodylimiet is 8 MB, en de prompt plus de completion moeten binnen 100.000 tokens passen.

Een herhalinglus die Retry-After respecteert en backoff toepast op de andere twee codes, lost bijna alles op. De kosten per verzoek zijn laag; de prijzenpagina bevat de tokensnelheden en de docs quickstart toont de migratiestappen vanaf een andere OpenAI-style provider.

Herhalingen en productiegewoonten

Zodra het eerste verzoek werkt, voeg een herhalingwrapper toe voordat je gaat deployen. Respecteer de Retry-After header wanneer deze aanwezig is en pas backoff toe met een korte willekeurige vertraging in andere gevallen.

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

Beperk je eigen gelijktijdigheid om bij je sleutel te passen: een thread pool van 8 voor een volledige sleutel, 2 voor een proefsleutel. Dat voorkomt de concurrency fout voordat deze begint, en houdt je binnen de limiet van 300 verzoeken per minuut, als elk verzoek meer dan een paar seconden duurt.

Onthoud tot slot dat je betaalt per token. Log het usage object voor elk verzoek en houd de X-Balance-USD header in de gaten. Bij $0,15 per 1M input tokens en $0,50 per 1M output tokens is een typische chatbeurt een fractie van een cent, maar loops en lange geschiedenissen tellen op, en het log vertelt je waar.

Meer handleidingen

• Kimi Code API-prijzen vs Pay-as-you-go tokens
• Kimicode in Cursor-alternatief: Aangepaste endpoint-instelling
• Groq API: Mythes versus feiten voor ongecensureerde LLM's