DeepSeek 完整教程

package main

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

type DeepSeekClient struct {
    apiKey     string
    baseURL    string
    httpClient *http.Client
}

type ChatRequest struct {
    Model       string    `json:"model"`
    Messages    []Message `json:"messages"`
    Temperature float32   `json:"temperature"`
    MaxTokens   int       `json:"max_tokens,omitempty"`
    Stream      bool      `json:"stream"`
}

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

type ChatResponse struct {
    ID      string `json:"id"`
    Choices []struct {
        Message      Message `json:"message"`
        FinishReason string  `json:"finish_reason"`
    } `json:"choices"`
    Usage struct {
        PromptTokens     int `json:"prompt_tokens"`
        CompletionTokens int `json:"completion_tokens"`
        TotalTokens      int `json:"total_tokens"`
    } `json:"usage"`
}

func NewDeepSeekClient(apiKey string) *DeepSeekClient {
    return &DeepSeekClient{
        apiKey:  apiKey,
        baseURL: "https://api.deepseek.com",
        httpClient: &http.Client{
            Timeout: 60 * time.Second,
        },
    }
}

func (c *DeepSeekClient) Chat(ctx context.Context, messages []Message) (string, error) {
    reqBody := ChatRequest{
        Model:       "deepseek-chat",
        Messages:    messages,
        Temperature: 0.7,
        MaxTokens:   2000,
        Stream:      false,
    }
    
    jsonData, err := json.Marshal(reqBody)
    if err != nil {
        return "", err
    }
    
    req, err := http.NewRequestWithContext(
        ctx,
        "POST",
        c.baseURL+"/chat/completions",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        return "", err
    }
    
    req.Header.Set("Authorization", "Bearer "+c.apiKey)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := c.httpClient.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != 200 {
        body, _ := io.ReadAll(resp.Body)
        return "", fmt.Errorf("API错误 %d: %s", resp.StatusCode, string(body))
    }
    
    var chatResp ChatResponse
    if err := json.NewDecoder(resp.Body).Decode(&chatResp); err != nil {
        return "", err
    }
    
    if len(chatResp.Choices) == 0 {
        return "", fmt.Errorf("无返回结果")
    }
    
    fmt.Printf("[Token] Prompt=%d, Completion=%d, Total=%d\n",
        chatResp.Usage.PromptTokens,
        chatResp.Usage.CompletionTokens,
        chatResp.Usage.TotalTokens)
    
    return chatResp.Choices[0].Message.Content, nil
}

func main() {
    client := NewDeepSeekClient("sk-your-api-key")
    
    messages := []Message{
        {Role: "system", Content: "你是一个有帮助的AI助手"},
        {Role: "user", Content: "Go语言的优势是什么？"},
    }
    
    answer, err := client.Chat(context.Background(), messages)
    if err != nil {
        panic(err)
    }
    
    fmt.Println("回答：", answer)
}