{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1711900000,
  "model": "gpt-4o-mini",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! I am an AI assistant..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 48,
    "total_tokens": 60
  }
}

data: {"id":"chatcmpl-abc","object":"chat.completion.chunk","choices":[{"delta":{"content":"Hello"}}]}

data: {"id":"chatcmpl-abc","object":"chat.completion.chunk","choices":[{"delta":{"content":"!"}}]}

data: [DONE]

curl -X POST https://DOMAIN/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "deepseek-chat",
    "messages": [
      {"role": "system", "content": "You are a professional coding assistant"},
      {"role": "user", "content": "Write a bubble sort in Python"}
    ],
    "temperature": 0.7,
    "max_tokens": 1024
  }'

# pip install openai
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://DOMAIN/v1"
)

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "You are a professional coding assistant"},
        {"role": "user", "content": "Write a bubble sort in Python"},
    ],
    temperature=0.7,
    max_tokens=1024
)

print(response.choices[0].message.content)
print(f"Token usage: {response.usage.total_tokens}")

// npm install openai
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://DOMAIN/v1",
});

async function main() {
  const res = await client.chat.completions.create({
    model: "deepseek-chat",
    messages: [
      { role: "system", content: "You are a professional coding assistant" },
      { role: "user", content: "Write a bubble sort in Python" },
    ],
    temperature: 0.7,
    max_tokens: 1024,
  });
  console.log(res.choices[0].message.content);
  console.log(`Token usage: ${res.usage.total_tokens}`);
}

main();

// go get github.com/sashabaranov/go-openai
package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("YOUR_API_KEY")
    config.BaseURL = "https://DOMAIN/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "deepseek-chat",
            Messages: []openai.ChatCompletionMessage{
                {Role: openai.ChatMessageRoleSystem, Content: "You are a professional coding assistant"},
                {Role: openai.ChatMessageRoleUser,   Content: "Write a bubble sort in Python"},
            },
        },
    )
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.Choices[0].Message.Content)
}

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://DOMAIN/v1")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Describe this image"},
            {
                "type": "image_url",
                "image_url": {
                    "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
                    "detail": "high"
                }
            }
        ]
    }]
)
print(response.choices[0].message.content)

import base64
from openai import OpenAI

def encode_image(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://DOMAIN/v1")
b64 = encode_image("./image.jpg")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "How many people are in this image?"},
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}}
        ]
    }]
)
print(response.choices[0].message.content)

import fs from "fs";
import OpenAI from "openai";

const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://DOMAIN/v1" });
const b64 = fs.readFileSync("./image.jpg").toString("base64");

const res = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{
    role: "user",
    content: [
      { type: "text", text: "How many people are in this image?" },
      { type: "image_url", image_url: { url: `data:image/jpeg;base64,${b64}` } }
    ]
  }]
});
console.log(res.choices[0].message.content);

package main

import (
    "context"; "encoding/base64"; "fmt"; "os"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("YOUR_API_KEY")
    config.BaseURL = "https://DOMAIN/v1"
    client := openai.NewClientWithConfig(config)

    data, _ := os.ReadFile("./image.jpg")
    b64 := base64.StdEncoding.EncodeToString(data)
    dataURL := "data:image/jpeg;base64," + b64

    resp, _ := client.CreateChatCompletion(context.Background(),
        openai.ChatCompletionRequest{
            Model: "gpt-4o",
            Messages: []openai.ChatCompletionMessage{{
                Role: openai.ChatMessageRoleUser,
                MultiContent: []openai.ChatMessagePart{
                    {Type: openai.ChatMessagePartTypeText,     Text: "How many people are in this image?"},
                    {Type: openai.ChatMessagePartTypeImageURL, ImageURL: &openai.ChatMessageImageURL{URL: dataURL}},
                },
            }},
        })
    fmt.Println(resp.Choices[0].Message.Content)
}

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://DOMAIN/v1")

with client.chat.completions.stream(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Write a classical Chinese seven-character poem about spring"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

import OpenAI from "openai";

const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://DOMAIN/v1" });

const stream = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Write a classical Chinese seven-character poem about spring" }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
console.log();

package main

import (
    "bufio"; "bytes"; "encoding/json"; "fmt"
    "net/http"; "strings"
)

func main() {
    body, _ := json.Marshal(map[string]any{
        "model":  "gpt-4o-mini",
        "stream": true,
        "messages": []map[string]string{{"role": "user", "content": "Write a classical Chinese seven-character poem"}},
    })

    req, _ := http.NewRequest("POST", "https://DOMAIN/v1/chat/completions", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    scanner := bufio.NewScanner(resp.Body)
    for scanner.Scan() {
        line := scanner.Text()
        if !strings.HasPrefix(line, "data: ") { continue }
        data := strings.TrimPrefix(line, "data: ")
        if data == "[DONE]" { break }
        var chunk map[string]any
        json.Unmarshal([]byte(data), &chunk)
        choices := chunk["choices"].([]any)
        delta := choices[0].(map[string]any)["delta"].(map[string]any)
        if content, ok := delta["content"]; ok {
            fmt.Print(content)
        }
    }
}