Add files via upload

internal/knowledge/indexer.go

@@ -3,596 +3,203 @@ package knowledge
 import (
 	"context"
 	"database/sql"
-	"encoding/json"
 	"fmt"
-	"regexp"
 	"strings"
 	"sync"
 	"time"
 
 	"cyberstrike-ai/internal/config"
 
-	"github.com/google/uuid"
+	fileloader "github.com/cloudwego/eino-ext/components/document/loader/file"
+	"github.com/cloudwego/eino/compose"
+	"github.com/cloudwego/eino/components/document"
+	"github.com/cloudwego/eino/components/indexer"
+	"github.com/cloudwego/eino/schema"
 	"go.uber.org/zap"
 )
 
-// Indexer 索引器，负责将知识项分块并向量化
+// Indexer 使用 Eino Compose 索引链（Markdown/递归分块、Lambda  enrich、SQLite 索引）与嵌入写入。
 type Indexer struct {
-	db             *sql.DB
-	embedder       *Embedder
-	logger         *zap.Logger
-	chunkSize      int // 每个块的最大 token 数（估算）
-	overlap        int // 块之间的重叠 token 数
-	maxChunks      int // 单个知识项的最大块数量（0 表示不限制）
+	db          *sql.DB
+	embedder    *Embedder
+	logger      *zap.Logger
+	chunkSize   int
+	overlap     int
+	indexingCfg *config.IndexingConfig
+
+	indexChain compose.Runnable[[]*schema.Document, []string]
+	fileLoader *fileloader.FileLoader
 
-	// 错误跟踪
 	mu            sync.RWMutex
-	lastError     string    // 最近一次错误信息
-	lastErrorTime time.Time // 最近一次错误时间
-	errorCount    int       // 连续错误计数
+	lastError     string
+	lastErrorTime time.Time
+	errorCount    int
 
-	// 重建索引状态跟踪
 	rebuildMu          sync.RWMutex
-	isRebuilding       bool      // 是否正在重建索引
-	rebuildTotalItems  int       // 重建总项数
-	rebuildCurrent     int       // 当前已处理项数
-	rebuildFailed      int       // 重建失败项数
-	rebuildStartTime   time.Time // 重建开始时间
-	rebuildLastItemID  string    // 最近处理的项 ID
-	rebuildLastChunks  int       // 最近处理的项的分块数
+	isRebuilding       bool
+	rebuildTotalItems  int
+	rebuildCurrent     int
+	rebuildFailed      int
+	rebuildStartTime   time.Time
+	rebuildLastItemID  string
+	rebuildLastChunks  int
 }
 
