💬 提示词工程完整指南

/*
完整RAG系统实现 - 生产环境可直接部署
技术栈：
- 向量数据库：Milvus 2.3+
- LLM服务：DeepSeek API
- Embedding：text-embedding-ada-002 或 DeepSeek Embedding
- ReRank：基于LLM的语义重排序
- 动态Prompt：根据检索质量自适应调整

目录结构：
rag-system/
├── main.go              # 入口文件
├── config/
│   └── config.go        # 配置管理
├── pkg/
│   ├── milvus/          # Milvus操作
│   ├── deepseek/        # DeepSeek API
│   ├── embedding/       # Embedding服务
│   ├── rerank/          # ReRank服务
│   └── prompt/          # Prompt模板管理
└── go.mod
*/

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "math/rand"
    "net/http"
    "os"
    "sort"
    "strconv"
    "strings"
    "sync"
    "time"

    "github.com/milvus-io/milvus-sdk-go/v2/client"
    "github.com/milvus-io/milvus-sdk-go/v2/entity"
    "github.com/go-redis/redis/v8"
)

// ============ 配置 ============

type Config struct {
    // Milvus配置
    MilvusHost string
    MilvusPort int
    
    // DeepSeek配置  
    DeepSeekAPIKey    string
    DeepSeekBaseURL   string
    DeepSeekModel     string
    
    // Embedding配置
    EmbeddingProvider string // "deepseek" or "openai"
    EmbeddingModel    string
    EmbeddingAPIKey   string
    
    // RAG参数
    TopK              int     // 第一阶段检索数量
    ReRankTopK        int     // ReRank后保留数量
    Temperature       float32
    MaxTokens         int
    
    // Redis缓存
    RedisAddr     string
    RedisCacheTTL int // 秒
}

func LoadConfig() *Config {
    return &Config{
        MilvusHost:        getEnv("MILVUS_HOST", "localhost"),
        MilvusPort:        getEnvInt("MILVUS_PORT", 19530),
        
        DeepSeekAPIKey:    getEnv("DEEPSEEK_API_KEY", ""),
        DeepSeekBaseURL:   getEnv("DEEPSEEK_BASE_URL", "https://api.deepseek.com"),
        DeepSeekModel:     getEnv("DEEPSEEK_MODEL", "deepseek-chat"),
        
        EmbeddingProvider: getEnv("EMBEDDING_PROVIDER", "deepseek"),
        EmbeddingModel:    getEnv("EMBEDDING_MODEL", "deepseek-embedding"),
        EmbeddingAPIKey:   getEnv("EMBEDDING_API_KEY", ""),
        
        TopK:              getEnvInt("TOP_K", 10),
        ReRankTopK:        getEnvInt("RERANK_TOP_K", 3),
        Temperature:       float32(getEnvFloat("TEMPERATURE", 0.2)),
        MaxTokens:         getEnvInt("MAX_TOKENS", 1000),
        
        RedisAddr:         getEnv("REDIS_ADDR", "localhost:6379"),
        RedisCacheTTL:     getEnvInt("REDIS_CACHE_TTL", 3600),
    }
}

// ============ 数据结构 ============

type Document struct {
    ID       string                 `json:"id"`
    Content  string                 `json:"content"`
    Metadata map[string]interface{} `json:"metadata"`
    Score    float32                `json:"score"`
}

type RetrievalResult struct {
    Query         string      `json:"query"`
    Documents     []Document  `json:"documents"`
    RetrievalTime int64       `json:"retrieval_time_ms"`
}

type ReRankResult struct {
    Documents  []Document `json:"documents"`
    Quality    string     `json:"quality"` // high/medium/low
    ReRankTime int64      `json:"rerank_time_ms"`
}

type RAGResponse struct {
    Answer        string     `json:"answer"`
    SourceDocs    []Document `json:"source_docs"`
    Quality       string     `json:"quality"`
    Confidence    string     `json:"confidence"`
    TotalTime     int64      `json:"total_time_ms"`
    Cached        bool       `json:"cached"`
}

