Kimi Code API URL: Ustawienie base URL dla klientów OpenAI

URL i znaczenie każdej z jego części

Jeśli szukasz kimi code api url, być może szukasz adresu własnej usługi Kimi. W tym celu skorzystaj z dokumentacji dostawcy, ponieważ nie mogę jej zweryfikować. Ta strona obsługuje coś innego: hostowane API kompatybilne z OpenAI przed modelem o otwartych wagach, obsługiwane przez niezależnego dostawcę. Jego adres to:

Copyhttps://api.kimicode.cc/v1

Ten ciąg to base URL. To część dzielona przez każde zapytanie. SDK dodaje resztę. Gdy wywołujesz chat.completions.create, biblioteka OpenAI wysyła POST do https://api.kimicode.cc/v1/chat/completions. Lista modeli znajduje się pod https://api.kimicode.cc/v1/models i wymaga GET.

Te dwie metody to jedyne, które to API obsługuje: POST /v1/chat/completions i GET /v1/models. Jeśli liczyłeś na endpointy obrazu, audio lub embeddingów, nie istnieją one tutaj. To API tekstowe.

Ważne są trzy ustawienia, nic innego nie musi się zmienić w istniejącym kodzie OpenAI: base URL, klucz API i ID modelu uncensored.

Dlaczego base URL to jedyny przełącznik

Klienty w stylu OpenAI są zbudowane wokół jednej idei: format zapytania jest stały, a host to ustawienie. Biblioteka ma domyślny host wskazujący na oryginalnego dostawcę. Gdy go zastąpisz innym base URL, to samo ciało zapytania trafi w inne miejsce. Nic w twoich promptach, tablicach wiadomości ani parsowaniu odpowiedzi nie musi się zmienić.

Dlatego migracja z innego dostawcy kompatybilnego z OpenAI to zwykle trzy zmiany: adres bazowy, klucz i nazwa modelu. Pola w odpowiedzi, takie jak choices, message, finish_reason i usage, mają takie same nazwy, więc kod je odczytujący działa bez zmian.

To też wyjaśnia dziwne błędy, na które natrafiają użytkownicy. Jeśli narzędzie prosi o „URL serwera”, a wkleisz tylko host, brakuje ścieżki. Jeśli narzędzie prosi o „pełny endpoint”, a wkleisz bazowy URL, zapytanie trafi w złe miejsce. Gdy ekran ustawień jest niejasny, najpierw spróbuj bazowego URL i przeczytaj zwrócony kod statusu. Szybki start w dokumentacji pokazuje tę migrację na kolejnym przykładzie.

Zmienne środowiskowe dla narzędzi, których nie możesz edytować

Wiele narzędzi wiersza poleceń i frameworków tworzy klienta OpenAI bez możliwości ingerencji w konstruktor. Zwykle odczytują one standardowe zmienne środowiskowe, więc ich ustawienie wystarczy:

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

Niektóre starsze narzędzia szukają OPENAI_API_BASE, więc jeśli jedno ignoruje pierwszą nazwę, spróbuj tej drugiej. Po ich ustawieniu uruchom narzędzie w tej samej sesji powłoki, ponieważ zmienne ustawione w innym oknie terminala nie są udostępniane.

Narzędzie nadal będzie potrzebować nazwy modelu. Jeśli hardkoduje model hostowany, szukaj flagi lub linii konfiguracji, która ją ustawia, i użyj uncensored. Jeśli nie da się tego zmienić, narzędzie nie jest odpowiednie, a lepszą ścieżką jest mały skrypt, taki jak powyższe.

Najpierw uzyskaj klucz

Zapytania są uwierzytelniane nagłówkiem w formie Authorization: Bearer YOUR_KEY. Każdy oficjalny SDK tworzy ten nagłówek dla Ciebie na podstawie argumentu api_key. Możesz utworzyć klucz po zalogowaniu się przez Google lub e-mail i hasłem.

Nowe konta mogą jednorazowo kliknąć i odebrać $0.50 kredytu próbnego na stronie klucza API. Nie wymaga karty i trwa 7 dni. To wystarczy, aby wielokrotnie uruchomić każdy poniższy przykład. Klucze próbne pozwalają na 2 równoległe zapytania i 60 zapytań na minutę, więc uruchamiaj przykłady jeden po drugim.

Przechowuj klucz w zmiennej środowiskowej, a nie w plikach źródłowych. Klucz wklejony do publicznego repozytorium zostanie znaleziony i użyty przez kogoś innego w ciągu kilku godzin, a kredyt na nim zawarty należy do Ciebie.

Pierwsze zapytanie w curl

Curl to najszybszy sposób na sprawdzenie, czy URL działa, ponieważ eliminuje każdą bibliotekę z obrazu. Jeśli to wywołanie się powiedzie, każdy problem, na który napotkasz później, leży w konfiguracji Twojego klienta.

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

