关于go-deepseek库的使用实践

这个库封装了DeepSeek API的调用，使用起来比较简洁。以下是一些实际使用中的关键点和示例：

1. 基础聊天完成示例

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    
    "github.com/p9966/go-deepseek"
)

func main() {
    // 从环境变量获取API密钥
    apiKey := os.Getenv("DEEPSEEK_API_KEY")
    if apiKey == "" {
        log.Fatal("DEEPSEEK_API_KEY environment variable is required")
    }
    
    client := deepseek.NewClient(apiKey)
    
    // 创建聊天请求
    request := deepseek.ChatCompletionRequest{
        Model: deepseek.DeepSeekChat,
        Messages: []deepseek.ChatCompletionMessage{
            {
                Role:    deepseek.ChatMessageRoleSystem,
                Content: "你是一个专业的Go语言助手",
            },
            {
                Role:    deepseek.ChatMessageRoleUser,
                Content: "请解释Go中的context包的作用",
            },
        },
        MaxTokens: 1000,
        Temperature: 0.7,
    }
    
    ctx := context.Background()
    resp, err := client.CreateChatCompletion(ctx, &request)
    if err != nil {
        log.Fatalf("ChatCompletion failed: %v", err)
    }
    
    fmt.Printf("回复: %s\n", resp.Choices[0].Message.Content)
}

2. 流式响应处理

func streamChatCompletion(client *deepseek.Client) error {
    request := deepseek.ChatCompletionRequest{
        Model: deepseek.DeepSeekChat,
        Messages: []deepseek.ChatCompletionMessage{
            {
                Role:    deepseek.ChatMessageRoleUser,
                Content: "用Go写一个简单的HTTP服务器",
            },
        },
        Stream: true,
    }
    
    ctx := context.Background()
    stream, err := client.CreateChatCompletionStream(ctx, &request)
    if err != nil {
        return err
    }
    defer stream.Close()
    
    for {
        response, err := stream.Recv()
        if err != nil {
            if err == io.EOF {
                break
            }
            return err
        }
        
        if len(response.Choices) > 0 {
            fmt.Print(response.Choices[0].Delta.Content)
        }
    }
    
    fmt.Println()
    return nil
}

3. 带错误重试的封装函数

type ChatClient struct {
    client *deepseek.Client
    maxRetries int
}

func NewChatClient(apiKey string, maxRetries int) *ChatClient {
    return &ChatClient{
        client: deepseek.NewClient(apiKey),
        maxRetries: maxRetries,
    }
}

func (c *ChatClient) SendMessageWithRetry(ctx context.Context, messages []deepseek.ChatCompletionMessage) (string, error) {
    request := deepseek.ChatCompletionRequest{
        Model: deepseek.DeepSeekChat,
        Messages: messages,
        MaxTokens: 2000,
    }
    
    var lastErr error
    for i := 0; i < c.maxRetries; i++ {
        resp, err := c.client.CreateChatCompletion(ctx, &request)
        if err != nil {
            lastErr = err
            time.Sleep(time.Duration(i+1) * time.Second) // 指数退避
            continue
        }
        
        if len(resp.Choices) > 0 {
            return resp.Choices[0].Message.Content, nil
        }
    }
    
    return "", fmt.Errorf("failed after %d retries: %v", c.maxRetries, lastErr)
}

// 使用示例
func main() {
    client := NewChatClient(os.Getenv("DEEPSEEK_API_KEY"), 3)
    
    messages := []deepseek.ChatCompletionMessage{
        {
            Role:    deepseek.ChatMessageRoleUser,
            Content: "帮我优化这段Go代码",
        },
    }
    
    response, err := client.SendMessageWithRetry(context.Background(), messages)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println(response)
}

4. 并发请求处理

func batchProcessQueries(client *deepseek.Client, queries []string) ([]string, error) {
    var wg sync.WaitGroup
    results := make([]string, len(queries))
    errs := make([]error, len(queries))
    
    for i, query := range queries {
        wg.Add(1)
        go func(idx int, q string) {
            defer wg.Done()
            
            request := deepseek.ChatCompletionRequest{
                Model: deepseek.DeepSeekChat,
                Messages: []deepseek.ChatCompletionMessage{
                    {
                        Role:    deepseek.ChatMessageRoleUser,
                        Content: q,
                    },
                },
            }
            
            ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
            defer cancel()
            
            resp, err := client.CreateChatCompletion(ctx, &request)
            if err != nil {
                errs[idx] = err
                return
            }
            
            if len(resp.Choices) > 0 {
                results[idx] = resp.Choices[0].Message.Content
            }
        }(i, query)
    }
    
    wg.Wait()
    
    // 检查是否有错误
    for _, err := range errs {
        if err != nil {
            return nil, err
        }
    }
    
    return results, nil
}

5. 结构化输出解析

type CodeReview struct {
    Issues     []string `json:"issues"`
    Suggestions []string `json:"suggestions"`
    Score      int      `json:"score"`
}

func reviewGoCode(client *deepseek.Client, code string) (*CodeReview, error) {
    prompt := fmt.Sprintf(`请审查这段Go代码，以JSON格式返回结果：
{
    "issues": ["问题1", "问题2"],
    "suggestions": ["建议1", "建议2"],
    "score": 85
}

代码：
%s`, code)
    
    request := deepseek.ChatCompletionRequest{
        Model: deepseek.DeepSeekChat,
        Messages: []deepseek.ChatCompletionMessage{
            {
                Role:    deepseek.ChatMessageRoleUser,
                Content: prompt,
            },
        },
        ResponseFormat: &deepseek.ResponseFormat{
            Type: "json_object",
        },
    }
    
    ctx := context.Background()
    resp, err := client.CreateChatCompletion(ctx, &request)
    if err != nil {
        return nil, err
    }
    
    var review CodeReview
    if err := json.Unmarshal([]byte(resp.Choices[0].Message.Content), &review); err != nil {
        return nil, fmt.Errorf("failed to parse response: %v", err)
    }
    
    return &review, nil
}

关键注意事项：

1. API密钥管理：建议使用环境变量或安全的密钥管理服务
2. 错误处理：API调用可能因网络或服务问题失败，需要适当的重试机制
3. 上下文管理：为长时间运行的请求设置超时
4. 速率限制：注意DeepSeek API的调用频率限制
5. 资源清理：流式响应需要显式关闭连接

这个库的接口设计遵循了OpenAI SDK的模式，对于熟悉OpenAI Go客户端的开发者来说上手很快。实际使用中需要注意错误处理和资源管理。