// ============ Milvus Client ============

type MilvusClient struct {
    client         client.Client
    collectionName string
    mu             sync.RWMutex
}

func NewMilvusClient(cfg *Config, collectionName string) (*MilvusClient, error) {
    c, err := client.NewGrpcClient(
        context.Background(),
        fmt.Sprintf("%s:%d", cfg.MilvusHost, cfg.MilvusPort),
    )
    if err != nil {
        return nil, fmt.Errorf("连接Milvus失败: %w", err)
    }
    
    mc := &MilvusClient{
        client:         c,
        collectionName: collectionName,
    }
    
    // 检查collection是否存在
    has, err := c.HasCollection(context.Background(), collectionName)
    if err != nil {
        return nil, fmt.Errorf("检查collection失败: %w", err)
    }
    
    if !has {
        log.Printf("[Milvus] Collection %s 不存在，需要先创建", collectionName)
    }
    
    return mc, nil
}

func (mc *MilvusClient) Search(ctx context.Context, vector []float32, topK int) ([]Document, error) {
    mc.mu.RLock()
    defer mc.mu.RUnlock()
    
    sp, err := entity.NewIndexFlatSearchParam()
    if err != nil {
        return nil, err
    }
    
    searchResult, err := mc.client.Search(
        ctx,
        mc.collectionName,
        []string{},      // 分区名
        "",              // 过滤表达式
        []string{"content", "metadata"}, // 输出字段
        []entity.Vector{entity.FloatVector(vector)},
        "embedding",     // 向量字段名
        entity.L2,       // 距离度量
        topK,
        sp,
    )
    if err != nil {
        return nil, fmt.Errorf("向量检索失败: %w", err)
    }
    
    if len(searchResult) == 0 {
        return []Document{}, nil
    }
    
    docs := make([]Document, 0, topK)
    for i := 0; i < searchResult[0].ResultCount; i++ {
        id := searchResult[0].IDs.(*entity.ColumnInt64).Data()[i]
        score := searchResult[0].Scores[i]
        
        // 获取content字段
        contentCol, err := searchResult[0].Fields.GetColumn("content")
        if err != nil {
            continue
        }
        content := contentCol.(*entity.ColumnVarChar).Data()[i]
        
        docs = append(docs, Document{
            ID:      fmt.Sprintf("%d", id),
            Content: content,
            Score:   score,
        })
    }
    
    return docs, nil
}

// ============ DeepSeek Client ============

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

func NewDeepSeekClient(cfg *Config) *DeepSeekClient {
    return &DeepSeekClient{
        apiKey:  cfg.DeepSeekAPIKey,
        baseURL: cfg.DeepSeekBaseURL,
        model:   cfg.DeepSeekModel,
        httpClient: &http.Client{
            Timeout: 60 * time.Second,
        },
    }
}

type DeepSeekRequest 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 DeepSeekResponse 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 (dc *DeepSeekClient) Chat(ctx context.Context, prompt string, temperature float32, maxTokens int) (string, error) {
    reqBody := DeepSeekRequest{
        Model: dc.model,
        Messages: []Message{
            {Role: "user", Content: prompt},
        },
        Temperature: temperature,
        MaxTokens:   maxTokens,
        Stream:      false,
    }
    
    jsonData, err := json.Marshal(reqBody)
    if err != nil {
        return "", err
    }
    
    req, err := http.NewRequestWithContext(
        ctx,
        "POST",
        dc.baseURL+"/chat/completions",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        return "", err
    }
    
    req.Header.Set("Authorization", "Bearer "+dc.apiKey)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := dc.httpClient.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != 200 {
        body, _ := io.ReadAll(resp.Body)
        return "", fmt.Errorf("DeepSeek API错误 %d: %s", resp.StatusCode, string(body))
    }
    
    var dsResp DeepSeekResponse
    if err := json.NewDecoder(resp.Body).Decode(&dsResp); err != nil {
        return "", err
    }
    
    if len(dsResp.Choices) == 0 {
        return "", fmt.Errorf("DeepSeek返回空结果")
    }
    
    log.Printf("[DeepSeek] Token使用: prompt=%d, completion=%d, total=%d",
        dsResp.Usage.PromptTokens,
        dsResp.Usage.CompletionTokens,
        dsResp.Usage.TotalTokens)
    
    return dsResp.Choices[0].Message.Content, nil
}