Pierwsze wywołanie zwraca listę modeli, która powinna zawierać uncensored. Drugie zwraca standardowy obiekt ukończenia czatu. Spójrz na nagłówki odpowiedzi używając curl -i i zobaczysz X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests i X-RateLimit-Limit-Concurrency. Zachowaj ID zapytania, jeśli kiedykolwiek skontaktujesz się z wsparciem w sprawie konkretnego wywołania.

Python z SDK OpenAI

Zainstaluj bibliotekę poleceniem pip install openai, a następnie zmień dwa argumenty w konstruktorze klienta.

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)

Parametry takie jak temperature, top_p, stop, seed oraz kary częstotliwości i obecności są przekazywane do modelu. Wartość max_tokens jest opcjonalna. Bez niej uzupełnienie może użyć tego, co zostało z okna 100 000 tokenów, czyli promptu i uzupełnienia łącznie.

SDK odczytuje również dwie zmienne środowiskowe, jeśli nie przekażesz argumentów: OPENAI_BASE_URL i OPENAI_API_KEY. Jest to przydatne dla narzędzi, których nie możesz edytować. Ustaw oba, uruchom narzędzie i będzie ono rozmawiać z tym API.

Node, strumieniowanie i tryb JSON

Konfiguracja Node odzwierciedla Pythona. Zainstaluj poleceniem 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));

Strumieniowanie wykorzystuje zdarzenia wysyłane przez serwer, a zużycie jest raportowane na końcu strumienia. Zapytanie strumieniowe zajmuje slot współbieżności do momentu zakończenia strumienia, więc klient, który otworzy strumień, ale go nie odczyta, zablokuje slot. W trybie JSON nadal mów modelowi w promptie, aby odpowiadał w formacie JSON. Flaga ogranicza format wyjściowy, ale jasna instrukcja daje lepsze nazwy pól.

Wywoływanie narzędzi

Narzędzia używają standardowego kształtu OpenAI: listy tools, opcjonalnego tool_choice i wyników narzędzi wysyłanych z powrotem jako wiadomości z role: "tool". Podczas strumieniowania tool_calls przychodzą w kawałkach w ramach chunków.

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)

Traktuj argumenty od modelu jako niezaufane dane. Waliduj je przed uruchomieniem czegokolwiek. Model może pominąć wywołanie narzędzia lub wywołać je z błędnym polem, tak jak każdy model, więc zachowaj ścieżkę awaryjną w pętli.

Gdy URL nie działa

Większość awarii mieści się na krótkiej liście.

• 404 Not Found. Ścieżka jest błędna. Powszechne przyczyny: bazowy URL został ustawiony na https://api.kimicode.cc bez /v1, lub na https://api.kimicode.cc/v1/chat/completions, przez co klient aplikuje ścieżkę dwukrotnie. Użyj dokładnie bazowego URL powyżej.
• 401 Unauthorized. Brakuje klucza, zawiera on przypadkową spację lub znak nowej linii, lub nagłówek nie jest tokenem Bearer. Wypisz długość zmiennej, aby sprawdzić.
• 429 z kodem rate_limited. Przekroczyłeś limit na minutę: 300 zapytań dla pełnego klucza, 60 dla klucza próbnego.
• 429 z kodem concurrency. Zbyt wiele zapytań naraz: 8 dla pełnego klucza, 2 dla klucza próbnego.
• 429 z nagłówkiem Retry-After: 5. Tymczasowe przeciążenie. Poczekaj pięć sekund i ponów próbę.
• Zapytanie zbyt duże. Limit ciała to 8 MB, a prompt plus ukończenie muszą zmieścić się w 100 000 tokenach.

Pętla ponownych prób, która respektuje Retry-After i stosuje opóźnienie przy pozostałych dwóch kodach, obsługuje prawie wszystkie przypadki. Koszt jednego wywołania jest niski; na stronie z cenami znajdziesz stawki za token, a szybki start w dokumentacji pokazuje kroki migracji z innego dostawcy w stylu OpenAI.

Ponowne próby i nawyki środowiska produkcyjnego

Gdy pierwsze wywołanie zadziała, dodaj opakowanie z retry przed wdrożeniem. Respektuj nagłówek Retry-After, gdy jest obecny, a w przeciwnym razie stosuj krótkie losowe opóźnienie.

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

Ogranicz własną współbieżność do limitów klucza: pulę 8 wątków dla pełnego klucza, 2 dla klucza próbnego. To zapobiega błędowi concurrency od początku i utrzymuje Cię w limicie 300 zapytań na minutę, gdy każde wywołanie trwa dłużej niż kilka sekund.

Na koniec pamiętaj, że płacisz za token. Loguj obiekt usage dla każdego wywołania i obserwuj nagłówek X-Balance-USD. Przy cenie $0.15 za 1M tokenów wejściowych i $0.50 za 1M tokenów wyjściowych, typowa tura czatu to ułamek centa, ale pętle i długie historie się sumują, a log pokazuje, gdzie.

Więcej przewodników

• Ceny API Kimi Code vs Tokeny Pay-as-You-Go
• Kimicode w Alternatywie dla Cursora: Konfiguracja Niestandardowego Endpointu
• API Groq: Mity vs Fakty dla LLM bez cenzury