Giao Thức Tương Thích OpenAI

Giao thức tương thích OpenAI là tiêu chuẩn API AI được hỗ trợ rộng rãi nhất trong ngành. RouteAPI triển khai đầy đủ đặc tả API OpenAI, cho phép bạn tích hợp liền mạch với các SDK, công cụ và client OpenAI hiện có chỉ bằng cách chuyển đổi Base URL và API Key.

Tổng Quan Giao Thức

API OpenAI định nghĩa một tập hợp các interface REST tiêu chuẩn hóa cho tạo hội thoại, embedding văn bản, liệt kê model và các khả năng khác. Ưu điểm cốt lõi của nó nằm ở hệ sinh thái trưởng thành: các SDK chính thức của OpenAI, LangChain, LiteLLM, Cursor và nhiều trợ lý lập trình khác hỗ trợ giao thức này một cách tự nhiên.

Phạm vi tương thích của RouteAPI:

Hoàn toàn tương thích với các endpoint Chat Completions, Responses, Embeddings và Models của OpenAI
Xác thực nhất quán sử dụng header request Authorization: Bearer
Định dạng request/response nhất quán, bao gồm streaming SSE và cấu trúc lỗi
Phạm vi model ID rộng hơn, có thể gọi OpenAI, Claude, Gemini, Mistral và các nhà cung cấp khác
Bảo toàn tham số giá trị zero tường minh, giá trị 0 / false được truyền tường minh không bị loại bỏ

Di chuyển từ API chính thức của OpenAI sang RouteAPI chỉ cần hai thay đổi cấu hình:

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-routeapi-token",        # Chuyển sang RouteAPI Token
    base_url="https://api.routeapi.ai/v1"   # Chuyển sang RouteAPI Base URL
)

Tất cả mã khác giữ nguyên.

Base URL

https://api.routeapi.ai/v1

Tất cả các endpoint tương thích OpenAI sử dụng base URL này. Nếu client hoặc SDK của bạn yêu cầu URL đầy đủ, chỉ cần nối thêm đường dẫn endpoint, ví dụ https://api.routeapi.ai/v1/chat/completions.

Xác Thực

Giống hệt với API chính thức của OpenAI, sử dụng header request HTTP Authorization:

Authorization: Bearer sk-your-routeapi-token
Content-Type: application/json

RouteAPI Token bắt đầu bằng sk- và được tạo trên trang API Keys trong console. Lưu trữ token ở phía server và không để lộ chúng trong trình duyệt, ứng dụng di động hoặc kho công khai.

Tổng Quan Các Endpoint Được Hỗ Trợ

Endpoint	Mục Đích	Tài Liệu Chi Tiết
`/v1/chat/completions`	Tạo hội thoại, hỗ trợ đối thoại nhiều lượt, gọi công cụ, đầu ra có cấu trúc	Chat Completions
`/v1/responses`	Giao thức OpenAI Responses, phù hợp cho coding agent và framework ứng dụng thế hệ mới	Responses
`/v1/embeddings`	Embedding vector văn bản cho tìm kiếm ngữ nghĩa, RAG, tính toán độ tương đồng	Embeddings
`/v1/models`	Lấy danh sách các model có sẵn cho tài khoản hiện tại	Bên dưới trên trang này

So Sánh Trường Hợp Sử Dụng

Kịch Bản	Endpoint Được Đề Xuất	Lý Do
Chat chung, Q&A, tóm tắt, phân loại	`/v1/chat/completions`	Hệ sinh thái trưởng thành nhất, tương thích rộng rãi nhất
Coding agent (Cursor, Claude Code, Copilot)	`/v1/responses` hoặc `/v1/chat/completions`	Tùy thuộc vào giao thức được client hỗ trợ tự nhiên
Đối thoại nhiều lượt, lịch sử hội thoại	`/v1/chat/completions`	Mảng `messages` tự nhiên hỗ trợ nhiều vòng
Gọi công cụ, gọi hàm	`/v1/chat/completions`	Cấu trúc định nghĩa công cụ và truyền kết quả chuẩn nhất
Tìm kiếm ngữ nghĩa, RAG, truy xuất tài liệu	`/v1/embeddings`	Trả về biểu diễn vector
Đầu ra có cấu trúc, JSON Schema	`/v1/chat/completions` hoặc `/v1/responses`	Kiểm soát qua tham số `response_format`