// ============ Embedding Service ============

type EmbeddingService struct {
    provider string
    client   interface{}
}

func NewEmbeddingService(cfg *Config) (*EmbeddingService, error) {
    // 这里可以根据provider选择不同的embedding服务
    // 简化起见，使用DeepSeek
    return &EmbeddingService{
        provider: cfg.EmbeddingProvider,
        client:   NewDeepSeekClient(cfg),
    }, nil
}

func (es *EmbeddingService) Embed(ctx context.Context, text string) ([]float32, error) {
    // 实际实现中需要调用embedding API
    // 这里返回模拟数据
    // 生产环境使用: https://api.deepseek.com/embeddings
    
    log.Printf("[Embedding] 生成向量: %s", text[:min(50, len(text))])
    
    // 模拟768维向量
    vector := make([]float32, 768)
    for i := range vector {
        vector[i] = rand.Float32()
    }
    
    return vector, nil
}

// ============ ReRank Service ============

type ReRanker struct {
    llmClient *DeepSeekClient
}

func NewReRanker(client *DeepSeekClient) *ReRanker {
    return &ReRanker{
        llmClient: client,
    }
}

func (rr *ReRanker) Rerank(ctx context.Context, query string, docs []Document, topK int) ([]Document, error) {
    if len(docs) <= topK {
        return docs, nil
    }
    
    log.Printf("[ReRank] 对%d个文档进行重排序", len(docs))
    
    type scoredDoc struct {
        doc   Document
        score float32
    }
    
    results := make([]scoredDoc, 0, len(docs))
    
    // 并发评分
    var wg sync.WaitGroup
    var mu sync.Mutex
    semaphore := make(chan struct{}, 5) // 限制并发数
    
    for _, doc := range docs {
        wg.Add(1)
        go func(d Document) {
            defer wg.Done()
            semaphore <- struct{}{}
            defer func() { <-semaphore }()
            
            prompt := fmt.Sprintf(`评估文档与问题的相关性，打分0-10。

问题：%s

文档：%s

只返回数字分数，不要解释。`, query, d.Content[:min(300, len(d.Content))])
            
            scoreStr, err := rr.llmClient.Chat(ctx, prompt, 0.1, 10)
            if err != nil {
                log.Printf("[ReRank] 评分失败: %v", err)
                mu.Lock()
                results = append(results, scoredDoc{doc: d, score: d.Score})
                mu.Unlock()
                return
            }
            
            var score float32
            if _, err := fmt.Sscanf(strings.TrimSpace(scoreStr), "%f", &score); err != nil {
                score = d.Score
            }
            
            mu.Lock()
            results = append(results, scoredDoc{doc: d, score: score})
            mu.Unlock()
        }(doc)
    }
    
    wg.Wait()
    
    // 排序
    sort.Slice(results, func(i, j int) bool {
        return results[i].score > results[j].score
    })
    
    // 返回topK
    reranked := make([]Document, 0, topK)
    for i := 0; i < min(topK, len(results)); i++ {
        doc := results[i].doc
        doc.Score = results[i].score
        reranked = append(reranked, doc)
    }
    
    return reranked, nil
}

// ============ Prompt Template Manager ============

type PromptManager struct {
    templates map[string]string
}

