第2周：Go RAG系统 - 完整概览#

// internal/rag/chunker.go
type Chunk struct {
	ID       string            `json:"id"`
	DocID    string            `json:"doc_id"`
	Title    string            `json:"title"`
	Section  string            `json:"section"`
	Text     string            `json:"text"`
	Source   string            `json:"source"`
	Metadata map[string]string `json:"metadata"`
}

type Chunker struct {
	chunkSize    int
	overlapSize  int
}

func (c *Chunker) ChunkDocument(doc *Document) []Chunk {
	// 1. 按\n\n分段落
	// 2. 如果段落太长，继续按sentence分
	// 3. 加metadata（来源、章节等）
	// 4. 生成ID（hash(content)）
}

// 输出 chunks.jsonl
func WriteChunksToJSONL(path string, chunks []Chunk) error {
	// 每行一个Chunk的JSON
}

// internal/rag/embedding.go
type EmbeddingClient interface {
	Embed(ctx context.Context, texts []string) ([][]float32, error)
}

type EmbeddingRequest struct {
	Texts      []string
	Model      string
	RequestID  string
}

// internal/rag/vector_store.go
type VectorStore interface {
	Upsert(ctx context.Context, chunks []ChunkWithEmbedding) error
	Search(ctx context.Context, embedding []float32, topK int) ([]Chunk, error)
}

type PgvectorStore struct {
	db *sql.DB
}

func (vs *PgvectorStore) Search(ctx context.Context, embedding []float32, topK int) ([]Chunk, error) {
	// SELECT * FROM chunks 
	// ORDER BY embedding <-> $1 
	// LIMIT $2
}

// internal/rag/keyword_search.go
type KeywordSearcher interface {
	Search(ctx context.Context, query string, topK int) ([]Chunk, []float32, error)
}

// 简单实现：contains + TF-IDF
func (ks *SimpleKeywordSearcher) Search(ctx context.Context, query string, topK int) ([]Chunk, []float32, error) {
	// 1. 分词：query → ["word1", "word2"]
	// 2. 在chunks里搜索包含这些词的
	// 3. 计算相关度得分
	// 4. 排序、截断
}

// internal/rag/hybrid.go
type HybridRetriever struct {
	vectorSearcher   VectorSearcher
	keywordSearcher  KeywordSearcher
	vectorWeight     float32  // 0.6
	keywordWeight    float32  // 0.4
}

func (hr *HybridRetriever) Search(ctx context.Context, query string, topK int) ([]Chunk, error) {
	// 1. 向量搜索topK个
	vectorResults, vectorScores := hr.vectorSearcher.Search(...)
	
	// 2. 关键词搜索topK个
	keywordResults, keywordScores := hr.keywordSearcher.Search(...)
	
	// 3. 合并 + 去重
	merged := merge(vectorResults, keywordResults)
	
	// 4. 归一化得分
	for i, chunk := range merged {
		normalizedScore := 
			hr.vectorWeight * normalize(vectorScores[chunk.ID]) +
			hr.keywordWeight * normalize(keywordScores[chunk.ID])
		merged[i].Score = normalizedScore
	}
	
	// 5. 排序 + 返回top K
	sort.Slice(merged, func(i, j int) bool {
		return merged[i].Score > merged[j].Score
	})
	return merged[:topK], nil
}

// internal/rag/reranker.go
type Reranker interface {
	Rerank(ctx context.Context, query string, candidates []Chunk) ([]Chunk, error)
}

// 简单实现：用LLM的cross-encoder或相似度重新打分
type LLMReranker struct {
	llmClient LLMClient
}

func (r *LLMReranker) Rerank(ctx context.Context, query string, candidates []Chunk) ([]Chunk, error) {
	// 对每个candidate计算与query的相关度
	// 用一个轻量级模型（可以用embedding的cosine相似度）
	// 重新排序，返回top 5
}

// RAG答案结构
type RAGAnswer struct {
	Answer    string     `json:"answer"`
	Citations []Citation `json:"citations"`
	Confidence string    `json:"confidence"`
}

type Citation struct {
	Source  string `json:"source"`      // 文档来源
	ChunkID string `json:"chunk_id"`    // 具体chunk ID
	Text    string `json:"text,omitempty"` // 引用的原文
}

