POST https://api.openai.com/v1/chat/completions

{
  "model": "gpt-4",
  "messages": [{"role": "user", "content": "你好"}]
}

// PlatformConfig 统一的大模型接口配置抽象
// 无论哪家厂商，都只需要这三个字段
type PlatformConfig struct {
    ApiKey  string `yaml:"api_key"`
    Model   string `yaml:"model"`
    BaseURL string `yaml:"base_url"`
}

// LLMConfig 管理所有厂商的配置集合
type LLMConfig struct {
    EmbeddingModel string                    `yaml:"embedding_model"` // 专用于 Embedding 的提供商
    Default        string                    `yaml:"default"`         // 兜底默认厂商名称
    Provider       map[string]PlatformConfig `yaml:"provider"`        // 厂商名 -> 配置
}

llm:
  embedding_model: "gemini"   # 哪个厂商专门用于向量化
  default: "deepseek"         # 找不到指定厂商时的兜底

  provider:
    gemini:
      api_key: "your-gemini-api-key"
      model: "gemini-2.0-flash"
      base_url: "https://generativelanguage.googleapis.com/v1beta/openai/"

    deepseek:
      api_key: "your-deepseek-api-key"
      model: "deepseek-chat"
      base_url: "https://api.deepseek.com"

    qwen:
      api_key: "your-qwen-api-key"
      model: "qwen-plus"
      base_url: "https://dashscope.aliyuncs.com/compatible-mode/v1"

    doubao:
      api_key: "your-doubao-api-key"
      model: "doubao-pro-4k"
      base_url: "https://ark.cn-beijing.volces.com/api/v3"

// GetConfigByName 根据提供商名字获取配置
// 如果找不到指定名称，或者名称为空，则返回 Default 兜底
func (l *LLMConfig) GetConfigByName(name string) PlatformConfig {
    if cfg, ok := l.Provider[name]; ok && name != "" {
        return cfg
    }
    // 兜底：返回 Default 配置
    return l.Provider[l.Default]
}

// 每个实体可以独立指定它使用哪家厂商的模型
providerName := entity.Provider  // 比如 "gemini" 或 "deepseek"
cfg := config.LLM.GetConfigByName(providerName)

// 拿到 apiKey、model、baseURL 之后就可以调用了
result, err := callLLM(ctx, cfg.ApiKey, cfg.BaseURL, cfg.Model, prompt)

var (
    mu      sync.Mutex
    clients = make(map[string]*openai.Client)
)

// GetOpenAIClient 获取或创建一个单例客户端
// 对于同一个 baseURL + apiKey 组合，永远返回同一个实例
func GetOpenAIClient(apiKey string, baseURL string) *openai.Client {
    mu.Lock()
    defer mu.Unlock()

    // 用 baseURL 和 apiKey 拼成唯一的 key
    key := baseURL + "|" + apiKey

    // 如果池子里已经有这个厂商的客户端，直接复用
    if cli, ok := clients[key]; ok {
        return cli
    }

    // 没有则新建，并缓存进池子
    config := openai.DefaultConfig(apiKey)
    if baseURL != "" {
        config.BaseURL = baseURL
    }

    cli := openai.NewClientWithConfig(config)
    clients[key] = cli

    return cli
}

// CallChat 通用的 LLM 聊天接口，兼容所有 OpenAI 协议的厂商
func CallChat(ctx context.Context, apiKey, baseURL, model, prompt string) (string, error) {
    client := GetOpenAIClient(apiKey, baseURL)

    req := openai.ChatCompletionRequest{
        Model: model,
        // 强制要求返回 JSON 格式（并非所有厂商都支持，需要测试）
        ResponseFormat: &openai.ChatCompletionResponseFormat{
            Type: openai.ChatCompletionResponseFormatTypeJSONObject,
        },
        Messages: []openai.ChatCompletionMessage{
            {
                Role:    openai.ChatMessageRoleUser,
                Content: prompt,
            },
        },
    }

    resp, err := client.CreateChatCompletion(ctx, req)
    if err != nil {
        return "", fmt.Errorf("LLM API call failed: %w", err)
    }

    if len(resp.Choices) == 0 {
        return "", fmt.Errorf("LLM returned no choices")
    }

    return resp.Choices[0].Message.Content, nil
}

YAML 配置
    ↓
GetConfigByName("deepseek")  →  PlatformConfig{ApiKey, Model, BaseURL}
    ↓
GetOpenAIClient(apiKey, baseURL)  →  复用或新建客户端
    ↓
CallChat(ctx, apiKey, baseURL, model, prompt)  →  string 返回值

func CallChat(ctx context.Context, ...) (string, error) {
    // 为这次调用创建独立的超时，不影响其他并发调用
    callCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()

    resp, err := client.CreateChatCompletion(callCtx, req)
    // ...
}