OpenAI SDK

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GRAFILAB_API_KEY"],
    base_url="https://llm.grafilab.ai/v1",
)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.GRAFILAB_API_KEY,
  baseURL: "https://llm.grafilab.ai/v1",
});

from openai import OpenAI

client = OpenAI(api_key="sk-grafilab-...", base_url="https://llm.grafilab.ai/v1")
for model in client.models.list():
    print(model.id)

import OpenAI from "openai";

const client = new OpenAI({ apiKey: "sk-grafilab-...", baseURL: "https://llm.grafilab.ai/v1" });
for await (const model of client.models.list()) {
  console.log(model.id);
}

response = client.chat.completions.create(
    model="grafilab/qwen3.6-flash",
    messages=[
        {"role": "system", "content": "You are terse."},
        {"role": "user", "content": "Why is the sky blue?"},
    ],
)

print(response.choices[0].message.content)
print(response.usage)

const response = await client.chat.completions.create({
  model: "grafilab/qwen3.6-flash",
  messages: [
    { role: "system", content: "You are terse." },
    { role: "user", content: "Why is the sky blue?" },
  ],
});

console.log(response.choices[0].message.content);
console.log(response.usage);

stream = client.chat.completions.create(
    model="grafilab/qwen3.6-flash",
    messages=[{"role": "user", "content": "Count to five."}],
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.usage:
        print("\nusage:", chunk.usage)
    elif chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

const stream = await client.chat.completions.create({
  model: "grafilab/qwen3.6-flash",
  messages: [{ role: "user", content: "Count to five." }],
  stream: true,
  stream_options: { include_usage: true },
});

for await (const chunk of stream) {
  if (chunk.usage) {
    console.log("\nusage:", chunk.usage);
  } else if (chunk.choices[0]?.delta?.content) {
    process.stdout.write(chunk.choices[0].delta.content);
  }
}

for model in client.models.list():
    print(model.id, getattr(model, "region", None), getattr(model, "tags", None))

for await (const model of client.models.list()) {
  console.log(model.id, (model as any).region, (model as any).tags);
}

import openai

try:
    raw = client.chat.completions.with_raw_response.create(
        model="grafilab/qwen3.6-flash",
        messages=[{"role": "user", "content": "Hello"}],
    )
    print(raw.headers.get("x-request-id"))
    completion = raw.parse()
except openai.RateLimitError:
    print("Top up your Grafilab credit balance.")
except openai.APIStatusError as err:
    print(err.status_code, err.response.headers.get("x-should-retry"), err.response.text)

try {
  const { data, response } = await client.chat.completions
    .create({
      model: "grafilab/qwen3.6-flash",
      messages: [{ role: "user", content: "Hello" }],
    })
    .withResponse();
  console.log(response.headers.get("x-request-id"), data.choices[0].message.content);
} catch (err) {
  if (err instanceof OpenAI.RateLimitError) {
    console.log("Top up your Grafilab credit balance.");
  } else if (err instanceof OpenAI.APIError) {
    console.log(err.status, err.headers?.["x-should-retry"], err.message);
  }
}

result = client.embeddings.create(
    model="<embedding-model-id>",
    input=["the first document", "the second document"],
    encoding_format="float",
)
print(len(result.data[0].embedding))

const result = await client.embeddings.create({
  model: "<embedding-model-id>",
  input: ["the first document", "the second document"],
  encoding_format: "float",
});
console.log(result.data[0].embedding.length);

image = client.images.generate(
    model="<image-model-id>",
    prompt="a lighthouse in fog, long exposure",
    n=1,
    response_format="url",
)
print(image.data[0].url)

const image = await client.images.generate({
  model: "<image-model-id>",
  prompt: "a lighthouse in fog, long exposure",
  n: 1,
  response_format: "url",
});
console.log(image.data[0].url);

edited = client.images.edit(
    model="<edit-capable-model-id>",
    image=open("source.png", "rb"),
    prompt="replace the sky with a clear night sky",
)

import fs from "node:fs";
import { toFile } from "openai";

const edited = await client.images.edit({
  model: "<edit-capable-model-id>",
  image: await toFile(fs.createReadStream("source.png")),
  prompt: "replace the sky with a clear night sky",
});

import time

video = client.videos.create(model="<video-model-id>", prompt="a paper boat crossing a puddle")

while video.status in ("queued", "in_progress"):
    time.sleep(5)
    video = client.videos.retrieve(video.id)

if video.status == "failed":
    raise RuntimeError(video.error)

content = client.videos.download_content(video.id)
content.write_to_file("out.mp4")

let video = await client.videos.create({
  model: "<video-model-id>",
  prompt: "a paper boat crossing a puddle",
});

while (video.status === "queued" || video.status === "in_progress") {
  await new Promise((r) => setTimeout(r, 5000));
  video = await client.videos.retrieve(video.id);
}

if (video.status === "failed") throw new Error(String(video.error));

const content = await client.videos.downloadContent(video.id);
// content is a Response — stream or buffer its body to a file.