OpenAI API 接口与 Spring AI 对应关系

# 请求头格式
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "role": "system|user|assistant",
  "content": "消息内容"
}

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-4",
    "messages": [
      {"role": "system", "content": "你是一个乐于助人的助手。"},
      {"role": "user", "content": "你好！"}
    ],
    "temperature": 0.7,
    "max_tokens": 1000,
    "top_p": 0.9,
    "stream": false
  }'

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "gpt-4",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "你好！有什么我可以帮助您的吗？"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 15,
    "completion_tokens": 10,
    "total_tokens": 25
  }
}

curl https://api.openai.com/v1/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "text-davinci-003",
    "prompt": "请写一首关于春天的诗。",
    "max_tokens": 100,
    "temperature": 0.7,
    "top_p": 0.9
  }'

{
  "id": "cmpl-abc123",
  "object": "text_completion",
  "created": 1677652288,
  "model": "text-davinci-003",
  "choices": [
    {
      "text": "春天来了，万物复苏，花儿绽放，鸟儿歌唱。",
      "index": 0,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 20,
    "total_tokens": 30
  }
}

curl https://api.openai.com/v1/embeddings \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "text-embedding-ada-002",
    "input": "机器学习的基本概念",
    "encoding_format": "float",
    "dimensions": 1536
  }'

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "embedding": [0.123, 0.456, -0.789, ...],
      "index": 0
    }
  ],
  "model": "text-embedding-ada-002",
  "usage": {
    "prompt_tokens": 5,
    "total_tokens": 5
  }
}

curl https://api.openai.com/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "dall-e-3",
    "prompt": "一只可爱的猫在花园里玩耍",
    "n": 1,
    "size": "1024x1024",
    "quality": "standard",
    "response_format": "url",
    "style": "vivid"
  }'

{
  "created": 1677652288,
  "data": [
    {
      "url": "https://oaidalleapiprodscus.blob.core.windows.net/private/...",
      "revised_prompt": "一只可爱的猫在花园里玩耍，背景是美丽的花朵"
    }
  ]
}

curl https://api.openai.com/v1/audio/transcriptions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F file="@audio.mp3" \
  -F model="whisper-1" \
  -F language="zh" \
  -F response_format="json" \
  -F temperature=0.0

{
  "text": "想象一下你曾经有过的最疯狂的想法，并且你想知道它如何扩展到100倍、1000倍的规模。"
}

curl https://api.openai.com/v1/audio/speech \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "tts-1",
    "input": "你好，欢迎使用语音服务！",
    "voice": "alloy",
    "response_format": "mp3",
    "speed": 1.0
  }'

curl -X POST https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-4",
    "messages": [{"role": "user", "content": "讲一个故事"}],
    "stream": true
  }'

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

POST https://api.openai.com/v1/chat/completions
{
  "model": "gpt-4",
  "messages": [
    {"role": "system", "content": "你是一个助手"},
    {"role": "user", "content": "你好"}
  ],
  "temperature": 0.7,
  "max_tokens": 1000
}

// 配置
@Configuration
public class OpenAiConfig {
    
    @Bean
    public OpenAiChatModel openAiChatModel() {
        return new OpenAiChatModel(
            new OpenAiApi("your-api-key", "https://api.openai.com"),
            OpenAiChatOptions.builder()
                .withModel("gpt-4")
                .withTemperature(0.7f)
                .withMaxTokens(1000)
                .withTopP(0.9f)
                .withFrequencyPenalty(0.0f)
                .withPresencePenalty(0.0f)
                .withStop(Arrays.asList("Human:", "AI:"))
                .withN(1)
                .withUser("spring-ai-app")
                .build()
        );
    }
    
    @Bean
    public ChatClient chatClient(OpenAiChatModel chatModel) {
        return ChatClient.create(chatModel);
    }
}

// 使用
@RestController
public class ChatController {
    
    private final ChatClient chatClient;
    
    public ChatController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }
    
    @PostMapping("/chat")
    public String chat(@RequestBody String message) {
        return chatClient.prompt()
            .system("你是一个助手")
            .user(message)
            .call()
            .content();
    }
    
    // 流式处理
    @PostMapping(value = "/stream", produces = MediaType.TEXT_PLAIN_VALUE)
    public ResponseEntity<StreamingResponseBody> streamChat(@RequestBody String message) {
        return ResponseEntity.ok()
            .contentType(MediaType.TEXT_PLAIN)
            .body(outputStream -> {
                chatClient.prompt()
                    .user(message)
                    .stream()
                    .content()
                    .forEach(content -> {
                        try {
                            outputStream.write(content.getBytes());
                            outputStream.flush();
                        } catch (IOException e) {
                            throw new RuntimeException(e);
                        }
                    });
            });
    }
}

POST https://api.openai.com/v1/completions
{
  "model": "text-davinci-003",
  "prompt": "写一首诗",
  "max_tokens": 100,
  "temperature": 0.7
}

// 配置
@Configuration
public class CompletionConfig {
    
    @Bean
    public OpenAiCompletionModel openAiCompletionModel() {
        return new OpenAiCompletionModel(
            new OpenAiApi("your-api-key", "https://api.openai.com"),
            OpenAiCompletionOptions.builder()
                .withModel("text-davinci-003")
                .withTemperature(0.7f)
                .withMaxTokens(100)
                .withTopP(0.9f)
                .withFrequencyPenalty(0.0f)
                .withPresencePenalty(0.0f)
                .withStop(Arrays.asList("\n\n"))
                .withN(1)
                .withUser("spring-ai-app")
                .build()
        );
    }
}