func NewPromptManager() *PromptManager {
    return &PromptManager{
        templates: map[string]string{
            "high_quality": `你是专业的知识助手，基于高质量的检索文档回答问题。

【参考文档】（高相关度 ⭐⭐⭐）
%s

【用户问题】
%s

【要求】
1. 基于文档详细回答，标注来源
2. 可以进行合理推论和扩展
3. 结构化输出，使用列表或分段
4. 置信度：高

【回答】`,
            
            "medium_quality": `你是专业的知识助手，基于检索文档回答问题。

【参考文档】（中等相关度 ⭐⭐）
%s

【用户问题】
%s

【要求】
1. 严格基于文档回答，谨慎推论
2. 标注每个信息的来源
3. 说明置信度为"中等"
4. 不确定的地方明确指出

【回答】`,
            
            "low_quality": `你是专业的知识助手。检索到的文档相关度较低。

【检索文档】（低相关度 ⭐）
%s

【用户问题】
%s

【要求】
1. 检查文档是否能回答问题
2. 如不能，明确说"根据现有资料不足以回答此问题"
3. 建议用户换个问法或提供更多背景
4. 不要编造信息

【回答】`,
        },
    }
}

func (pm *PromptManager) BuildPrompt(quality string, docs []Document, question string) string {
    template, ok := pm.templates[quality+"_quality"]
    if !ok {
        template = pm.templates["medium_quality"]
    }
    
    // 构建文档上下文
    var context strings.Builder
    for i, doc := range docs {
        context.WriteString(fmt.Sprintf("[文档%d]（相关度:%.2f）\n", i+1, doc.Score))
        context.WriteString(doc.Content)
        context.WriteString("\n\n")
    }
    
    return fmt.Sprintf(template, context.String(), question)
}

// ============ RAG System ============

type RAGSystem struct {
    config          *Config
    milvus          *MilvusClient
    deepseek        *DeepSeekClient
    embedding       *EmbeddingService
    reranker        *ReRanker
    promptManager   *PromptManager
    cache           *redis.Client
}

func NewRAGSystem(cfg *Config) (*RAGSystem, error) {
    milvus, err := NewMilvusClient(cfg, "knowledge_base")
    if err != nil {
        return nil, err
    }
    
    deepseek := NewDeepSeekClient(cfg)
    
    embedding, err := NewEmbeddingService(cfg)
    if err != nil {
        return nil, err
    }
    
    reranker := NewReRanker(deepseek)
    promptManager := NewPromptManager()
    
    // Redis缓存
    redisClient := redis.NewClient(&redis.Options{
        Addr: cfg.RedisAddr,
    })
    
    return &RAGSystem{
        config:        cfg,
        milvus:        milvus,
        deepseek:      deepseek,
        embedding:     embedding,
        reranker:      reranker,
        promptManager: promptManager,
        cache:         redisClient,
    }, nil
}