// 生成答案时强制加citation
func (r *RAGEngine) GenerateAnswerWithCitations(ctx context.Context, query string, topChunks []Chunk) (*RAGAnswer, error) {
	// 组织prompt：
	// "根据以下参考文档回答问题。必须在答案中使用[chunk_id]标记引用。"
	
	response, err := r.llmClient.Generate(ctx, GenerateRequest{
		Messages: []Message{
			{Role: "system", Content: systemPrompt},
			{Role: "user", Content: fmt.Sprintf("参考文档:\n%s\n\n问题:%s", formatChunks(topChunks), query)},
		},
	})
	
	// 从response里解析出[chunk_id]标记
	citations := extractCitations(response.Content)
	
	return &RAGAnswer{
		Answer:     response.Content,
		Citations:  citations,
		Confidence: evaluateConfidence(citations),
	}, nil
}

func evaluateConfidence(citations []Citation) string {
	if len(citations) == 0 {
		return "low"  // 没引用 → 低信心
	}
	if len(citations) >= 2 {
		return "high"  // 多来源 → 高信心
	}
	return "medium"
}

// evals/dataset.jsonl
{
  "input": "How to reset SSO?",
  "expected_answer": "...",
  "expected_sources": ["sso_setup.md"],
  "must_cite": true,
  "should_call_tools": ["search_knowledge_base"],
  "expected_confidence": "high"
}

// internal/eval/evaluator.go
type EvalResult struct {
	AnswerCorrect      bool
	CitationAccurate   bool
	RetrievalHitRate   float32
	ToolCallAccurate   bool
	ConfidenceCorrect  bool
	Latency            time.Duration
}

func (e *Evaluator) Eval(ctx context.Context, input string, expected EvalCase) *EvalResult {
	// 1. 调RAG系统
	answer := e.ragEngine.Query(ctx, input)
	
	// 2. 检查答案正确性（可用LLM judge）
	answerCorrect := evaluateAnswer(answer.Answer, expected.ExpectedAnswer)
	
	// 3. 检查citation准确性
	citationAccurate := verifyCitations(answer.Citations, expected.ExpectedSources)
	
	// 4. 检查retrieval命中
	retrievalHit := len(answer.Citations) > 0
	
	// 5. 检查confidence是否合理
	confidenceCorrect := validateConfidence(answer.Confidence, citationAccurate)
	
	return &EvalResult{
		AnswerCorrect:     answerCorrect,
		CitationAccurate:  citationAccurate,
		RetrievalHitRate:  float32(hitCount) / float32(len(testCases)),
		ConfidenceCorrect: confidenceCorrect,
	}
}

// internal/eval/error_analysis.go
type ErrorCategory string

const (
	ErrorRetrievalMiss   ErrorCategory = "retrieval_miss"      // 没找到相关文档
	ErrorWrongRerank     ErrorCategory = "wrong_rerank"        // Rerank把好结果排下去了
	ErrorMissingCitation ErrorCategory = "missing_citation"    // 答案没引用
	ErrorHallucination   ErrorCategory = "hallucination"       // 编造内容
	ErrorWrongTool       ErrorCategory = "wrong_tool"          // 调错工具了
	ErrorUnsafeAction    ErrorCategory = "unsafe_action"       // Guardrail拦截
	ErrorSchemaFailure   ErrorCategory = "schema_failure"      // 输出格式不对
)

type ErrorAnalysis struct {
	Category ErrorCategory
	Symptom  string  // 表现
	RootCause string // 根本原因
	Mitigation string // 修复方案
}

func AnalyzeFailures(results []EvalResult) map[ErrorCategory]int {
	// 1. 分类每个失败
	categories := make(map[ErrorCategory]int)
	
	for _, result := range results {
		if result.AnswerCorrect {
			continue  // 成功，跳过
		}
		
		// 根据症状推断错误类别
		if result.RetrievalHitRate == 0 {
			categories[ErrorRetrievalMiss]++
		} else if !result.CitationAccurate {
			categories[ErrorWrongRerank]++
		} else {
			categories[ErrorHallucination]++
		}
	}
	
	return categories
}

// 例：retrieval_miss的修复
// → 调大embedding模型
// → 改chunking策略
// → 加keyword search权重
// → 补充更多FAQ