// 他的切分方式funcSplitText(text string) []string {    var chunks []string    for i := 0; i < len(text); i += 500 {        chunks = append(chunks, text[i:i+500])    }    return chunks}

❌ 按固定字数切：500个字，正好切在句子中间❌ "Go语言的并发编程" → 切成了 "Go语言的并发" + "编程"→ 检索"并发" → 能匹配→ 检索"Go并发编程" → 匹配不到，因为向量被截断了

import "os"funcReadTxt(path string) (string, error) {    data, err := os.ReadFile(path)    if err != nil {        return "", err    }    return string(data), nil}

import (    "github.com/russross/blackfriday/v2")funcReadMarkdown(path string) (string, error) {    data, err := os.ReadFile(path)    if err != nil {        return "", err    }    // 用blackfriday解析Markdown    html := blackfriday.Run(data)    // 用goquery提取纯文本（去掉HTML标签）    doc, _ := goquery.NewDocumentFromReader(bytes.NewReader(html))    text := doc.Text()    return text, nil}

import "github.com/PuerkitoBio/goquery"funcReadHTML(path string) (string, error) {    data, err := os.ReadFile(path)    if err != nil {        return "", err    }    doc, err := goquery.NewDocumentFromReader(bytes.NewReader(data))    if err != nil {        return "", err    }    // 去掉script和style（这些不是正文）    doc.Find("script, style").Remove()    // 提取纯文本    text := doc.Text()    return text, nil}

import "github.com/ledongthuc/pdf"funcReadPDF(path string) (string, error) {    f, r, err := pdf.Open(path)    if err != nil {        return "", err    }    defer f.Close()    var text string    totalPages := r.NumPage()    for i := 1; i <= totalPages; i++ {        p := r.Page(i)        if p.V.IsNull() {            continue        }        content, _ := p.GetPlainText()        text += content + "\n"    }    return text, nil}

funcSplitByChars(text string, chunkSize int) []string {    var chunks []string    runes := []rune(text)    for i := 0; i < len(runes); i += chunkSize {        end := i + chunkSize        if end > len(runes) {            end = len(runes)        }        chunks = append(chunks, string(runes[i:end]))    }    return chunks}

❌ 可能在句子中间切断❌ 上下文被割裂，检索"完整语义"时丢失❌ "Go语言的并发编程" → "Go语言的并发" + "编程"

// 第6篇：文本分割（使用langchaingo textsplitter）//// 运行前提：无外部服务依赖//   - go run ./article06/splitter/package mainimport (	"context"	"fmt"	"strings"	"unicode/utf8"	"github.com/tmc/langchaingo/documentloaders"	"github.com/tmc/langchaingo/schema"	"github.com/tmc/langchaingo/textsplitter")funcmain() {	ctx := context.Background()	text := `Go语言是一门静态类型的编译型语言，由Google于2009年发布。它具有高并发、高性能的特点，特别适合构建后端服务和分布式系统。Goroutine是Go语言的核心特性之一，它是一种轻量级的线程，由Go运行时管理。创建一个Goroutine只需要在函数调用前加上go关键字。Channel是Go语言中用于Goroutine之间通信的机制。通过Channel，可以实现安全的跨Goroutine数据传递，避免共享内存带来的并发问题。Go语言的错误处理采用显式返回错误的方式，而非异常机制。这虽然让代码稍微冗长，但让错误处理逻辑更加清晰。Go的标准库非常强大，包含了HTTP服务器、JSON处理、加密、测试等常用功能，减少了对外部依赖的需求。`	fmt.Println("=== 第6篇：文本分割（langchaingo textsplitter） ===")	fmt.Printf("原文长度: %d 字符\n\n", utf8.RuneCountInString(text))	// ===== 1. RecursiveCharacter 分割器（推荐） =====	fmt.Println("--- 1. RecursiveCharacter 分割器（推荐） ---")	// langchaingo 的 RecursiveCharacter 是最常用的分割器	// 默认分隔符: ["\n\n", "\n", " ", ""]	splitter := textsplitter.NewRecursiveCharacter(		textsplitter.WithChunkSize(100),		textsplitter.WithChunkOverlap(20),		textsplitter.WithSeparators([]string{"\n", "。", "，", " ", ""}),	)	chunks, err := splitter.SplitText(text)	if err != nil {		fmt.Printf("分割失败: %v\n", err)		return	}	for i, chunk := range chunks {		fmt.Printf("  Chunk %d (%d字符): %s\n", i+1, utf8.RuneCountInString(chunk), truncate(chunk, 50))	}	// ===== 2. 对比：不同ChunkSize =====	fmt.Println()	fmt.Println("--- 2. ChunkSize 对比 ---")	for _, size := range []int{50, 100, 200} {		s := textsplitter.NewRecursiveCharacter(			textsplitter.WithChunkSize(size),			textsplitter.WithChunkOverlap(10),		)		parts, _ := s.SplitText(text)		fmt.Printf("  ChunkSize=%d → %d 个分片\n", size, len(parts))	}	// ===== 3. 与文档加载器结合使用（LoadAndSplit） =====	fmt.Println()	fmt.Println("--- 3. LoadAndSplit: 加载+分割一体化 ---")	// 创建测试文件	testContent := strings.Repeat("Go语言是一门编译型语言。", 20)	docs, err := documentloaders.NewText(		strings.NewReader(testContent),	).LoadAndSplit(ctx,		textsplitter.NewRecursiveCharacter(			textsplitter.WithChunkSize(50),			textsplitter.WithChunkOverlap(10),		),	)	if err != nil {		fmt.Printf("LoadAndSplit失败: %v\n", err)	} else {		fmt.Printf("  加载+分割得到 %d 个文档\n", len(docs))		for i, doc := range docs {			if i >= 3 {				fmt.Printf("  ... 共%d个\n", len(docs))				break			}			fmt.Printf("  Doc %d (%d字符): %s\n", i+1, utf8.RuneCountInString(doc.PageContent), truncate(doc.PageContent, 40))		}	}	// ===== 4. 自定义分割（中文按句子） =====	fmt.Println()	fmt.Println("--- 4. 自定义分割器（实现TextSplitter接口） ---")	sentenceSplitter := &SentenceSplitter{MaxChars: 150}	sentenceChunks, err := sentenceSplitter.SplitText(text)	if err != nil {		fmt.Printf("分割失败: %v\n", err)	}	for i, chunk := range sentenceChunks {		fmt.Printf("  Chunk %d (%d字符): %s\n", i+1, utf8.RuneCountInString(chunk), truncate(chunk, 50))	}	// ===== 5. SplitDocuments 批量分割 =====	fmt.Println()	fmt.Println("--- 5. SplitDocuments 批量分割 ---")	inputDocs := []schema.Document{		{PageContent: strings.Repeat("Go语言并发编程。", 15), Metadata: map[string]any{"source": "article1"}},		{PageContent: strings.Repeat("RAG知识库搭建。", 15), Metadata: map[string]any{"source": "article2"}},	}	splitDocs, err := textsplitter.SplitDocuments(		textsplitter.NewRecursiveCharacter(			textsplitter.WithChunkSize(80),			textsplitter.WithChunkOverlap(10),		),		inputDocs,	)	if err != nil {		fmt.Printf("批量分割失败: %v\n", err)	} else {		fmt.Printf("  %d个文档 → 分割为 %d 个片段\n", len(inputDocs), len(splitDocs))		for _, doc := range splitDocs {			fmt.Printf("  [source=%v] %s\n", doc.Metadata["source"], truncate(doc.PageContent, 40))		}	}}// SentenceSplitter 自定义按句子分割器（实现 textsplitter.TextSplitter 接口）type SentenceSplitter struct {	MaxChars int}func(s *SentenceSplitter) SplitText(text string) ([]string, error) {	var chunks []string	var current string	sentences := splitChineseSentences(text)	for _, sentence := range sentences {		sentence = strings.TrimSpace(sentence)		if sentence == "" {			continue		}		if utf8.RuneCountInString(current)+utf8.RuneCountInString(sentence) <= s.MaxChars {			current += sentence		} else {			if current != "" {				chunks = append(chunks, current)			}			current = sentence		}	}	if current != "" {		chunks = append(chunks, current)	}	return chunks, nil}funcsplitChineseSentences(text string) []string {	var sentences []string	var current string	for _, r := range text {		current += string(r)		if r == '。' || r == '！' || r == '？' || r == '.' || r == '!' || r == '?' {			sentences = append(sentences, current)			current = ""		}	}	if current != "" {		sentences = append(sentences, current)	}	return sentences}functruncate(s string, n int) string {	runes := []rune(s)	if len(runes) <= n {		return s	}	return string(runes[:n]) + "..."}

✅ 按语义单元切，不会切断句子✅ 上下文完整✅ 实现简单，效果好

funcSplitBySemantic(text string) ([]string, error) {    // 1. 先按句子切分    sentences := SplitBySentence(text, 200)    // 2. 相邻句子做Embedding，计算相似度    var chunks []string    var currentChunk []string    for i := 0; i < len(sentences); i++ {        emb1, _ := EmbedText(strings.Join(currentChunk, ""))        if len(currentChunk) > 0 {            // 计算当前chunk和下一句的相似度            nextEmb, _ := EmbedText(sentences[i])            sim := Cosine(emb1, nextEmb)            // 3. 如果相似度高（>0.9），合并；否则断开            if sim > 0.9 && len(strings.Join(currentChunk, "")) < 1000 {                currentChunk = append(currentChunk, sentences[i])            } else {                chunks = append(chunks, strings.Join(currentChunk, ""))                currentChunk = []string{sentences[i]}            }        } else {            currentChunk = []string{sentences[i]}        }    }    if len(currentChunk) > 0 {        chunks = append(chunks, strings.Join(currentChunk, ""))    }    return chunks, nil

相邻两段话 → 计算相似度→ 相似度高 → 合并（因为说的是同一件事）→ 相似度低 → 断开（因为话题切换了）

Chunk = 50字→ "Go语言的并发编程"→ 切成：["Go语言的并发", "编程"]检索"Go并发"：  → 可能匹配到"Go语言的并发" ✅  → 但丢失了"编程"这个上下文问题：  → 上下文碎片化  → LLM看到的是残缺的句子  → 生成的回答质量差

Chunk = 5000字→ 整篇文章作为一个Chunk→ 文章里混杂了：  → 开头：引言（100字）  → 中间：正文（4600字）  → 结尾：广告（300字）检索"Go并发怎么学"：  → 检索结果包含了整篇文章  → LLM的Context里全是噪声  → 生成的回答被广告污染

大多数文章 → 512字/Chunk  → 能覆盖一个完整段落  → 不会太短丢失上下文  → 不会太长引入噪声

编辑发布文章     ↓提取内容（标题/正文/标签/发布时间）     ↓文本清洗（去HTML标签/特殊字符）     ↓语义分割（按句子切，512字/Chunk）     ↓逐段Embedding（调用Embedding API）     ↓存入向量数据库（Chroma/Milvus）     ↓完成

// 第6篇：文档加载（使用langchaingo documentloaders）//// 运行前提：无外部服务依赖//   - go run ./article06/loader/package mainimport (	"bytes"	"context"	"fmt"	"log"	"os"	"strings"	"github.com/tmc/langchaingo/documentloaders"	"github.com/tmc/langchaingo/schema")funcmain() {	ctx := context.Background()	fmt.Println("=== 第6篇：文档加载演示（langchaingo documentloaders） ===")	// 创建测试文件	os.MkdirAll("testdata", 0755)	os.WriteFile("testdata/test.txt", []byte("Go语言是一门静态类型的编译型语言，由Google开发。\n它具有高并发、高性能的特点。"), 0644)	os.WriteFile("testdata/test.html", []byte("<html><head><title>测试</title></head><body><h1>Go语言</h1><p>Go是一门高性能的编程语言。</p><p>它支持并发编程。</p></body></html>"), 0644)	os.WriteFile("testdata/test.csv", []byte("title,tag,views\nGo并发编程,Go,12580\nRAG知识库,AI,8960\nK8s部署,DevOps,15230"), 0644)	defer os.RemoveAll("testdata")	// ===== 1. TXT 文本加载 =====	fmt.Println("\n--- 1. Text Loader（纯文本） ---")	txtFile, err := os.Open("testdata/test.txt")	if err != nil {		log.Fatal(err)	}	defer txtFile.Close()	txtLoader := documentloaders.NewText(txtFile)	txtDocs, err := txtLoader.Load(ctx)	if err != nil {		log.Fatal(err)	}	for _, doc := range txtDocs {		fmt.Printf("  内容: %s\n", truncate(doc.PageContent, 80))		fmt.Printf("  元数据: %v\n", doc.Metadata)	}	// ===== 2. HTML 文档加载 =====	fmt.Println("\n--- 2. HTML Loader（HTML解析+清洗） ---")	htmlContent, err := os.ReadFile("testdata/test.html")	if err != nil {		log.Fatal(err)	}	htmlLoader := documentloaders.NewHTML(bytes.NewReader(htmlContent))	htmlDocs, err := htmlLoader.Load(ctx)	if err != nil {		log.Fatal(err)	}	for _, doc := range htmlDocs {		fmt.Printf("  内容: %s\n", truncate(doc.PageContent, 80))	}	// ===== 3. CSV 文档加载 =====	fmt.Println("\n--- 3. CSV Loader（表格数据） ---")	csvFile, err := os.Open("testdata/test.csv")	if err != nil {		log.Fatal(err)	}	defer csvFile.Close()	csvLoader := documentloaders.NewCSV(csvFile)	csvDocs, err := csvLoader.Load(ctx)	if err != nil {		log.Fatal(err)	}	for _, doc := range csvDocs {		fmt.Printf("  行内容: %s\n", truncate(doc.PageContent, 60))		fmt.Printf("  元数据: %v\n", doc.Metadata)	}	// ===== 4. 自定义Loader（模拟Markdown） =====	fmt.Println("\n--- 4. 自定义 Loader（Markdown演示） ---")	mdContent := "# Go并发编程\n\n## Goroutine\n\nGoroutine是Go语言的**轻量级线程**。\n\n## Channel\n\nChannel用于Goroutine间通信。"	mdDocs := loadMarkdown(ctx, mdContent)	for _, doc := range mdDocs {		fmt.Printf("  内容: %s\n", truncate(doc.PageContent, 80))	}	// ===== 5. 批量加载目录 =====	fmt.Println("\n--- 5. 批量加载演示 ---")	fmt.Println("  documentloaders.NewDirectory(path, suffix...) 可批量加载目录文件")	fmt.Println("  例如：NewDirectory(\"./docs\", \".txt\", \".md\")")}// loadMarkdown 自定义Markdown加载（langchaingo暂无内置Markdown loader，// 可使用 RecursiveCharacter splitter 或自定义实现）funcloadMarkdown(ctx context.Context, content string) []schema.Document {	text := content	// 简化的Markdown清洗	for _, pair := range []struct{ from, to string }{		{"# ", ""}, {"## ", ""}, {"**", ""}, {"`", ""},	} {		text = strings.ReplaceAll(text, pair.from, pair.to)	}	return []schema.Document{		{			PageContent: strings.TrimSpace(text),			Metadata:    map[string]any{"format": "markdown"},		},	}}functruncate(s string, n int) string {	runes := []rune(s)	if len(runes) <= n {		return s	}	return string(runes[:n]) + "..."

读者输入问题     ↓问题Embedding     ↓向量数据库检索（Top5）     ↓组装Context     ↓LLM生成回答     ↓返回给读者     ↓附带原文链接（可跳转

Chunk大小的选择直接影响LLM调用成本：Chunk = 512字：  → 5个Chunk = 2560字 = 约2560 Token（按1:1估算）  → 每次搜索的LLM调用成本 = 2560 Token × 单价Chunk = 1024字：  → 5个Chunk = 5120字 = 约5120 Token（按1:1估算）  → 每次搜索的LLM调用成本 = 5120 Token × 单价差距：2倍！❗️ Chunk越大 → Context越长 → Token越多 → 费用越高

策略一：控制Chunk数量（TopK）  Top5 → Top3：省40% Context  → 但可能漏掉相关结果策略二：控制Chunk大小  1024字 → 512字：省50% Context  → 但上下文变少策略三：Context压缩（进阶）  → 先用简单模型总结Chunk  → 再用主模型生成

推荐配置（博客CMS）：  Chunk大小：512字  TopK：5  Context上限：2560字（≈主模型单次Context，按1:1估算）超出上限时：  → 按相关性排序，只取最相关的  → 或用Context压缩技术

// ❌ 错误：用Go原生PDF库处理中文text, _ := pdf.GetPlainText(page)// → 中文全是方块 □□□□□// ✅ 正确：用Python转成TXT，再给Go处理// Python: PyPDF2 + 字体映射表// 或：用云服务（阿里云OCR）转写

// ❌ 错误：直接读Markdown当纯文本data, _ := os.ReadFile("article.md")text := string(data)// → "## 标题" "**加粗**" 全部丢失语义// ✅ 正确：用blackfriday解析，保留结构html := blackfriday.Run(data)text := extractText(html)  // 去标签保留内容

// ❌ 错误：不处理特殊字符text := doc.Text()// → "Go\u00a0并发" 换行符、制表符混在文本里// ✅ 正确：清理特殊字符text = regexp.MustCompile(`[\u00a0\t\n\r]+`).ReplaceAllString(text, " ")text = strings.TrimSpace(text)

// ❌ 错误：最短Chunk不加限制for _, s := range sentences {    if current.Len() > 0 && current.Len()+len(s) <= chunkSize {        // 可能最后只剩几个字    }}// ✅ 正确：设置最小Chunk大小const minChunkSize = 100  // 至少100字才成一个Chunk// 否则合并到上一个Chunk

// ❌ 错误：标题+正文一起向量化combined := article.Title + article.Content// → 标题重复出现在每个Chunk里// ✅ 正确：标题作为元数据，不进Contentmetadatas: []map[string]interface{}{    {"title": article.Title, ...},  // 标题放元数据}// Content只放正文

✅ 四种格式处理（TXT/Markdown/HTML/PDF）✅ 三种分割策略（字符/句子/语义）✅ 分割粒度选择（128-1024字）✅ 博客CMS文章入库RAG完整流程✅ Context长度=Token成本=钱（核心）✅ 踩坑表（5个高频坑）