Lựa chọn endpoint cụ thể nên ưu tiên khả năng hỗ trợ tự nhiên của client và SDK. Nếu client yêu cầu một giao thức cụ thể, làm theo yêu cầu của client.

Cấu Hình SDK

OpenAI Python SDK

Cài đặt:

pip install openai

Cấu hình RouteAPI:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ROUTEAPI_KEY"],
    base_url="https://api.routeapi.ai/v1"
)

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "user", "content": "Vui lòng giới thiệu RouteAPI trong một câu"}
    ]
)

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

Chỉ cần thiết lập tham số api_key và base_url; tất cả mã khác giống hệt với API chính thức.

OpenAI Node.js SDK

Cài đặt:

npm install openai

Cấu hình RouteAPI:

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.ROUTEAPI_KEY,
  baseURL: 'https://api.routeapi.ai/v1'
});

const response = await client.chat.completions.create({
  model: 'gpt-5.5',
  messages: [
    { role: 'user', content: 'Vui lòng giới thiệu RouteAPI trong một câu' }
  ]
});

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

LangChain

Class ChatOpenAI của LangChain hỗ trợ base_url tùy chỉnh:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-5.5",
    openai_api_key=os.environ["ROUTEAPI_KEY"],
    openai_api_base="https://api.routeapi.ai/v1"
)

response = llm.invoke("Vui lòng giới thiệu RouteAPI trong một câu")
print(response.content)

LiteLLM

Hàm completion() của LiteLLM hỗ trợ api_base tùy chỉnh:

import litellm

response = litellm.completion(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Vui lòng giới thiệu RouteAPI trong một câu"}],
    api_key=os.environ["ROUTEAPI_KEY"],
    api_base="https://api.routeapi.ai/v1"
)

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

Các Client Tương Thích Khác

Bất kỳ client, công cụ hoặc framework nào hỗ trợ API OpenAI đều có thể tích hợp với RouteAPI thông qua cấu hình sau:

API Key thiết lập thành RouteAPI Token (bắt đầu bằng sk-)
Base URL thiết lập thành https://api.routeapi.ai/v1
Model ID sử dụng tên model được RouteAPI hỗ trợ (truy vấn qua /v1/models)

Tham Số Request Cốt Lõi

Các endpoint chính của giao thức tương thích OpenAI chia sẻ một tập hợp tham số cốt lõi. Dưới đây là bảng tham chiếu nhanh cho các tham số phổ biến; giải thích chi tiết có trong tài liệu chuyên dụng của từng endpoint.

Tham Số Chat Completions

Tham Số	Kiểu	Bắt Buộc	Mô Tả
`model`	string	Có	Model ID, phải có sẵn cho tài khoản hiện tại
`messages`	array	Có	Danh sách tin nhắn hội thoại, mỗi tin nhắn chứa `role` và `content`
`stream`	boolean	Không	Có sử dụng đầu ra streaming SSE hay không, mặc định `false`
`temperature`	number	Không	Nhiệt độ lấy mẫu, phạm vi `0` đến `2`, mặc định `1`
`top_p`	number	Không	Tham số nucleus sampling, phạm vi `0` đến `1`
`max_tokens`	number	Không	Token đầu ra tối đa (tên tham số cũ, vẫn được yêu cầu bởi một số model)
`max_completion_tokens`	number	Không	Token đầu ra tối đa (tên tham số mới)
`tools`	array	Không	Danh sách định nghĩa công cụ cho function calling
`tool_choice`	string/object	Không	Chiến lược chọn công cụ (`auto` / `required` / `none` / công cụ cụ thể)
`response_format`	object	Không	Ràng buộc định dạng đầu ra (chế độ JSON / JSON Schema)
`stream_options`	object	Không	Tùy chọn streaming bổ sung, chẳng hạn như `include_usage`
`stop`	string/array	Không	Chuỗi dừng tùy chỉnh
`presence_penalty`	number	Không	Phạt hiện diện, phạm vi `-2` đến `2`
`frequency_penalty`	number	Không	Phạt tần suất, phạm vi `-2` đến `2`
`user`	string	Không	Định danh người dùng cuối cho phát hiện lạm dụng

