# 测试连接
curl http://ylxunlapi.top/v1/models \
  -H "Authorization: Bearer sk-你的APIKey"

# 发送对话
curl http://ylxunlapi.top/v1/chat/completions \
  -H "Authorization: Bearer sk-你的APIKey" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role": "user", "content": "你好，请介绍一下你自己"}],
    "temperature": 0.7
  }'

from openai import OpenAI

client = OpenAI(
    api_key="sk-你的平台APIKey",
    base_url="http://ylxunlapi.top/v1"
)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "你好，请介绍一下你自己"}],
    temperature=0.7,
    max_tokens=1024
)

print(response.choices[0].message.content)
# 查看用量
print(f"消耗 tokens: {response.usage.total_tokens}")

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "sk-你的平台APIKey",
  baseURL: "http://ylxunlapi.top/v1",
});

const completion = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "你好" }],
  temperature: 0.7,
  max_tokens: 1024,
});

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

Authorization: Bearer sk-你的APIKey

{
  "messages": [
    {"role": "system", "content": "你是一个有用的AI助手。"},
    {"role": "user", "content": "帮我翻译这段话：Hello World"},
    {"role": "assistant", "content": "你好，世界"},
    {"role": "user", "content": "换一种更文艺的翻译"}
  ]
}

{
  "id": "chatcmpl-xxx",
  "object": "chat.completion",
  "created": 1700000000,
  "model": "gpt-4o-mini",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "你好！我是一个AI助手..."
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 45,
    "total_tokens": 63
  }
}

from openai import OpenAI

client = OpenAI(
    api_key="sk-你的APIKey",
    base_url="http://ylxunlapi.top/v1"
)

stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "写一首关于夏天的诗"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()  # 流结束换行

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "sk-你的APIKey",
  baseURL: "http://ylxunlapi.top/v1",
});

const stream = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "写一首关于夏天的诗" }],
  stream: true,
});

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

curl http://ylxunlapi.top/v1/chat/completions \
  -H "Authorization: Bearer sk-你的APIKey" \
  -H "Content-Type: application/json" \
  -N \
  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"Hello"}],"stream":true}'

curl http://ylxunlapi.top/v1/models \
  -H "Authorization: Bearer sk-你的APIKey"

# Python
models = client.models.list()
for m in models.data:
    print(m.id)

package main

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

func main() {
    config := openai.DefaultConfig("sk-你的APIKey")
    config.BaseURL = "http://ylxunlapi.top/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateChatCompletion(context.Background(), openai.ChatCompletionRequest{
        Model: "gpt-4o-mini",
        Messages: []openai.ChatCompletionMessage{
            {Role: "user", Content: "Hello!"},
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.Choices[0].Message.Content)
}

// application.yml
openai:
  api-key: sk-你的APIKey
  base-url: http://ylxunlapi.top/v1

// ChatService.java
@Service
public class ChatService {
    private final OpenAiClient client;

    public ChatService(OpenAiClient client) {
        this.client = client;
    }

    public String chat(String prompt) {
        var request = ChatCompletionRequest.builder()
            .model("gpt-4o-mini")
            .messages(List.of(
                new ChatMessage("user", prompt)
            ))
            .build();
        return client.chatCompletion(request)
            .execute()
            .choices().get(0).message().content();
    }
}

<?php
require 'vendor/autoload.php';

$client = OpenAI::factory()
    ->withApiKey('sk-你的APIKey')
    ->withBaseUri('http://ylxunlapi.top/v1')
    ->make();

$result = $client->chat()->create([
    'model' => 'gpt-4o-mini',
    'messages' => [
        ['role' => 'user', 'content' => 'Hello!'],
    ],
]);

echo $result->choices[0]->message->content;

use async_openai::{
    Client,
    config::OpenAIConfig,
    types::CreateChatCompletionRequestArgs,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = OpenAIConfig::default()
        .with_api_key("sk-你的APIKey")
        .with_api_base("http://ylxunlapi.top/v1");

    let client = Client::with_config(config);

    let request = CreateChatCompletionRequestArgs::default()
        .model("gpt-4o-mini")
        .messages(vec![
            ("user", "Hello!").into(),
        ])
        .build()?;

    let response = client.chat().create(request).await?;
    println!("{}", response.choices[0].message.content
        .as_ref().unwrap_or(&"".to_string()));

    Ok(())
}

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4o-mini",
    openai_api_key="sk-你的APIKey",
    openai_api_base="http://ylxunlapi.top/v1",
    temperature=0.7,
)

response = llm.invoke("Hello!")
print(response.content)

import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  model: "gpt-4o-mini",
  apiKey: "sk-你的APIKey",
  configuration: {
    baseURL: "http://ylxunlapi.top/v1",
  },
});

const response = await model.invoke("Hello!");
console.log(response.content);

# .env
OPENAI_API_KEY=sk-你的APIKey
OPENAI_PROXY_URL=http://ylxunlapi.top/v1

OPENAI_API_KEY=sk-你的APIKey
BASE_URL=http://ylxunlapi.top

API Base URL: http://ylxunlapi.top/v1
API Key: sk-你的APIKey

名称：AI Token 中转站
接入模式：纯 API
配置模型：gpt-4o-mini
Base URL：http://ylxunlapi.top/v1
Key：sk-你的平台APIKey
上游协议：Chat Completions
模型列表：点击「从上游获取」自动填充

response = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[{"role": "user", "content": "9.11 和 9.8 哪个大？"}],
    max_tokens=4096  # 推理模型建议设置较大值
)

# 仅输出最终回答，思考过程已由平台过滤
print(response.choices[0].message.content)