curl -X POST "https://xxx.yisu.com/v1/chat/completions" \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "model": "gpt-3.5-turbo",
        "messages": [
          {"role": "system", "content": "你是一个有用的AI助手。"},
          {"role": "user", "content": "你好！请介绍一下自己。"}
        ],
        "temperature": 0.7,
        "max_tokens": 1000
      }'

    from openai import OpenAI

    # 初始化客户端
    client = OpenAI(
        api_key="YOUR_API_KEY",
        base_url="https://xxx.yisu.com/v1"
    )

    # 发送聊天请求
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "你是一个有用的AI助手。"},
            {"role": "user", "content": "你好！请介绍一下自己。"}
        ],
        temperature=0.7,
        max_tokens=1000
    )

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

    import requests
    import json

    url = "https://xxx.yisu.com/v1/chat/completions"
    headers = {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    }

    data = {
        "model": "gpt-3.5-turbo",
        "messages": [
            {"role": "system", "content": "你是一个有用的AI助手。"},
            {"role": "user", "content": "你好！请介绍一下自己。"}
        ],
        "temperature": 0.7,
        "max_tokens": 1000
    }

    response = requests.post(url, headers=headers, json=data)
    result = response.json

    if response.status_code == 200:
        print(result["choices"][0]["message"]["content"])
    else:
        print(f"错误: {result}")

    const OpenAI = require('openai');

    const client = new OpenAI({
      apiKey: 'YOUR_API_KEY',
      baseURL: 'https://xxx.yisu.com/v1'
    });

    async function chatCompletion {
      try {
        const response = await client.chat.completions.create({
          model: 'gpt-3.5-turbo',
          messages: [
            {"role": "system", "content": "你是一个有用的AI助手。"},
            {"role": "user", "content": "你好！请介绍一下自己。"}
          ],
          temperature: 0.7,
          max_tokens: 1000
        });
        
        console.log(response.choices[0].message.content);
      } catch (error) {
        console.error('API调用错误:', error);
      }
    }

    chatCompletion;

    import okhttp3.*;
    import com.google.gson.Gson;
    import java.io.IOException;
    import java.util.*;

    public class APIYiExample {
        private static final String API_KEY = "YOUR_API_KEY";
        private static final String BASE_URL = "https://xxx.yisu.com/v1";
        
        public static void main(String[] args) throws IOException {
            OkHttpClient client = new OkHttpClient;
            Gson gson = new Gson;
            
            // 构建请求体
            Map<String, Object> requestBody = new HashMap<>;
            requestBody.put("model", "gpt-3.5-turbo");
            requestBody.put("temperature", 0.7);
            requestBody.put("max_tokens", 1000);
            
            List<Map<String, String>> messages = Arrays.asList(
                Map.of("role", "system", "content", "你是一个有用的AI助手。"),
                Map.of("role", "user", "content", "你好！请介绍一下自己。")
            );
            requestBody.put("messages", messages);
            
            RequestBody body = RequestBody.create(
                gson.toJson(requestBody),
                MediaType.parse("application/json")
            );
            
            Request request = new Request.Builder
                .url(BASE_URL + "/chat/completions")
                .addHeader("Authorization", "Bearer " + API_KEY)
                .addHeader("Content-Type", "application/json")
                .post(body)
                .build;
            
            try (Response response = client.newCall(request).execute) {
                System.out.println(response.body.string);
            }
        }
    }

    using System;
    using System.Net.Http;
    using System.Text;
    using System.Threading.Tasks;
    using Newtonsoft.Json;

    class Program
    {
        private static readonly string API_KEY = "YOUR_API_KEY";
        private static readonly string BASE_URL = "https://xxx.yisu.com/v1";
        
        static async Task Main(string[] args)
        {
            using var client = new HttpClient;
            client.DefaultRequestHeaders.Add("Authorization", $"Bearer {API_KEY}");
            
            var requestBody = new
            {
                model = "gpt-3.5-turbo",
                messages = new[]
                {
                    new { role = "system", content = "你是一个有用的AI助手。" },
                    new { role = "user", content = "你好！请介绍一下自己。" }
                },
                temperature = 0.7,
                max_tokens = 1000
            };
            
            var json = JsonConvert.SerializeObject(requestBody);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            
            try
            {
                var response = await client.PostAsync($"{BASE_URL}/chat/completions", content);
                var result = await response.Content.ReadAsStringAsync;
                Console.WriteLine(result);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"错误: {ex.Message}");
            }
        }
    }

    package main

    import (
        "bytes"
        "encoding/json"
        "fmt"
        "io/ioutil"
        "net/http"
    )

    type Message struct {
        Role    string `json:"role"`
        Content string `json:"content"`
    }

    type ChatRequest struct {
        Model       string    `json:"model"`
        Messages    []Message `json:"messages"`
        Temperature float64   `json:"temperature"`
        MaxTokens   int       `json:"max_tokens"`
    }

    func main {
        apiKey := "YOUR_API_KEY"
        baseURL := "https://xxx.yisu.com/v1"
        
        reqData := ChatRequest{
            Model: "gpt-3.5-turbo",
            Messages: []Message{
                {Role: "system", Content: "你是一个有用的AI助手。"},
                {Role: "user", Content: "你好！请介绍一下自己。"},
            },
            Temperature: 0.7,
            MaxTokens:   1000,
        }
        
        jsonData, _ := json.Marshal(reqData)
        
        req, _ := http.NewRequest("POST", baseURL+"/chat/completions", bytes.NewBuffer(jsonData))
        req.Header.Set("Authorization", "Bearer "+apiKey)
        req.Header.Set("Content-Type", "application/json")
        
        client := &http.Client{}
        resp, err := client.Do(req)
        if err != nil {
            fmt.Printf("请求错误: %v\n", err)
            return
        }
        defer resp.Body.Close
        
        body, _ := ioutil.ReadAll(resp.Body)
        fmt.Println(string(body))
    }

    <?php
    $api_key = 'YOUR_API_KEY';
    $base_url = 'https://xxx.yisu.com/v1';

    $data = array(
        'model' => 'gpt-3.5-turbo',
        'messages' => array(
            array('role' => 'system', 'content' => '你是一个有用的AI助手。'),
            array('role' => 'user', 'content' => '你好！请介绍一下自己。')
        ),
        'temperature' => 0.7,
        'max_tokens' => 1000
    );

    $ch = curl_init;
    curl_setopt($ch, CURLOPT_URL, $base_url . '/chat/completions');
    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_HTTPHEADER, array(
        'Authorization: Bearer ' . $api_key,
        'Content-Type: application/json'
    ));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($http_code == 200) {
        $result = json_decode($response, true);
        echo $result['choices'][0]['message']['content'];
    } else {
        echo "错误: " . $response;
    }
    ?>

    require 'net/http'
    require 'json'

    api_key = 'YOUR_API_KEY'
    base_url = 'https://xxx.yisu.com/v1'

    uri = URI("#{base_url}/chat/completions")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = Net::HTTP::Post.new(uri)
    request['Authorization'] = "Bearer #{api_key}"
    request['Content-Type'] = 'application/json'

    request.body = {
      model: 'gpt-3.5-turbo',
      messages: [
        { role: 'system', content: '你是一个有用的AI助手。' },
        { role: 'user', content: '你好！请介绍一下自己。' }
      ],
      temperature: 0.7,
      max_tokens: 1000
    }.to_json

    response = http.request(request)

    if response.code == '200'
      result = JSON.parse(response.body)
      puts result['choices'][0]['message']['content']
    else
      puts "错误: #{response.body}"
    end

    curl -X POST "https://xxx.yisu.com/v1/embeddings" \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "model": "text-embedding-ada-002",
        "input": "这是一段需要向量化的文本示例"
      }'

    from openai import OpenAI

    client = OpenAI(
        api_key="YOUR_API_KEY",
        base_url="https://xxx.yisu.com/v1"
    )

    response = client.embeddings.create(
        model="text-embedding-ada-002",
        input="这是一段需要向量化的文本示例"
    )

    # 获取向量
    embedding = response.data[0].embedding
    print(f"向量维度: {len(embedding)}")
    print(f"前5个值: {embedding[:5]}")

    import requests
    import json

    url = "https://xxx.yisu.com/v1/embeddings"
    headers = {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    }

    data = {
        "model": "text-embedding-ada-002",
        "input": "这是一段需要向量化的文本示例"
    }

    response = requests.post(url, headers=headers, json=data)
    result = response.json

    if response.status_code == 200:
        embedding = result["data"][0]["embedding"]
        print(f"向量维度: {len(embedding)}")
        print(f"向量值: {embedding[:5]}")  # 显示前5个值
    else:
        print(f"错误: {result}")

    const OpenAI = require('openai');

    const client = new OpenAI({
      apiKey: 'YOUR_API_KEY',
      baseURL: 'https://xxx.yisu.com/v1'
    });

    async function getEmbedding {
      try {
        const response = await client.embeddings.create({
          model: 'text-embedding-ada-002',
          input: '这是一段需要向量化的文本示例'
        });
        
        const embedding = response.data[0].embedding;
        console.log(`向量维度: ${embedding.length}`);
        console.log(`前5个值: ${embedding.slice(0, 5)}`);
      } catch (error) {
        console.error('API调用错误:', error);
      }
    }

    getEmbedding;

    curl -X POST "https://xxx.yisu.com/v1/images/generations" \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "model": "gpt-image-1",
        "prompt": "一只可爱的橙色小猫坐在阳光明媚的花园里",
        "n": 1,
        "size": "1024x1024",
        "quality": "hd"
      }'

    from openai import OpenAI

    client = OpenAI(
        api_key="YOUR_API_KEY",
        base_url="https://xxx.yisu.com/v1"
    )

    response = client.images.generate(
        model="gpt-image-1",  # 推荐使用gpt-image-1
        prompt="一只可爱的橙色小猫坐在阳光明媚的花园里",
        n=1,
        size="1024x1024",
        quality="hd"
    )

    # 获取图片URL
    image_url = response.data[0].url
    print(f"生成的图片: {image_url}")

    # 下载图片
    import requests
    img_response = requests.get(image_url)
    with open("generated_image.png", "wb") as f:
        f.write(img_response.content)
    print("图片已保存为 generated_image.png")

    const OpenAI = require('openai');
    const fs = require('fs');

    const client = new OpenAI({
      apiKey: 'YOUR_API_KEY',
      baseURL: 'https://xxx.yisu.com/v1'
    });

    async function generateImage {
      try {
        const response = await client.images.generate({
          model: 'gpt-image-1',  // 推荐使用gpt-image-1
          prompt: '一只可爱的橙色小猫坐在阳光明媚的花园里',
          n: 1,
          size: '1024x1024',
          quality: 'hd'
        });
        
        const imageUrl = response.data[0].url;
        console.log('生成的图片:', imageUrl);
        
        // 下载图片
        const fetch = require('node-fetch');
        const imgResponse = await fetch(imageUrl);
        const buffer = await imgResponse.buffer;
        fs.writeFileSync('generated_image.png', buffer);
        console.log('图片已保存');
        
      } catch (error) {
        console.error('生成图片错误:', error);
      }
    }

    generateImage;

    import requests
    import json

    response = requests.post(
        'https://xxx.yisu.com/v1/chat/completions',
        headers={
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        },
        json={
            'model': 'gpt-3.5-turbo',
            'messages': [{'role': 'user', 'content': 'Hello'}],
            'stream': True
        },
        stream=True
    )

    for line in response.iter_lines:
        if line:
            line = line.decode('utf-8')
            if line.startswith('data: '):
                data = line[6:]
                if data != '[DONE]':
                    chunk = json.loads(data)
                    content = chunk['choices'][0]['delta'].get('content', '')
                    print(content, end='')

    const response = await fetch('https://xxx.yisu.com/v1/chat/completions', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        model: 'gpt-3.5-turbo',
        messages: [{role: 'user', content: 'Hello'}],
        stream: true
      })
    });

    const reader = response.body.getReader;
    const decoder = new TextDecoder;

    while (true) {
      const {done, value} = await reader.read;
      if (done) break;
      
      const chunk = decoder.decode(value);
      const lines = chunk.split('\n');
      
      for (const line of lines) {
        if (line.startsWith('data: ')) {
          const data = line.slice(6);
          if (data !== '[DONE]') {
            const json = JSON.parse(data);
            const content = json.choices[0].delta.content || '';
            process.stdout.write(content);
          }
        }
      }
    }