Để biết giải thích chi tiết và thêm tham số, tham khảo tài liệu Chat Completions.

Tham Số Embeddings

Tham Số	Kiểu	Bắt Buộc	Mô Tả
`model`	string	Có	Embedding model ID
`input`	string/array	Có	Văn bản để embedding, hỗ trợ chuỗi đơn hoặc mảng chuỗi
`encoding_format`	string	Không	Định dạng trả về, `float` (mặc định) hoặc `base64`
`dimensions`	number	Không	Số chiều vector đầu ra, phụ thuộc vào khả năng hỗ trợ của model
`user`	string	Không	Định danh người dùng cuối

Để biết giải thích chi tiết, tham khảo tài liệu Embeddings.

Định Dạng Response

Response Chuẩn (Không streaming)

Ví dụ response chuẩn Chat Completions:

{
  "id": "chatcmpl_xxx",
  "object": "chat.completion",
  "created": 1730000000,
  "model": "gpt-5.5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "RouteAPI là một API gateway thống nhất truy cập vào nhiều nhà cung cấp model AI."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 18,
    "total_tokens": 42
  }
}

Các trường chính:

choices[0].message.content — Phản hồi văn bản của model
choices[0].finish_reason — Lý do hoàn thành (stop / length / tool_calls / content_filter)
usage — Thống kê sử dụng token

Response Streaming (SSE)

Thiết lập stream: true trả về dữ liệu tăng dần ở định dạng Server-Sent Events (SSE):

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{"content":"RouteAPI"},"finish_reason":null}]}

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{"content":" là"},"finish_reason":null}]}

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":24,"completion_tokens":18,"total_tokens":42}}

data: [DONE]

Đặc điểm response streaming:

Mỗi dòng bắt đầu bằng data: theo sau là một đối tượng JSON
Nội dung tăng dần nằm trong choices[0].delta.content
Khi hoàn thành, finish_reason không phải null
Dòng cuối cùng là data: [DONE]

Nếu bạn cần thống kê sử dụng token trong chế độ streaming, thiết lập stream_options: { "include_usage": true }, và thông tin usage sẽ được trả về trong data chunk cuối cùng.

Response Lỗi

Response lỗi tuân theo định dạng chuẩn của OpenAI:

{
  "error": {
    "message": "Invalid API key provided",
    "type": "invalid_request_error",
    "code": "invalid_api_key"
  }
}

Các loại lỗi phổ biến:

Mã Trạng Thái HTTP	type	Mô Tả
401	`invalid_request_error`	API Key không hợp lệ hoặc thiếu
429	`rate_limit_error`	Vượt quá giới hạn tốc độ
500	`api_error`	Lỗi server nội bộ
503	`overloaded_error`	Dịch vụ quá tải

Để biết chi tiết xử lý lỗi, tham khảo tài liệu Xử Lý Lỗi.

Khác Biệt So Với API Chính Thức OpenAI

Giao thức tương thích OpenAI của RouteAPI hoàn toàn tương thích ở cấp độ giao thức, nhưng có một số khác biệt về khả năng model, thanh toán và giới hạn tốc độ:

Phạm Vi Model ID Rộng Hơn

API chính thức của OpenAI chỉ có thể gọi các model của chính OpenAI (gpt-4o, gpt-5.5, v.v.). RouteAPI hỗ trợ model từ nhiều nhà cung cấp:

OpenAI: gpt-4o, gpt-5.5, o3-mini, v.v.
Anthropic Claude: claude-sonnet-4-5, claude-opus-4, v.v.
Google Gemini: gemini-2.0-flash, gemini-2.5-pro, v.v.
Mistral: mistral-large, mistral-small, v.v.
Khác: DeepSeek, Qwen, LLaMA, v.v.