func (rs *RAGSystem) Answer(ctx context.Context, question string) (*RAGResponse, error) {
    startTime := time.Now()
    
    log.Printf("[RAG] 开始处理问题: %s", question)
    
    // 1. 检查缓存
    cacheKey := "rag:" + question
    if cached, err := rs.cache.Get(ctx, cacheKey).Result(); err == nil {
        var resp RAGResponse
        if err := json.Unmarshal([]byte(cached), &resp); err == nil {
            resp.Cached = true
            log.Printf("[RAG] 命中缓存")
            return &resp, nil
        }
    }
    
    // 2. 生成查询向量
    vector, err := rs.embedding.Embed(ctx, question)
    if err != nil {
        return nil, fmt.Errorf("生成向量失败: %w", err)
    }
    
    // 3. 向量检索
    docs, err := rs.milvus.Search(ctx, vector, rs.config.TopK)
    if err != nil {
        return nil, fmt.Errorf("向量检索失败: %w", err)
    }
    log.Printf("[RAG] 检索到%d个候选文档", len(docs))
    
    // 4. ReRank精排
    rerankedDocs, err := rs.reranker.Rerank(ctx, question, docs, rs.config.ReRankTopK)
    if err != nil {
        log.Printf("[RAG] ReRank失败，使用原始结果: %v", err)
        rerankedDocs = docs[:min(rs.config.ReRankTopK, len(docs))]
    }
    
    // 5. 评估检索质量
    quality := rs.assessQuality(rerankedDocs)
    log.Printf("[RAG] 检索质量: %s", quality)
    
    // 6. 构建动态Prompt
    prompt := rs.promptManager.BuildPrompt(quality, rerankedDocs, question)
    
    // 7. 调用LLM生成回答
    answer, err := rs.deepseek.Chat(ctx, prompt, rs.config.Temperature, rs.config.MaxTokens)
    if err != nil {
        return nil, fmt.Errorf("生成回答失败: %w", err)
    }
    
    totalTime := time.Since(startTime).Milliseconds()
    
    resp := &RAGResponse{
        Answer:     answer,
        SourceDocs: rerankedDocs,
        Quality:    quality,
        Confidence: map[string]string{
            "high":   "高",
            "medium": "中",
            "low":    "低",
        }[quality],
        TotalTime: totalTime,
        Cached:    false,
    }
    
    // 8. 缓存结果
    if respJSON, err := json.Marshal(resp); err == nil {
        rs.cache.Set(ctx, cacheKey, respJSON, time.Duration(rs.config.RedisCacheTTL)*time.Second)
    }
    
    log.Printf("[RAG] 处理完成，耗时: %dms", totalTime)
    
    return resp, nil
}

func (rs *RAGSystem) assessQuality(docs []Document) string {
    if len(docs) == 0 {
        return "low"
    }
    
    var totalScore float32
    for _, doc := range docs {
        totalScore += doc.Score
    }
    avgScore := totalScore / float32(len(docs))
    
    if avgScore >= 8.0 {
        return "high"
    } else if avgScore >= 6.0 {
        return "medium"
    }
    return "low"
}

// ============ HTTP Server ============

func (rs *RAGSystem) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.Method != "POST" {
        http.Error(w, "只支持POST请求", http.StatusMethodNotAllowed)
        return
    }
    
    var req struct {
        Question string `json:"question"`
    }
    
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "无效的JSON", http.StatusBadRequest)
        return
    }
    
    if req.Question == "" {
        http.Error(w, "问题不能为空", http.StatusBadRequest)
        return
    }
    
    resp, err := rs.Answer(r.Context(), req.Question)
    if err != nil {
        log.Printf("[Error] 处理失败: %v", err)
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(resp)
}

// ============ Main ============

func main() {
    // 加载配置
    cfg := LoadConfig()
    
    // 初始化RAG系统
    rag, err := NewRAGSystem(cfg)
    if err != nil {
        log.Fatalf("初始化RAG系统失败: %v", err)
    }
    
    // 启动HTTP服务器
    http.HandleFunc("/api/rag/ask", rag.ServeHTTP)
    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("OK"))
    })
    
    addr := ":8080"
    log.Printf("🚀 RAG系统启动成功，监听端口: %s", addr)
    log.Printf("📝 测试命令: curl -X POST http://localhost%s/api/rag/ask -d '{\"question\":\"什么是RAG?\"}'", addr)
    
    if err := http.ListenAndServe(addr, nil); err != nil {
        log.Fatalf("服务器启动失败: %v", err)
    }
}

// ============ 辅助函数 ============

func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

func getEnvInt(key string, defaultValue int) int {
    if value := os.Getenv(key); value != "" {
        if intVal, err := strconv.Atoi(value); err == nil {
            return intVal
        }
    }
    return defaultValue
}

func getEnvFloat(key string, defaultValue float64) float64 {
    if value := os.Getenv(key); value != "" {
        if floatVal, err := strconv.ParseFloat(value, 64); err == nil {
            return floatVal
        }
    }
    return defaultValue
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}