// 使用
@Service
public class CompletionService {
    
    private final OpenAiCompletionModel completionModel;
    
    public String complete(String prompt) {
        return completionModel.call(prompt);
    }
}

POST https://api.openai.com/v1/embeddings
{
  "model": "text-embedding-ada-002",
  "input": "机器学习的基本概念",
  "encoding_format": "float",
  "dimensions": 1536
}

// 配置
@Configuration
public class EmbeddingConfig {
    
    @Bean
    public OpenAiEmbeddingModel openAiEmbeddingModel() {
        return new OpenAiEmbeddingModel(
            new OpenAiApi("your-api-key", "https://api.openai.com"),
            OpenAiEmbeddingOptions.builder()
                .withModel("text-embedding-ada-002")
                .withEncodingFormat("float")
                .withDimensions(1536)
                .withUser("spring-ai-app")
                .build()
        );
    }
}

// 使用
@Service
public class EmbeddingService {
    
    private final OpenAiEmbeddingModel embeddingModel;
    
    public List<Double> embed(String text) {
        return embeddingModel.embed(text);
    }
    
    public List<List<Double>> embed(List<String> texts) {
        return embeddingModel.embed(texts);
    }
    
    // 批量嵌入
    public EmbeddingResponse embedBatch(List<String> texts) {
        return embeddingModel.call(texts);
    }
}

POST https://api.openai.com/v1/images/generations
{
  "model": "dall-e-3",
  "prompt": "一只可爱的猫",
  "n": 1,
  "size": "1024x1024",
  "quality": "standard",
  "response_format": "url",
  "style": "vivid"
}

// 配置
@Configuration
public class ImageConfig {
    
    @Bean
    public OpenAiImageModel openAiImageModel() {
        return new OpenAiImageModel(
            new OpenAiApi("your-api-key", "https://api.openai.com"),
            OpenAiImageOptions.builder()
                .withModel("dall-e-3")
                .withN(1)
                .withSize("1024x1024")
                .withQuality("standard")
                .withResponseFormat("url")
                .withStyle("vivid")
                .withUser("spring-ai-app")
                .build()
        );
    }
}

// 使用
@Service
public class ImageService {
    
    private final OpenAiImageModel imageModel;
    
    public ImageResponse generateImage(String prompt) {
        return imageModel.call(prompt);
    }
    
    // 生成多张图片
    public ImageResponse generateImages(String prompt, int count) {
        return imageModel.call(OpenAiImagePrompt.builder()
            .withPrompt(prompt)
            .withN(count)
            .build());
    }
}

POST https://api.openai.com/v1/audio/transcriptions
-F file="@audio.mp3"
-F model="whisper-1"
-F language="zh"
-F response_format="json"
-F temperature=0.0

// 配置
@Configuration
public class AudioConfig {
    
    @Bean
    public OpenAiAudioTranscriptionModel openAiAudioTranscriptionModel() {
        return new OpenAiAudioTranscriptionModel(
            new OpenAiApi("your-api-key", "https://api.openai.com"),
            OpenAiAudioTranscriptionOptions.builder()
                .withModel("whisper-1")
                .withLanguage("zh")
                .withResponseFormat("json")
                .withTemperature(0.0f)
                .withTimestampGranularities(Arrays.asList("word", "segment"))
                .withUser("spring-ai-app")
                .build()
        );
    }
}

// 使用
@Service
public class AudioService {
    
    private final OpenAiAudioTranscriptionModel transcriptionModel;
    
    public String transcribe(Resource audioFile) {
        return transcriptionModel.call(audioFile);
    }
    
    // 从文件路径转录
    public String transcribeFromFile(String filePath) {
        Resource audioFile = new FileSystemResource(filePath);
        return transcriptionModel.call(audioFile);
    }
}

POST https://api.openai.com/v1/audio/speech
{
  "model": "tts-1",
  "input": "你好，欢迎使用语音服务！",
  "voice": "alloy",
  "response_format": "mp3",
  "speed": 1.0
}

// 配置
@Configuration
public class TTSConfig {
    
    @Bean
    public OpenAiAudioSpeechModel openAiAudioSpeechModel() {
        return new OpenAiAudioSpeechModel(
            new OpenAiApi("your-api-key", "https://api.openai.com"),
            OpenAiAudioSpeechOptions.builder()
                .withModel("tts-1")
                .withVoice("alloy")
                .withResponseFormat("mp3")
                .withSpeed(1.0f)
                .withUser("spring-ai-app")
                .build()
        );
    }
}

// 使用
@Service
public class TTSService {
    
    private final OpenAiAudioSpeechModel speechModel;
    
    public byte[] synthesize(String text) {
        return speechModel.call(text);
    }
    
    // 保存为文件
    public void synthesizeToFile(String text, String outputPath) {
        byte[] audioData = speechModel.call(text);
        try {
            Files.write(Paths.get(outputPath), audioData);
        } catch (IOException e) {
            throw new RuntimeException("保存音频文件失败", e);
        }
    }
}