-// NewIndexer 创建新的索引器
-func NewIndexer(db *sql.DB, embedder *Embedder, logger *zap.Logger, indexingCfg *config.IndexingConfig) *Indexer {
+// NewIndexer 创建索引器并编译 Eino 索引链；kcfg 为完整知识库配置（含 indexing 与路径相关行为）。
+func NewIndexer(ctx context.Context, db *sql.DB, embedder *Embedder, logger *zap.Logger, kcfg *config.KnowledgeConfig) (*Indexer, error) {
+	if db == nil {
+		return nil, fmt.Errorf("db is nil")
+	}
+	if embedder == nil {
+		return nil, fmt.Errorf("embedder is nil")
+	}
+	if err := EnsureKnowledgeEmbeddingsSchema(db); err != nil {
+		return nil, fmt.Errorf("knowledge_embeddings 结构迁移: %w", err)
+	}
+	if kcfg == nil {
+		kcfg = &config.KnowledgeConfig{}
+	}
+	indexingCfg := &kcfg.Indexing
+
 	chunkSize := 512
 	overlap := 50
-	maxChunks := 0
-	if indexingCfg != nil {
-		if indexingCfg.ChunkSize > 0 {
-			chunkSize = indexingCfg.ChunkSize
-		}
-		if indexingCfg.ChunkOverlap >= 0 {
-			overlap = indexingCfg.ChunkOverlap
-		}
-		if indexingCfg.MaxChunksPerItem > 0 {
-			maxChunks = indexingCfg.MaxChunksPerItem
-		}
+	if indexingCfg.ChunkSize > 0 {
+		chunkSize = indexingCfg.ChunkSize
 	}
+	if indexingCfg.ChunkOverlap >= 0 {
+		overlap = indexingCfg.ChunkOverlap
+	}
+
+	embedModel := embedder.EmbeddingModelName()
+	splitter, err := newKnowledgeSplitter(chunkSize, overlap, embedModel)
+	if err != nil {
+		return nil, fmt.Errorf("eino recursive splitter: %w", err)
+	}
+
+	chain, err := buildKnowledgeIndexChain(ctx, indexingCfg, db, splitter, embedModel)
+	if err != nil {
+		return nil, fmt.Errorf("knowledge index chain: %w", err)
+	}
+
+	var fl *fileloader.FileLoader
+	fl, err = fileloader.NewFileLoader(ctx, nil)
+	if err != nil {
+		if logger != nil {
+			logger.Warn("Eino FileLoader 初始化失败，prefer_source_file 将回退数据库正文", zap.Error(err))
+		}
+		fl = nil
+		err = nil
+	}
+
 	return &Indexer{
-		db:        db,
-		embedder:  embedder,
-		logger:    logger,
-		chunkSize: chunkSize,
-		overlap:   overlap,
-		maxChunks: maxChunks,
-	}
+		db:          db,
+		embedder:    embedder,
+		logger:      logger,
+		chunkSize:   chunkSize,
+		overlap:     overlap,
+		indexingCfg: indexingCfg,
+		indexChain:  chain,
+		fileLoader:  fl,
+	}, nil
 }
 
-// ChunkText 将文本分块（支持重叠，保留标题上下文）
-func (idx *Indexer) ChunkText(text string) []string {
-	// 按 Markdown 标题分割，获取带标题的块
-	sections := idx.splitByMarkdownHeadersWithContent(text)
-
-	// 处理每个块
-	result := make([]string, 0)
-	for _, section := range sections {
-		// 构建父级标题路径（不包含最后一级标题，因为内容中已经包含）
-		// 例如：["# A", "## B", "### C"] -> "[# A > ## B]"
-		var parentHeaderPath string
-		if len(section.HeaderPath) > 1 {
-			parentHeaderPath = strings.Join(section.HeaderPath[:len(section.HeaderPath)-1], " > ")
-		}
-
-		// 提取内容的第一行作为标题（如 "# Prompt Injection"）
-		firstLine, remainingContent := extractFirstLine(section.Content)
-
-		// 如果剩余内容为空或只有空白，说明这个块只有标题没有正文，跳过
-		if strings.TrimSpace(remainingContent) == "" {
-			continue
-		}
-
-		// 如果块太大，进一步分割
-		if idx.estimateTokens(section.Content) <= idx.chunkSize {
-			// 块大小合适，添加父级标题前缀
-			if parentHeaderPath != "" {
-				result = append(result, fmt.Sprintf("[%s] %s", parentHeaderPath, section.Content))
-			} else {
-				result = append(result, section.Content)
-			}
-		} else {
-			// 块太大，按子标题或段落分割，保持标题上下文
-			// 首先尝试按子标题分割（保留子标题结构）
-			subSections := idx.splitBySubHeaders(section.Content, firstLine, parentHeaderPath)
-			if len(subSections) > 1 {
-				// 成功按子标题分割，递归处理每个子块
-				for _, sub := range subSections {
-					if idx.estimateTokens(sub) <= idx.chunkSize {
-						result = append(result, sub)
-					} else {
-						// 子块仍然太大，按段落分割（保留标题前缀）
-						paragraphs := idx.splitByParagraphsWithHeader(sub, parentHeaderPath)
-						for _, para := range paragraphs {
-							if idx.estimateTokens(para) <= idx.chunkSize {
-								result = append(result, para)
-							} else {
-								// 段落仍太大，按句子分割
-								sentenceChunks := idx.splitBySentencesWithOverlap(para)
-								for _, chunk := range sentenceChunks {
-									result = append(result, chunk)
-								}
-							}
-						}
-					}
-				}
-			} else {
-				// 没有子标题，按段落分割（保留标题前缀）
-				paragraphs := idx.splitByParagraphsWithHeader(section.Content, parentHeaderPath)
-				for _, para := range paragraphs {
-					if idx.estimateTokens(para) <= idx.chunkSize {
-						result = append(result, para)
-					} else {
-						// 段落仍太大，按句子分割
-						sentenceChunks := idx.splitBySentencesWithOverlap(para)
-						for _, chunk := range sentenceChunks {
-							result = append(result, chunk)
-						}
-					}
-				}
-			}
-		}
+// RecompileIndexChain 在配置或嵌入模型变更后重建 Eino 索引链（无需重启进程）。
+func (idx *Indexer) RecompileIndexChain(ctx context.Context) error {
+	if idx == nil || idx.db == nil || idx.embedder == nil {
+		return fmt.Errorf("indexer 未初始化")
 	}
-
-	return result
+	if err := EnsureKnowledgeEmbeddingsSchema(idx.db); err != nil {
+		return err
+	}
+	embedModel := idx.embedder.EmbeddingModelName()
+	splitter, err := newKnowledgeSplitter(idx.chunkSize, idx.overlap, embedModel)
+	if err != nil {
+		return fmt.Errorf("eino recursive splitter: %w", err)
+	}
+	chain, err := buildKnowledgeIndexChain(ctx, idx.indexingCfg, idx.db, splitter, embedModel)
+	if err != nil {
+		return fmt.Errorf("knowledge index chain: %w", err)
+	}
+	idx.indexChain = chain
+	return nil
 }
 
-// extractFirstLine 提取第一行内容和剩余内容
-func extractFirstLine(content string) (firstLine, remaining string) {
-	lines := strings.SplitN(content, "\n", 2)
-	if len(lines) == 0 {
-		return "", ""
-	}
-	if len(lines) == 1 {
-		return lines[0], ""
-	}
-	return lines[0], lines[1]
-}
-
-// splitBySubHeaders 尝试按子标题分割内容（用于处理大块内容）
-// headerPrefix 是父级标题路径，用于添加到每个子块
-func (idx *Indexer) splitBySubHeaders(content, headerPrefix, parentPath string) []string {
-	// 匹配 Markdown 子标题（## 及以上）
-	subHeaderRegex := regexp.MustCompile(`(?m)^#{2,6}\s+.+$`)
-	matches := subHeaderRegex.FindAllStringIndex(content, -1)
-
-	if len(matches) == 0 {
-		// 没有子标题，返回原始内容
-		return []string{content}
-	}
-
-	result := make([]string, 0, len(matches))
-	for i, match := range matches {
-		start := match[0]
-		nextStart := len(content)
-		if i+1 < len(matches) {
-			nextStart = matches[i+1][0]
-		}
-
-		subContent := strings.TrimSpace(content[start:nextStart])
-
-		// 添加父级路径前缀
-		if parentPath != "" {
-			result = append(result, fmt.Sprintf("[%s] %s", parentPath, subContent))
-		} else {
-			result = append(result, subContent)
-		}
-	}
-
-	return result
-}
-
-// splitByParagraphsWithHeader 按段落分割，每个段落添加标题前缀（用于保持上下文）
-func (idx *Indexer) splitByParagraphsWithHeader(content, parentPath string) []string {
-	// 提取第一行作为标题
-	firstLine, _ := extractFirstLine(content)
-
-	paragraphs := strings.Split(content, "\n\n")
-	result := make([]string, 0)
-
-	for i, p := range paragraphs {
-		trimmed := strings.TrimSpace(p)
-		if trimmed == "" {
-			continue
-		}
-
-		// 过滤掉只有标题的段落（没有实际内容）
-		if strings.TrimSpace(trimmed) == strings.TrimSpace(firstLine) {
-			continue
-		}
-
-		// 第一个段落已经包含标题，不需要重复添加
-		if i == 0 && strings.Contains(trimmed, firstLine) {
-			if parentPath != "" {
-				result = append(result, fmt.Sprintf("[%s] %s", parentPath, trimmed))
-			} else {
-				result = append(result, trimmed)
-			}
-		} else {
-			// 其他段落添加标题前缀以保持上下文
-			if parentPath != "" {
-				result = append(result, fmt.Sprintf("[%s] %s\n%s", parentPath, firstLine, trimmed))
-			} else {
-				result = append(result, fmt.Sprintf("%s\n%s", firstLine, trimmed))
-			}
-		}
-	}
-
-	return result
-}
-
-// Section 表示一个带标题路径的文本块
-type Section struct {
-	HeaderPath []string // 标题路径（如 ["# SQL 注入", "## 检测方法"]）
-	Content    string   // 块内容
-}
-
-// splitByMarkdownHeadersWithContent 按 Markdown 标题分割，返回带标题路径的块
-// 每个块的内容包含自己的标题，用于向量化检索
-//
-// 例如，对于以下 Markdown:
-//   # Prompt Injection
-//   引言内容
-//   ## Summary
-//   目录内容
-//
-// 返回：
-//   [{HeaderPath: ["# Prompt Injection"], Content: "# Prompt Injection\n引言内容"},
-//    {HeaderPath: ["# Prompt Injection", "## Summary"], Content: "## Summary\n目录内容"}]
-func (idx *Indexer) splitByMarkdownHeadersWithContent(text string) []Section {
-	// 匹配 Markdown 标题 (# ## ### 等)
-	headerRegex := regexp.MustCompile(`(?m)^#{1,6}\s+.+$`)
-
-	// 找到所有标题位置
-	matches := headerRegex.FindAllStringIndex(text, -1)
-	if len(matches) == 0 {
-		// 没有标题，返回整个文本
-		return []Section{{HeaderPath: []string{}, Content: text}}
-	}
-
-	sections := make([]Section, 0, len(matches))
-	currentHeaderPath := []string{}
-
-	for i, match := range matches {
-		start := match[0]
-		end := match[1]
-		nextStart := len(text)
-
-		// 找到下一个标题的位置
-		if i+1 < len(matches) {
-			nextStart = matches[i+1][0]
-		}
-
-		// 提取当前标题
-		headerLine := strings.TrimSpace(text[start:end])
-
-		// 计算标题层级（# 的数量）
-		level := 0
-		for _, ch := range headerLine {
-			if ch == '#' {
-				level++
-			} else {
-				break
-			}
-		}
-
-		// 更新标题路径：移除比当前层级深或等于的子标题，然后添加当前标题
-		newPath := make([]string, 0, len(currentHeaderPath)+1)
-		for _, h := range currentHeaderPath {
-			hLevel := 0
-			for _, ch := range h {
-				if ch == '#' {
-					hLevel++
-				} else {
-					break
-				}
-			}
-			if hLevel < level {
-				newPath = append(newPath, h)
-			}
-		}
-		newPath = append(newPath, headerLine)
-		currentHeaderPath = newPath
-
-		// 提取当前标题到下一个标题之间的内容（包含当前标题）
-		content := strings.TrimSpace(text[start:nextStart])
-
-		// 创建块，使用当前标题路径（包含当前标题）
-		sections = append(sections, Section{
-			HeaderPath: append([]string(nil), currentHeaderPath...),
-			Content:    content,
-		})
-	}
-
-	// 过滤空块
-	result := make([]Section, 0, len(sections))
-	for _, section := range sections {
-		if strings.TrimSpace(section.Content) != "" {
-			result = append(result, section)
-		}
-	}
-
-	if len(result) == 0 {
-		return []Section{{HeaderPath: []string{}, Content: text}}
-	}
-
-	return result
-}
-
-// splitByParagraphs 按段落分割
-func (idx *Indexer) splitByParagraphs(text string) []string {
-	paragraphs := strings.Split(text, "\n\n")
-	result := make([]string, 0)
-	for _, p := range paragraphs {
-		if strings.TrimSpace(p) != "" {
-			result = append(result, strings.TrimSpace(p))
-		}
-	}
-	return result
-}
-
-// splitBySentences 按句子分割（用于内部，不包含重叠逻辑）
-func (idx *Indexer) splitBySentences(text string) []string {
-	// 简单的句子分割（按句号、问号、感叹号，支持中英文）
-	// . ! ? = 英文标点
-	// \u3002 = 。(中文句号)
-	// \uFF01 = ！(中文叹号)
-	// \uFF1F = ？(中文问号)
-	sentenceRegex := regexp.MustCompile(`[.!?\x{3002}\x{FF01}\x{FF1F}]+`)
-	sentences := sentenceRegex.Split(text, -1)
-	result := make([]string, 0)
-	for _, s := range sentences {
-		if strings.TrimSpace(s) != "" {
-			result = append(result, strings.TrimSpace(s))
-		}
-	}
-	return result
-}
-
-// splitBySentencesWithOverlap 按句子分割并应用重叠策略
-func (idx *Indexer) splitBySentencesWithOverlap(text string) []string {
-	if idx.overlap <= 0 {
-		// 如果没有重叠，使用简单分割
-		return idx.splitBySentencesSimple(text)
-	}
-
-	sentences := idx.splitBySentences(text)
-	if len(sentences) == 0 {
-		return []string{}
-	}
-
-	result := make([]string, 0)
-	currentChunk := ""
-
-	for _, sentence := range sentences {
-		testChunk := currentChunk
-		if testChunk != "" {
-			testChunk += "\n"
-		}
-		testChunk += sentence
-
-		testTokens := idx.estimateTokens(testChunk)
-
-		if testTokens > idx.chunkSize && currentChunk != "" {
-			// 当前块已达到大小限制，保存它
-			result = append(result, currentChunk)
-
-			// 从当前块的末尾提取重叠部分
-			overlapText := idx.extractLastTokens(currentChunk, idx.overlap)
-			if overlapText != "" {
-				// 如果有重叠内容，作为下一个块的起始
-				currentChunk = overlapText + "\n" + sentence
-			} else {
-				// 如果无法提取足够的重叠内容，直接使用当前句子
-				currentChunk = sentence
-			}
-		} else {
-			currentChunk = testChunk
-		}
-	}
-
-	// 添加最后一个块
-	if strings.TrimSpace(currentChunk) != "" {
-		result = append(result, currentChunk)
-	}
-
-	// 过滤空块
-	filtered := make([]string, 0)
-	for _, chunk := range result {
-		if strings.TrimSpace(chunk) != "" {
-			filtered = append(filtered, chunk)
-		}
-	}
-
-	return filtered
-}
-
-// splitBySentencesSimple 按句子分割（简单版本，无重叠）
-func (idx *Indexer) splitBySentencesSimple(text string) []string {
-	sentences := idx.splitBySentences(text)
-	result := make([]string, 0)
-	currentChunk := ""
-
-	for _, sentence := range sentences {
-		testChunk := currentChunk
-		if testChunk != "" {
-			testChunk += "\n"
-		}
-		testChunk += sentence
-
-		if idx.estimateTokens(testChunk) > idx.chunkSize && currentChunk != "" {
-			result = append(result, currentChunk)
-			currentChunk = sentence
-		} else {
-			currentChunk = testChunk
-		}
-	}
-	if currentChunk != "" {
-		result = append(result, currentChunk)
-	}
-
-	return result
-}
-
-// extractLastTokens 从文本末尾提取指定 token 数量的内容
-func (idx *Indexer) extractLastTokens(text string, tokenCount int) string {
-	if tokenCount <= 0 || text == "" {
-		return ""
-	}
-
-	// 估算字符数（1 token ≈ 4 字符）
-	charCount := tokenCount * 4
-	runes := []rune(text)
-
-	if len(runes) <= charCount {
-		return text
-	}
-
-	// 从末尾提取指定数量的字符
-	startPos := len(runes) - charCount
-	extracted := string(runes[startPos:])
-
-	// 尝试找到第一个句子边界（支持中英文标点）
-	sentenceBoundary := regexp.MustCompile(`[.!?\x{3002}\x{FF01}\x{FF1F}]+`)
-	matches := sentenceBoundary.FindStringIndex(extracted)
-	if len(matches) > 0 && matches[0] > 0 {
-		// 在句子边界处截断，保留完整句子
-		extracted = extracted[matches[0]:]
-	}
-
-	return strings.TrimSpace(extracted)
-}
-
-// estimateTokens 估算 token 数（简单估算：1 token ≈ 4 字符）
-func (idx *Indexer) estimateTokens(text string) int {
-	return len([]rune(text)) / 4
-}
-
-// IndexItem 索引知识项（分块并向量化）
+// IndexItem 索引单个知识项：先清空旧向量，再走 Compose 链（分块、嵌入、写入）。
 func (idx *Indexer) IndexItem(ctx context.Context, itemID string) error {
-	// 获取知识项（包含 category 和 title，用于向量化）
-	var content, category, title string
-	err := idx.db.QueryRow("SELECT content, category, title FROM knowledge_base_items WHERE id = ?", itemID).Scan(&content, &category, &title)
+	if idx.indexChain == nil {
+		return fmt.Errorf("索引链未初始化")
+	}
+	if idx.embedder == nil {
+		return fmt.Errorf("嵌入器未初始化")
+	}
+
+	var content, category, title, filePath string
+	err := idx.db.QueryRow("SELECT content, category, title, file_path FROM knowledge_base_items WHERE id = ?", itemID).Scan(&content, &category, &title, &filePath)
 	if err != nil {
 		return fmt.Errorf("获取知识项失败：%w", err)
 	}
 
-	// 删除旧的向量（在 RebuildIndex 中已经统一清空，这里保留是为了单独调用 IndexItem 时的兼容性）
-	_, err = idx.db.Exec("DELETE FROM knowledge_embeddings WHERE item_id = ?", itemID)
-	if err != nil {
+	if _, err := idx.db.Exec("DELETE FROM knowledge_embeddings WHERE item_id = ?", itemID); err != nil {
 		return fmt.Errorf("删除旧向量失败：%w", err)
 	}
 
-	// 分块
-	chunks := idx.ChunkText(content)
-
-	// 应用最大块数限制
-	if idx.maxChunks > 0 && len(chunks) > idx.maxChunks {
-		idx.logger.Info("知识项块数量超过限制，已截断",
-			zap.String("itemId", itemID),
-			zap.Int("originalChunks", len(chunks)),
-			zap.Int("maxChunks", idx.maxChunks))
-		chunks = chunks[:idx.maxChunks]
-	}
-
-	idx.logger.Info("知识项分块完成", zap.String("itemId", itemID), zap.Int("chunks", len(chunks)))
-
-	// 跟踪该知识项的错误
-	itemErrorCount := 0
-	var firstError error
-	firstErrorChunkIndex := -1
-
-	// 向量化每个块（包含 category 和 title 信息，以便向量检索时能匹配到风险类型）
-	for i, chunk := range chunks {
-		// 将 category 和 title 信息包含到向量化的文本中
-		// 格式："[风险类型：{category}] [标题：{title}]\n{chunk 内容}"
-		// 这样向量嵌入就会包含风险类型信息，即使 SQL 过滤失败，向量相似度也能帮助匹配
-		textForEmbedding := fmt.Sprintf("[风险类型：%s] [标题：%s]\n%s", category, title, chunk)
-
-		embedding, err := idx.embedder.EmbedText(ctx, textForEmbedding)
-		if err != nil {
-			itemErrorCount++
-			if firstError == nil {
-				firstError = err
-				firstErrorChunkIndex = i
-				// 只在第一个块失败时记录详细日志
-				chunkPreview := chunk
-				if len(chunkPreview) > 200 {
-					chunkPreview = chunkPreview[:200] + "..."
+	body := strings.TrimSpace(content)
+	if idx.indexingCfg != nil && idx.indexingCfg.PreferSourceFile && strings.TrimSpace(filePath) != "" && idx.fileLoader != nil {
+		docs, lerr := idx.fileLoader.Load(ctx, document.Source{URI: strings.TrimSpace(filePath)})
+		if lerr == nil && len(docs) > 0 {
+			var b strings.Builder
+			for i, d := range docs {
+				if d == nil {
+					continue
 				}
-				idx.logger.Warn("向量化失败",
-					zap.String("itemId", itemID),
-					zap.Int("chunkIndex", i),
-					zap.Int("totalChunks", len(chunks)),
-					zap.String("chunkPreview", chunkPreview),
-					zap.Error(err),
-				)
-
-				// 更新全局错误跟踪
-				errorMsg := fmt.Sprintf("向量化失败 (知识项：%s): %v", itemID, err)
-				idx.mu.Lock()
-				idx.lastError = errorMsg
-				idx.lastErrorTime = time.Now()
-				idx.mu.Unlock()
+				if i > 0 {
+					b.WriteString("\n\n")
+				}
+				b.WriteString(d.Content)
 			}
-
-			// 如果连续失败 5 个块，立即停止处理该知识项
-			// 这样可以避免继续浪费 API 调用，同时也能更快地检测到配置问题
-			// 对于大文档（超过 10 个块），允许失败比例不超过 50%
-			maxConsecutiveFailures := 5
-			if len(chunks) > 10 && itemErrorCount > len(chunks)/2 {
-				idx.logger.Error("知识项向量化失败比例过高，停止处理",
-					zap.String("itemId", itemID),
-					zap.Int("totalChunks", len(chunks)),
-					zap.Int("failedChunks", itemErrorCount),
-					zap.Int("firstErrorChunkIndex", firstErrorChunkIndex),
-					zap.Error(firstError),
-				)
-				return fmt.Errorf("知识项向量化失败比例过高 (%d/%d个块失败): %v", itemErrorCount, len(chunks), firstError)
+			if s := strings.TrimSpace(b.String()); s != "" {
+				body = s
 			}
-			if itemErrorCount >= maxConsecutiveFailures {
-				idx.logger.Error("知识项连续向量化失败，停止处理",
-					zap.String("itemId", itemID),
-					zap.Int("totalChunks", len(chunks)),
-					zap.Int("failedChunks", itemErrorCount),
-					zap.Int("firstErrorChunkIndex", firstErrorChunkIndex),
-					zap.Error(firstError),
-				)
-				return fmt.Errorf("知识项连续向量化失败 (%d个块失败): %v", itemErrorCount, firstError)
-			}
-			continue
-		}
-
-		// 保存向量
-		chunkID := uuid.New().String()
-		embeddingJSON, _ := json.Marshal(embedding)
-
-		_, err = idx.db.Exec(
-			"INSERT INTO knowledge_embeddings (id, item_id, chunk_index, chunk_text, embedding, created_at) VALUES (?, ?, ?, ?, ?, datetime('now'))",
-			chunkID, itemID, i, chunk, string(embeddingJSON),
-		)
-		if err != nil {
-			idx.logger.Warn("保存向量失败", zap.String("itemId", itemID), zap.Int("chunkIndex", i), zap.Error(err))
-			continue
+		} else if idx.logger != nil {
+			idx.logger.Warn("优先源文件读取失败，使用数据库正文",
+				zap.String("itemId", itemID),
+				zap.String("path", filePath),
+				zap.Error(lerr))
 		}
 	}
 
-	idx.logger.Info("知识项索引完成", zap.String("itemId", itemID), zap.Int("chunks", len(chunks)))
+	root := &schema.Document{
+		ID:      itemID,
+		Content: body,
+		MetaData: map[string]any{
+			metaKBCategory: category,
+			metaKBTitle:    title,
+			metaKBItemID:   itemID,
+		},
+	}
 
-	// 更新重建状态中的最近处理信息
+	idxOpts := []indexer.Option{indexer.WithEmbedding(idx.embedder.EinoEmbeddingComponent())}
+	if idx.indexingCfg != nil && len(idx.indexingCfg.SubIndexes) > 0 {
+		idxOpts = append(idxOpts, indexer.WithSubIndexes(idx.indexingCfg.SubIndexes))
+	}
+
+	ids, err := idx.indexChain.Invoke(ctx, []*schema.Document{root}, compose.WithIndexerOption(idxOpts...))
+	if err != nil {
+		msg := fmt.Sprintf("索引写入失败 (知识项：%s): %v", itemID, err)
+		idx.mu.Lock()
+		idx.lastError = msg
+		idx.lastErrorTime = time.Now()
+		idx.mu.Unlock()
+		return err
+	}
+
+	if idx.logger != nil {
+		idx.logger.Info("知识项索引完成", zap.String("itemId", itemID), zap.Int("chunks", len(ids)))
+	}
 	idx.rebuildMu.Lock()
 	idx.rebuildLastItemID = itemID
-	idx.rebuildLastChunks = len(chunks)
+	idx.rebuildLastChunks = len(ids)
 	idx.rebuildMu.Unlock()
-
 	return nil
 }
 
@@ -608,7 +215,6 @@ func (idx *Indexer) HasIndex() (bool, error) {
 
 // RebuildIndex 重建所有索引
 func (idx *Indexer) RebuildIndex(ctx context.Context) error {
-	// 设置重建状态
 	idx.rebuildMu.Lock()
 	idx.isRebuilding = true
 	idx.rebuildTotalItems = 0
@@ -619,7 +225,6 @@ func (idx *Indexer) RebuildIndex(ctx context.Context) error {
 	idx.rebuildLastChunks = 0
 	idx.rebuildMu.Unlock()
 
-	// 重置错误跟踪
 	idx.mu.Lock()
 	idx.lastError = ""
 	idx.lastErrorTime = time.Time{}
@@ -628,7 +233,6 @@ func (idx *Indexer) RebuildIndex(ctx context.Context) error {
 
 	rows, err := idx.db.Query("SELECT id FROM knowledge_base_items")
 	if err != nil {
-		// 重置重建状态
 		idx.rebuildMu.Lock()
 		idx.isRebuilding = false
 		idx.rebuildMu.Unlock()
@@ -640,7 +244,6 @@ func (idx *Indexer) RebuildIndex(ctx context.Context) error {
 	for rows.Next() {
 		var id string
 		if err := rows.Scan(&id); err != nil {
-			// 重置重建状态
 			idx.rebuildMu.Lock()
 			idx.isRebuilding = false
 			idx.rebuildMu.Unlock()
@@ -655,13 +258,9 @@ func (idx *Indexer) RebuildIndex(ctx context.Context) error {
 
 	idx.logger.Info("开始重建索引", zap.Int("totalItems", len(itemIDs)))
 
-	// 注意：不再清空所有旧索引，而是按增量方式更新
-	// 每个知识项在 IndexItem 中会先删除自己的旧向量，然后插入新向量
-	// 这样配置更新后只重新索引变化的知识项，保留其他知识项的索引
-
 	failedCount := 0
 	consecutiveFailures := 0
-	maxConsecutiveFailures := 5 // 连续失败 5 次后立即停止（允许偶尔的临时错误）
+	maxConsecutiveFailures := 5
 	firstFailureItemID := ""
 	var firstFailureError error
 
@@ -670,7 +269,6 @@ func (idx *Indexer) RebuildIndex(ctx context.Context) error {
 			failedCount++
 			consecutiveFailures++
 
-			// 只在第一个失败时记录详细日志
 			if consecutiveFailures == 1 {
 				firstFailureItemID = itemID
 				firstFailureError = err
@@ -681,7 +279,6 @@ func (idx *Indexer) RebuildIndex(ctx context.Context) error {
 				)
 			}
 
-			// 如果连续失败过多，可能是配置问题，立即停止索引
 			if consecutiveFailures >= maxConsecutiveFailures {
 				errorMsg := fmt.Sprintf("连续 %d 个知识项索引失败，可能存在配置问题（如嵌入模型配置错误、API 密钥无效、余额不足等）。第一个失败项：%s, 错误：%v", consecutiveFailures, firstFailureItemID, firstFailureError)
 				idx.mu.Lock()
@@ -699,7 +296,6 @@ func (idx *Indexer) RebuildIndex(ctx context.Context) error {
 				return fmt.Errorf("连续索引失败次数过多：%v", firstFailureError)
 			}
 
-			// 如果失败的知识项过多，记录警告但继续处理（降低阈值到 30%）
 			if failedCount > len(itemIDs)*3/10 && failedCount == len(itemIDs)*3/10+1 {
 				errorMsg := fmt.Sprintf("索引失败的知识项过多 (%d/%d)，可能存在配置问题。第一个失败项：%s, 错误：%v", failedCount, len(itemIDs), firstFailureItemID, firstFailureError)
 				idx.mu.Lock()
@@ -717,26 +313,22 @@ func (idx *Indexer) RebuildIndex(ctx context.Context) error {
 			continue
 		}
 
-		// 成功时重置连续失败计数和第一个失败信息
 		if consecutiveFailures > 0 {
 			consecutiveFailures = 0
 			firstFailureItemID = ""
 			firstFailureError = nil
 		}
 
-		// 更新重建进度
 		idx.rebuildMu.Lock()
 		idx.rebuildCurrent = i + 1
 		idx.rebuildFailed = failedCount
 		idx.rebuildMu.Unlock()
 
-		// 减少进度日志频率（每 10 个或每 10% 记录一次）
 		if (i+1)%10 == 0 || (len(itemIDs) > 0 && (i+1)*100/len(itemIDs)%10 == 0 && (i+1)*100/len(itemIDs) > 0) {
 			idx.logger.Info("索引进度", zap.Int("current", i+1), zap.Int("total", len(itemIDs)), zap.Int("failed", failedCount))
 		}
 	}
 
-	// 重置重建状态
 	idx.rebuildMu.Lock()
 	idx.isRebuilding = false
 	idx.rebuildMu.Unlock()