Truy vấn danh sách đầy đủ các model có sẵn cho tài khoản hiện tại qua endpoint /v1/models.

Thanh Toán và Giới Hạn Tốc Độ Được Quản Lý Bởi RouteAPI

Thanh toán: Tính phí theo bảng giá của RouteAPI, có thể khác với giá chính thức của nhà cung cấp upstream
Giới hạn tốc độ: Kiểm soát bởi chính sách giới hạn tốc độ của RouteAPI, không phải giới hạn của nhà cung cấp upstream
Hạn mức: Số dư tài khoản và hạn mức được quản lý bởi RouteAPI, nạp tiền và xem trong console

Hỗ Trợ Tham Số Phụ Thuộc Vào Model Cơ Bản

Giao thức tương thích OpenAI định nghĩa một tập hợp tham số đầy đủ, nhưng khả năng hỗ trợ thực tế phụ thuộc vào model được chọn:

Khả Năng	Mô Tả
Gọi công cụ (`tools`)	Phụ thuộc vào việc model có hỗ trợ function calling hay không
Đầu ra có cấu trúc (`response_format`)	Phụ thuộc vào việc model có hỗ trợ chế độ JSON hoặc JSON Schema hay không
Đầu vào hình ảnh (`image_url`)	Phụ thuộc vào việc model có hỗ trợ đầu vào đa phương thức hay không
Streaming usage (`stream_options.include_usage`)	Phụ thuộc vào việc model và kênh có hỗ trợ thống kê usage streaming hay không
Kiểm soát suy luận (`reasoning_effort`)	Chỉ được hỗ trợ bởi một số model suy luận

Khuyến nghị xác thực khả năng hỗ trợ của model đã chọn cho các tham số chính trong môi trường thử nghiệm trước khi bật trong môi trường production.

Xử Lý Tham Số Giá Trị Zero Tường Minh

Đây là một khác biệt tinh tế nhưng quan trọng. Trong giao thức tương thích OpenAI, nếu tham số tùy chọn được truyền tường minh là 0, 0.0 hoặc false, RouteAPI xem chúng như thiết lập tường minh của người dùng thay vì loại bỏ chúng như giá trị mặc định.

Ví dụ:

{
  "model": "gpt-5.5",
  "messages": [...],
  "temperature": 0,
  "top_p": 1.0
}

Ở đây, temperature: 0 sẽ được bảo toàn và chuyển tiếp đến model upstream, thay vì được xem như không thiết lập vì “giá trị là 0”. Điều này đảm bảo client có thể kiểm soát chính xác các tham số lấy mẫu.

Nếu bạn không muốn truyền một tham số nhất định, chỉ cần loại bỏ trường đó khỏi request; đừng truyền null hoặc 0.

Lưu Ý Tương Thích

Khả Năng Phụ Thuộc Vào Model Đã Chọn

Giao thức tương thích OpenAI là định nghĩa interface chuẩn, nhưng khả năng cụ thể phụ thuộc vào model cơ bản:

Gọi công cụ: Yêu cầu model hỗ trợ function calling, và định dạng định nghĩa công cụ phù hợp với yêu cầu model
Đầu ra có cấu trúc: Yêu cầu model hỗ trợ chế độ JSON hoặc JSON Schema
Đầu vào hình ảnh: Yêu cầu model hỗ trợ đầu vào hình ảnh hoặc đa phương thức
Streaming usage: Yêu cầu model và kênh hỗ trợ trả về sử dụng token trong chế độ streaming

Nếu request bao gồm tham số mà model không hỗ trợ, hành vi phụ thuộc vào loại tham số:

Tham số có thể bỏ qua (chẳng hạn như frequency_penalty) sẽ bị bỏ qua im lặng
Tham số quan trọng (chẳng hạn như tools) có thể kích hoạt lỗi

Trong môi trường production, khuyến nghị cố định model ID và chuẩn bị chiến lược dự phòng cho các luồng kinh doanh quan trọng.

Xác Thực Tham Số và Thông Báo Lỗi

RouteAPI thực hiện xác thực cơ bản trên các tham số request, chẳng hạn như:

Thiếu tham số bắt buộc (chẳng hạn như model, messages)
Loại tham số không chính xác (chẳng hạn như truyền chuỗi cho temperature)
Giá trị tham số ngoài phạm vi (chẳng hạn như temperature: 3)

Khi xác thực thất bại, nó trả về 400 Bad Request với thông tin lỗi chi tiết. Nếu request vượt qua xác thực của RouteAPI nhưng bị từ chối bởi model upstream, nó trả về 500 hoặc 502 cùng với thông báo lỗi gốc từ upstream.

Cân Nhắc Khi Di Chuyển Giữa Các Model

Khi chuyển từ model này sang model khác, ngay cả khi cả hai đều sử dụng giao thức tương thích OpenAI, các điểm sau cần chú ý:

Độ dài ngữ cảnh: Các model khác nhau có độ dài ngữ cảnh tối đa khác nhau; request quá dài có thể bị từ chối
Định dạng gọi công cụ: Một số model có yêu cầu nghiêm ngặt hơn về định dạng mô tả công cụ
Phong cách đầu ra: Cùng một prompt có thể tạo ra phong cách đầu ra, độ dài và định dạng khác nhau giữa các model
Đếm token: Các model khác nhau có tokenizer khác nhau; cùng một văn bản có thể có số lượng token khác nhau
Giá thanh toán: Các model khác nhau có đơn giá khác nhau; chuyển đổi model có thể ảnh hưởng đến chi phí

Khuyến nghị xác thực quy trình công việc hoàn chỉnh trong môi trường thử nghiệm trước khi chuyển đổi model trong môi trường production.

Endpoint /v1/models

Endpoint /v1/models trả về danh sách các model có sẵn cho tài khoản hiện tại, ở định dạng nhất quán với API chính thức của OpenAI.

Ví Dụ Request

curl https://api.routeapi.ai/v1/models \
  -H "Authorization: Bearer $ROUTEAPI_KEY"

Ví Dụ Response

{
  "success": true,
  "object": "list",
  "data": [
    {
      "id": "gpt-5.5",
      "object": "model",
      "created": 1626777600,
      "owned_by": "openai",
      "supported_endpoint_types": ["openai", "openai-response"]
    },
    {
      "id": "claude-sonnet-4-5",
      "object": "model",
      "created": 1626777600,
      "owned_by": "anthropic",
      "supported_endpoint_types": ["openai", "anthropic"]
    }
  ]
}

Mảng data được trả về chứa các model khả dụng với Token hiện tại, không phải toàn bộ danh mục của nền tảng. Mỗi đối tượng model bao gồm:

id — Model ID, sử dụng giá trị này khi thực hiện request
object — Cố định là "model"
owned_by — Loại kênh mà model thuộc về; model tự định nghĩa của nền tảng là custom
supported_endpoint_types — Trường mở rộng của RouteAPI, các loại endpoint dùng được với model này
created — Giá trị giữ chỗ cố định 1626777600, không phải thời điểm model thực sự lên kệ, đừng dùng nó để sắp xếp

Trường success thừa ra ở cấp cao nhất là phần mở rộng của RouteAPI; các OpenAI SDK chỉ đọc data nên không ảnh hưởng đến việc parse. Thứ tự các phần tử trong data không được đảm bảo ổn định.

Khuyến nghị gọi /v1/models một lần khi ứng dụng khởi động, cache danh sách model có sẵn, và tránh truy vấn trên mọi request. Ý nghĩa các trường và quy tắc lọc xem chi tiết tại Models.

Ví Dụ Đầy Đủ

curl Hội Thoại Cơ Bản

curl https://api.routeapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $ROUTEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "messages": [
      {
        "role": "system",
        "content": "Bạn là một trợ lý kỹ thuật nghiêm ngặt. Giữ câu trả lời ngắn gọn."
      },
      {
        "role": "user",
        "content": "Vui lòng giới thiệu RouteAPI trong một câu"
      }
    ],
    "temperature": 0.7
  }'

Ví Dụ Đầy Đủ Python SDK

