Czat (chat completions)

Endpoint POST /v1/chat/completions mówi tym samym językiem co Chat Completions z API OpenAI. Każde SDK i narzędzie, które potrafi rozmawiać z OpenAI, połączy się z Kadrarisem po zmianie adresu bazowego na https://kadraris.com/v1 i podaniu klucza z panelu. Pod tym jednym adresem działają wszystkie modele czatu z katalogu, także te spoza OpenAI.

Dostępne modele czatu

OpenAI: gpt-6-sol, gpt-6-luna, gpt-6-astra
Anthropic: claude-opus-5.5, claude-sonnet-5, claude-fable-5.1
Google: gemini-3.6-flash
DeepSeek: deepseek-v4-flash
Zhipu: glm-5.2
Moonshot: kimi-k3

Stawki za milion tokenów wejścia i wyjścia są w katalogu modeli oraz w GET /v1/models?category=chat (opis w Modelach). Dla przykładu Claude Sonnet 5 kosztuje 17,60 zł / 87,98 zł za 1 mln tokenów.

Parametry zapytania

http

POST https://kadraris.com/v1/chat/completions
Authorization: Bearer sk-kd-...
Content-Type: application/json

Pole	Typ	Obowiązkowe	Znaczenie
`model`	string	tak	Id z tabeli powyżej
`messages`	array	tak	Historia rozmowy w formacie OpenAI: obiekty `{role, content}` z rolami `system`, `user`, `assistant`, `tool`
`stream`	boolean	nie	Wartość `true` włącza strumień SSE; bez niej dostajesz jedną odpowiedź
`max_tokens`	integer	nie	Maksymalna liczba tokenów odpowiedzi
`temperature`	number	nie	Temperatura losowania
`tools`	array	nie	Funkcje opisane w formacie OpenAI
`tool_choice`	tekst albo obiekt	nie	`auto`, `none`, `required` albo wskazana funkcja

Najprostsza rozmowa

bash

curl https://kadraris.com/v1/chat/completions \
  -H "Authorization: Bearer $KADRARIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-sol",
    "messages": [
      {"role": "system", "content": "Mów krótko, jednym zdaniem."},
      {"role": "user", "content": "Czym jest proporcja 9:16?"}
    ]
  }'

python

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://kadraris.com/v1",
    api_key=os.environ["KADRARIS_API_KEY"],
)

resp = client.chat.completions.create(
    model="gpt-6-sol",
    messages=[
        {"role": "system", "content": "Mów krótko, jednym zdaniem."},
        {"role": "user", "content": "Czym jest proporcja 9:16?"},
    ],
)
print(resp.choices[0].message.content)

javascript

import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "gpt-6-sol",
  messages: [
    { role: "system", content: "Mów krótko, jednym zdaniem." },
    { role: "user", content: "Czym jest proporcja 9:16?" },
  ],
});
console.log(resp.choices[0].message.content);

To samo bez żadnego SDK, gołym requests:

python

import os, requests

r = requests.post(
    "https://kadraris.com/v1/chat/completions",
    headers={"Authorization":
             f"Bearer {os.environ['KADRARIS_API_KEY']}"},
    json={"model": "gemini-3.6-flash",
          "messages": [{"role": "user", "content": "Dzień dobry"}]},
    timeout=120,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])

Kształt odpowiedzi

json

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1790500000,
  "model": "gpt-6-sol",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant",
        "content": "To pionowy kadr: wysokość jest prawie dwa razy większa od szerokości." },
      "finish_reason": "stop"
    }
  ],
  "usage": { "prompt_tokens": 24, "completion_tokens": 18,
    "total_tokens": 42 }
}

Rachunek wynika z usage: tokeny wejściowe mnożymy przez stawkę wejścia modelu, a wyjściowe przez stawkę wyjścia.

Odpowiedź strumieniowa

Z stream: true tokeny przychodzą na bieżąco, w miarę jak model je pisze. Treść ma typ text/event-stream, każda linia data: niesie kawałek w formacie OpenAI, a całość zamyka data: [DONE].

bash

curl -N https://kadraris.com/v1/chat/completions \
  -H "Authorization: Bearer $KADRARIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-sonnet-5", "stream": true,
       "messages": [{"role": "user",
         "content": "Wymień trzy plany filmowe."}]}'

text

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"Plan ogólny"}}]}

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":", półzbliżenie"}}]}

data: [DONE]

python

stream = client.chat.completions.create(
    model="claude-sonnet-5",
    messages=[{"role": "user",
               "content": "Wymień trzy plany filmowe."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

javascript

const stream = await client.chat.completions.create({
  model: "claude-sonnet-5",
  messages: [{ role: "user", content: "Wymień trzy plany filmowe." }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Narzędzia (function calling)

Funkcje opisujesz tak jak w OpenAI. Jeśli model zechce z nich skorzystać, odda tool_calls. Ty wykonujesz funkcję u siebie, dokładasz do rozmowy wiadomość tool z wynikiem, a model kończy odpowiedź.

python

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_render_status",
        "description": "Podaje stan renderu filmu po id",
        "parameters": {
            "type": "object",
            "properties": {"render_id": {"type": "string"}},
            "required": ["render_id"],
        },
    },
}]

messages = [{"role": "user",
             "content": "Czy render R-207 jest gotowy?"}]
first = client.chat.completions.create(
    model="gpt-6-luna", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        # tu wywołujesz własny system
        result = {"render_id": args["render_id"],
                  "status": "gotowy"}
        messages.append({"role": "tool",
                         "tool_call_id": call.id,
                         "content": json.dumps(result)})
    final = client.chat.completions.create(
        model="gpt-6-luna", messages=messages, tools=tools)
    print(final.choices[0].message.content)

javascript

const tools = [{
  type: "function",
  function: {
    name: "get_render_status",
    description: "Podaje stan renderu filmu po id",
    parameters: {
      type: "object",
      properties: { render_id: { type: "string" } },
      required: ["render_id"],
    },
  },
}];

const messages = [
  { role: "user", content: "Czy render R-207 jest gotowy?" },
];
const first = await client.chat.completions.create({
  model: "gpt-6-luna", messages, tools,
});
const msg = first.choices[0].message;

if (msg.tool_calls) {
  messages.push(msg);
  for (const call of msg.tool_calls) {
    const args = JSON.parse(call.function.arguments);
    // tu wywołujesz własny system
    const result = { render_id: args.render_id, status: "gotowy" };
    messages.push({
      role: "tool",
      tool_call_id: call.id,
      content: JSON.stringify(result),
    });
  }
  const final = await client.chat.completions.create({
    model: "gpt-6-luna", messages, tools,
  });
  console.log(final.choices[0].message.content);
}

Obsługa błędów

Błędy przychodzą w formacie OpenAI, dlatego SDK zgłasza swoje standardowe wyjątki (AuthenticationError, RateLimitError i pozostałe). Jeden klucz może domyślnie wysłać 600 zapytań na minutę. Pełny opis: Błędy.

Powiązane strony

Pracujesz na SDK Anthropic albo w Claude Code? Zajrzyj do opisu endpointu Messages.
Konfiguracja Cursora, Cline'a i Continue jest w poradniku o edytorach i agentach.