import os
from openai import OpenAI

# Khởi tạo client
client = OpenAI(
    api_key=os.environ["ROUTEAPI_KEY"],
    base_url="https://api.routeapi.ai/v1"
)

# Hội thoại cơ bản
def basic_chat():
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "system", "content": "Bạn là một trợ lý kỹ thuật nghiêm ngặt."},
            {"role": "user", "content": "Vui lòng giới thiệu RouteAPI trong một câu"}
        ],
        temperature=0.7
    )
    print(response.choices[0].message.content)
    print(f"Usage: {response.usage.total_tokens} tokens")

# Hội thoại streaming
def streaming_chat():
    stream = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "user", "content": "Giải thích từng bước API gateway là gì"}
        ],
        stream=True,
        stream_options={"include_usage": True}
    )

    for chunk in stream:
        if chunk.choices:
            delta = chunk.choices[0].delta
            if delta.content:
                print(delta.content, end="", flush=True)
        # Chunk cuối cùng chứa usage
        if hasattr(chunk, 'usage') and chunk.usage:
            print(f"\nUsage: {chunk.usage.total_tokens} tokens")

# Gọi công cụ
def tool_calling():
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Truy vấn thời tiết hiện tại cho một thành phố cụ thể",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string",
                            "description": "Tên thành phố, ví dụ: Hà Nội"
                        },
                        "unit": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]
                        }
                    },
                    "required": ["city"]
                }
            }
        }
    ]

    messages = [{"role": "user", "content": "Thời tiết ở Hà Nội bây giờ như thế nào?"}]

    # Vòng đầu tiên: model yêu cầu gọi công cụ
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )

    # Kiểm tra gọi công cụ
    if response.choices[0].message.tool_calls:
        # Mô phỏng thực thi công cụ
        tool_call = response.choices[0].message.tool_calls[0]
        tool_result = "Hà Nội, nắng, nhiệt độ 23 độ C, độ ẩm 45%."

        # Xây dựng request vòng thứ hai
        messages.append(response.choices[0].message)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": tool_result
        })

        # Vòng thứ hai: model tạo response dựa trên kết quả công cụ
        final_response = client.chat.completions.create(
            model="gpt-5.5",
            messages=messages,
            tools=tools
        )
        print(final_response.choices[0].message.content)

# Đầu ra có cấu trúc
def structured_output():
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "user", "content": "Trích xuất thông tin chính từ văn bản sau: RouteAPI là một AI API gateway hỗ trợ OpenAI, Claude, Gemini và các model khác."}
        ],
        response_format={
            "type": "json_schema",
            "json_schema": {
                "name": "key_info",
                "strict": True,
                "schema": {
                    "type": "object",
                    "properties": {
                        "product_name": {"type": "string"},
                        "category": {"type": "string"},
                        "supported_models": {
                            "type": "array",
                            "items": {"type": "string"}
                        }
                    },
                    "required": ["product_name", "category", "supported_models"],
                    "additionalProperties": False
                }
            }
        }
    )
    print(response.choices[0].message.content)

if __name__ == "__main__":
    basic_chat()
    print("\n" + "="*50 + "\n")
    streaming_chat()
    print("\n" + "="*50 + "\n")
    tool_calling()
    print("\n" + "="*50 + "\n")
    structured_output()

Ví Dụ Đầy Đủ Node.js SDK

import OpenAI from 'openai';

// Khởi tạo client
const client = new OpenAI({
  apiKey: process.env.ROUTEAPI_KEY,
  baseURL: 'https://api.routeapi.ai/v1'
});

// Hội thoại cơ bản
async function basicChat() {
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      { role: 'system', content: 'Bạn là một trợ lý kỹ thuật nghiêm ngặt.' },
      { role: 'user', content: 'Vui lòng giới thiệu RouteAPI trong một câu' }
    ],
    temperature: 0.7
  });

  console.log(response.choices[0].message.content);
  console.log(`Usage: ${response.usage.total_tokens} tokens`);
}

// Hội thoại streaming
async function streamingChat() {
  const stream = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      { role: 'user', content: 'Giải thích từng bước API gateway là gì' }
    ],
    stream: true,
    stream_options: { include_usage: true }
  });

  for await (const chunk of stream) {
    if (chunk.choices[0]?.delta?.content) {
      process.stdout.write(chunk.choices[0].delta.content);
    }
    if (chunk.usage) {
      console.log(`\nUsage: ${chunk.usage.total_tokens} tokens`);
    }
  }
}

// Gọi công cụ
async function toolCalling() {
  const tools = [
    {
      type: 'function',
      function: {
        name: 'get_weather',
        description: 'Truy vấn thời tiết hiện tại cho một thành phố cụ thể',
        parameters: {
          type: 'object',
          properties: {
            city: {
              type: 'string',
              description: 'Tên thành phố, ví dụ: Hà Nội'
            },
            unit: {
              type: 'string',
              enum: ['celsius', 'fahrenheit']
            }
          },
          required: ['city']
        }
      }
    }
  ];

  const messages = [
    { role: 'user', content: "Thời tiết ở Hà Nội bây giờ như thế nào?" }
  ];

  // Vòng đầu tiên
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: messages,
    tools: tools,
    tool_choice: 'auto'
  });

  // Kiểm tra gọi công cụ
  if (response.choices[0].message.tool_calls) {
    const toolCall = response.choices[0].message.tool_calls[0];
    const toolResult = 'Hà Nội, nắng, nhiệt độ 23 độ C, độ ẩm 45%.';

    // Vòng thứ hai
    messages.push(response.choices[0].message);
    messages.push({
      role: 'tool',
      tool_call_id: toolCall.id,
      content: toolResult
    });

    const finalResponse = await client.chat.completions.create({
      model: 'gpt-5.5',
      messages: messages,
      tools: tools
    });

    console.log(finalResponse.choices[0].message.content);
  }
}

// Đầu ra có cấu trúc
async function structuredOutput() {
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      {
        role: 'user',
        content: 'Trích xuất thông tin chính từ văn bản sau: RouteAPI là một AI API gateway hỗ trợ OpenAI, Claude, Gemini và các model khác.'
      }
    ],
    response_format: {
      type: 'json_schema',
      json_schema: {
        name: 'key_info',
        strict: true,
        schema: {
          type: 'object',
          properties: {
            product_name: { type: 'string' },
            category: { type: 'string' },
            supported_models: {
              type: 'array',
              items: { type: 'string' }
            }
          },
          required: ['product_name', 'category', 'supported_models'],
          additionalProperties: false
        }
      }
    }
  });

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

// Chạy ví dụ
async function main() {
  await basicChat();
  console.log('\n' + '='.repeat(50) + '\n');
  await streamingChat();
  console.log('\n' + '='.repeat(50) + '\n');
  await toolCalling();
  console.log('\n' + '='.repeat(50) + '\n');
  await structuredOutput();
}

main().catch(console.error);

Khuyến Nghị Tích Hợp

Ưu tiên giao thức tương thích OpenAI nếu client, SDK hoặc công cụ của bạn hỗ trợ API OpenAI tự nhiên
Cố định model ID, đừng dựa vào alias tạm thời hoặc tên hiển thị trong môi trường production
Ghi lại metadata request, bao gồm request ID, model ID, mã trạng thái, độ trễ và sử dụng token
Bật thử lại khi thất bại, bật thử lại client và tùy chọn model thay thế cho các luồng kinh doanh cốt lõi
Xác thực khả năng tùy chọn, kiểm tra gọi công cụ, đầu ra có cấu trúc, đầu vào hình ảnh và các khả năng khác trong môi trường thử nghiệm trước
Giám sát chi phí và hạn mức, thường xuyên kiểm tra nhật ký sử dụng và chi tiết thanh toán trong console
Bảo vệ API Key, đóng gói RouteAPI Token ở phía server và tránh lộ key trực tiếp cho frontend kinh doanh

Nếu client chỉ hỗ trợ giao thức Claude Messages hoặc Google Gemini, sử dụng các endpoint giao thức tương ứng; tham khảo tài liệu Claude Messages và Gemini API.