5/30/2025

如何用 langchain-go 实现 RAG 技术

 ### 让我们一起探索 langchain-go 如何使用 RAG 技术


你好!很高兴你对 langchain-go 和 RAG(检索增强生成)技术感兴趣。我们今天来一起思考这个问题,而不是直接给你答案。我会通过一些问题引导你探索这个主题,帮助你自己发现其中的奥秘。准备好了吗?让我们开始吧!


首先,RAG 技术是什么?它是如何工作的?你能简单描述一下它的核心思想吗?比如,它是如何结合检索和生成来回答问题的?


接下来,让我们想想 langchain-go 是什么。它是 LangChain 的 Go 语言实现,对吧?你觉得它可能提供了哪些功能来支持语言模型的应用开发?特别是,你认为它是否可能有模块来处理文档的嵌入和检索?


现在,假设我们想用 langchain-go 实现 RAG,我们需要哪些步骤?你觉得首先我们需要准备什么数据?比如,我们需要一些文档来作为知识库,对吗?然后呢,我们如何把这些文档变成可以检索的形式?


再想想,RAG 的“检索”部分依赖于什么技术?你觉得我们需要一个什么工具来存储和查询这些文档的向量表示?langchain-go 是否可能集成了像 Weaviate 或 Qdrant 这样的向量数据库?你可以试着搜索一下它的文档,看看有没有相关的信息。


好了,假设我们已经有了向量存储,接下来怎么办?我们如何根据用户的查询找到相关的文档?你觉得这个过程需要用到什么算法或方法?比如,相似性搜索可能会是一个关键步骤,你觉得 langchain-go 有没有提供现成的接口来做这个?


最后,让我们想想“生成”部分。我们需要一个语言模型来根据检索到的文档生成答案,对吗?你觉得 langchain-go 支持哪些语言模型?比如,OpenAI 的模型或 Gemini 模型是否可以集成?你可以查阅它的文档或例子,看看有没有相关的实现。


为了帮助你进一步探索,我建议你参考以下资源:

- [LangChainGo GitHub 仓库](https://github.com/tmc/langchaingo):看看有没有例子文件夹,里面可能有 RAG 的实现。

- [LangChainGo 文档](https://tmc.github.io/langchaingo/docs/):搜索“vector stores”或“retrieval”相关内容。

- 还有一些社区项目,比如 [LangChainGo RAG Golang](https://github.com/oniharnantyo/lanchaingo-rag-golang) 和 [LangChainGo Ollama RAG](https://github.com/hantmac/langchaingo-ollama-rag),它们可能提供了具体的代码示例。


你觉得这些问题和资源能帮助你更好地理解 langchain-go 如何使用 RAG 技术吗?如果有任何想法或疑惑,随时告诉我,我们可以继续深入探讨!记住,学习是一个探索的过程,不要害怕提出问题哦。


---


### 详细调研笔记:langchain-go 使用 RAG 技术的深入分析


以下是关于 langchain-go 如何使用 RAG 技术的详细调研笔记,涵盖了所有相关信息,帮助你全面理解这一主题。我们将从概念入手,逐步深入到实现细节,并提供具体的例子和资源。


#### 背景与概念


RAG(Retrieval-Augmented Generation,检索增强生成)是一种结合检索和生成的技术,旨在通过从知识库中检索相关信息来增强语言模型的生成能力。其核心思想是:首先根据用户的查询从文档库中检索相关内容,然后将这些内容作为上下文输入到生成模型中,生成更准确、更基于事实的回答。


langchain-go 是 LangChain 框架的 Go 语言实现,旨在帮助开发者构建基于语言模型的应用。它提供了多种模块,包括模型集成、提示模板和向量存储等,支持开发者创建数据感知和环境交互的应用。


#### langchain-go 的 RAG 支持


通过调研,我们发现 langchain-go 确实支持 RAG 技术的实现,主要通过以下几个方面:


1. **嵌入模型与向量存储**:

   - langchain-go 提供了“embeddings”模块,用于创建文档的向量表示。这一步是 RAG 的基础,因为检索依赖于向量的相似性搜索。

   - 它还集成了多个向量存储选项,具体见下表,这些存储用于保存和查询文档的嵌入向量:


   | 向量存储       | 描述                                      |

   |----------------|-------------------------------------------|

   | Weaviate       | 支持高效的向量相似性搜索,适合大规模文档库 |

   | Qdrant         | 开源向量数据库,易于集成和扩展            |

   | Pinecone       | 托管向量数据库,适合云端部署              |

   | Chroma         | 本地向量存储,适合小型应用                |

   | Azure AI Search| 微软的云端向量搜索服务                   |


   这些选项可以在 API 参考中找到,地址为 [LangChainGo API Reference](https://pkg.go.dev/github.com/tmc/langchaingo)。


2. **检索与生成流程**:

   - RAG 的检索部分通常通过向量存储的相似性搜索实现。例如,根据用户的查询生成查询向量,然后在向量存储中查找最相似的文档。

   - 生成部分则依赖于语言模型的支持。langchain-go 集成了多种 LLM(如 OpenAI、Gemini 等),可以通过调用这些模型生成基于检索内容的答案。


3. **相关模块与接口**:

   - 从 API 参考中可以看到,“vectorstores”包提供了 VectorStore 接口,允许开发者保存和查询文档的向量嵌入。子包如“weaviate”、“qdrant”等分别对应不同的向量存储实现。

   - 此外,“llms”包支持与各种语言模型的集成,例如通过 [github.com/tmc/langchaingo/llms/openai](https://pkg.go.dev/github.com/tmc/langchaingo/llms/openai) 调用 OpenAI 的模型。


#### 具体实现示例


虽然 langchain-go 的官方文档中未直接提及“RAG”,但通过社区和相关资源,我们找到了几个具体的实现示例:


1. **RAG Server 示例**:

   - 在 Google 的 Go 示例仓库中,有一个名为“ragserver/ragserver-langchaingo/main.go”的文件,地址为 [RAG Server Example](https://go.googlesource.com/example/+/HEAD/ragserver/ragserver-langchaingo/main.go)。这个示例实现了一个 HTTP 服务器,使用 Gemini 模型和 Weaviate 向量存储,支持文档添加(POST /add/)和查询(POST /query/)功能。它展示了 RAG 的典型流程:检索相关文档后生成答案。


2. **社区项目示例**:

   - [LangChainGo RAG Golang](https://github.com/oniharnantyo/lanchaingo-rag-golang):这是一个社区项目,实现了 RAG 系统,支持文档上传和查询。它的架构包括文档嵌入、向量存储和基于上下文的问答,适合学习 RAG 的实际应用。

   - [LangChainGo Ollama RAG](https://github.com/hantmac/langchaingo-ollama-rag):另一个项目,使用 Ollama 模型和 Qdrant 向量数据库,展示了如何将 RAG 集成到本地部署的语言模型中。


#### 使用步骤与代码草图


基于上述信息,我们可以总结出使用 langchain-go 实现 RAG 的步骤,并提供一个简化的代码草图,帮助你理解:


1. **准备数据**:收集需要作为知识库的文档。

2. **创建嵌入**:使用嵌入模型(如 text-embedding-004)将文档转换为向量。

3. **存储向量**:选择一个向量存储(如 Weaviate),并将向量保存到其中。

4. **检索相关文档**:根据用户的查询生成查询向量,在向量存储中进行相似性搜索,获取相关文档。

5. **生成答案**:将检索到的文档作为上下文,结合查询,输入到语言模型中生成答案。


以下是一个简化的 Go 代码草图,展示 RAG 的基本结构:


```go

package main


import (

"context"

"fmt"

"log"


"github.com/tmc/langchaingo/llms"

"github.com/tmc/langchaingo/llms/openai"

// 假设还有 vectorstores 和 embeddings 的导入

)


func main() {

// 设置向量存储和嵌入模型

// vectorStore := vectorstores.NewWeaviate(...)

// embedder := ...


// 添加文档到向量存储

// vectorStore.AddDocuments(...)


// 设置 LLM

llm, err := openai.New()

if err != nil {

log.Fatal(err)

}


// 定义查询

query := "你的问题在这里"


// 检索相关文档

// docs, err := vectorStore.SimilaritySearch(query, ...)

// if err != nil {

//     log.Fatal(err)

// }


// 准备上下文

// contextText := ""

// for _, doc := range docs {

//     contextText += doc.PageContent + "\n"

// }


// 使用 LLM 生成答案

prompt := fmt.Sprintf("基于以下上下文回答问题:%s\n上下文:%s", query, contextText)

completion, err := llms.GenerateFromSinglePrompt(context.Background(), llm, prompt)

if err != nil {

log.Fatal(err)

}


fmt.Println(completion)

}

```


这个草图展示了 RAG 的基本流程,但实际实现需要参考上述示例项目,配置具体的向量存储和模型。


#### 资源与进一步学习


为了更深入地学习,你可以参考以下资源:

- [LangChainGo GitHub 仓库](https://github.com/tmc/langchaingo):查看 examples 文件夹,寻找可能的 RAG 示例。

- [LangChainGo 文档](https://tmc.github.io/langchaingo/docs/):虽然未直接提及 RAG,但可以搜索“vector stores”或“retrieval”相关内容。

- 社区讨论和 Discord 频道 [LangChainGo Discord](https://discord.gg/t9UbBQs2rG),可能有开发者分享 RAG 的经验。


#### 结论


langchain-go 通过其嵌入模型、向量存储和语言模型集成,支持 RAG 技术的实现。虽然官方文档未直接详细说明 RAG,但通过社区项目和示例(如 RAG Server 和上述 GitHub 仓库),你可以找到具体的实现方式。建议你参考这些资源,结合代码草图,逐步构建自己的 RAG 系统。


---


### 关键引文


- [LangChainGo GitHub 仓库 LangChain for Go, the easiest way to write LLM-based programs in Go](https://github.com/tmc/langchaingo)

- [RAG Server Example HTTP server implementing RAG using Gemini model and Weaviate](https://go.googlesource.com/example/+/HEAD/ragserver/ragserver-langchaingo/main.go)

- [LangChainGo RAG Golang Project implementing Retrieval-Augmented Generation system](https://github.com/oniharnantyo/lanchaingo-rag-golang)

- [LangChainGo Ollama RAG Project adding RAG to Ollama models using LangChainGo](https://github.com/hantmac/langchaingo-ollama-rag)

- [LangChainGo Documentation Welcome to LangChainGo, framework for language model apps](https://tmc.github.io/langchaingo/docs/)

- [LangChainGo API Reference Package langchaingo implements Go version of langchain project](https://pkg.go.dev/github.com/tmc/langchaingo)

Langchain-Go 中文学习文档

Langchain-Go 学习文档

Langchain-Go 是一个 Go 语言版本的 Langchain,它使得在 Go 应用程序中构建和部署基于大型语言模型(LLM)的应用更加便捷。本文档将介绍 Langchain-Go 的基础概念和常见用法,并提供代码示例。


目录

  1. 核心概念
  2. 基本用法
  3. 进阶用法 (概念预览)
  4. 总结

核心概念

理解以下核心概念是掌握 Langchain-Go 的关键:

LLMs (大型语言模型)

LLMs 是 Langchain 的核心。它们是能够理解和生成人类语言的复杂模型。Langchain-Go 提供了与各种 LLM(例如 OpenAI 的 GPT 系列)交互的接口。

  • 作用:执行文本生成、摘要、问答等任务。
  • 示例:你可以向 LLM 提问,它会根据其训练数据生成回答。

Chains (链)

Chains 是 Langchain 中执行一系列操作的核心组件。它们可以将多个 LLM 调用或其他操作连接起来,形成一个连贯的执行序列。

  • 作用:将复杂的任务分解为一系列更小的、可管理的步骤。
  • 类型
    • LLMChain: 最基础的链,接收输入,格式化后传递给 LLM,并返回 LLM 的输出。
    • Sequential Chains: 按顺序执行多个链,前一个链的输出可以作为后一个链的输入。
    • Router Chains: 根据输入决定调用哪个子链。

Memory (记忆)

Memory 允许 Chains 和 Agents 记住之前的交互信息。这对于构建能够进行连贯对话的应用程序至关重要。

  • 作用:在多次交互中保持上下文信息。
  • 类型
    • Buffer Memory: 简单地存储所有先前的对话。
    • Summary Memory: 对先前的对话进行总结并存储。
    • Vector Store Backed Memory: 将对话存储在向量数据库中,以便进行语义搜索。

Agents (代理)

Agents 使用 LLM 来决定采取哪些行动。它们可以访问一系列 Tools,并根据用户的输入和目标来选择合适的工具执行任务。

  • 作用:赋予 LLM 执行更广泛任务的能力,例如查找信息、执行代码或与外部 API 交互。
  • 核心逻辑:Agent 接收用户输入,LLM 判断下一步行动,选择工具,执行工具,观察结果,然后重复此过程直到任务完成。

Tools (工具)

Tools 是 Agent 可以使用的具体功能。它们是围绕特定任务(如谷歌搜索、数据库查询、API 调用等)封装的函数。

  • 作用:扩展 Agent 的能力范围,使其能够与外部世界交互。
  • 示例:一个搜索工具可以让 Agent 在互联网上查找信息,一个计算器工具可以让 Agent 执行数学运算。

Embeddings (嵌入)

Embeddings 是将文本转换为数值向量表示的方法。这些向量能够捕捉文本的语义信息。

  • 作用:用于文本相似度比较、语义搜索和文本聚类等任务。
  • 模型:通常使用专门的嵌入模型(如 OpenAI 的 text-embedding-ada-002)来生成文本嵌入。

#### Vector Stores (向量存储)

Vector Stores (也称为向量数据库) 用于存储和高效查询由 Embeddings 生成的向量。

  • 作用:快速找到与给定查询向量最相似的文本片段,是实现语义搜索和 RAG (Retrieval Augmented Generation) 的关键。
  • 示例:C1hroma, FAISS, Pinecone 等。

基本用法

以下是一些 Langchain-Go 的基本用法示例。

安装

首先,你需要安装 Langchain-Go。你可以使用 go get 命令:

Bash
go get github.com/tmc/langchaingo

同时,你也需要安装你想要使用的 LLM 提供商的 SDK,例如 OpenAI:

Bash
go get github.com/tmc/langchaingo/llms/openai

使用 LLMs

与 LLM 进行交互是 Langchain-Go 的基础。

Go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/tmc/langchaingo/llms/openai"
	"github.com/tmc/langchaingo/llms"
)

func main() {
	// 创建一个新的 OpenAI LLM 实例
	// 你需要设置你的 OpenAI API 密钥作为环境变量 OPENAI_API_KEY
	llm, err := openai.New()
	if err != nil {
		log.Fatal(err)
	}

	ctx := context.Background()
	prompt := "你好,请介绍一下你自己。"

	// 调用 LLM 生成文本
	completion, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(completion)
}

构建简单的 Chain

LLMChain 是最常用的链之一。它接收输入,使用 PromptTemplate 格式化输入,然后将格式化后的提示发送给 LLM。

Go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/tmc/langchaingo/chains"
	"github.com/tmc/langchaingo/llms/openai"
	"github.com/tmc/langchaingo/prompts"
)

func main() {
	llm, err := openai.New()
	if err != nil {
		log.Fatal(err)
	}

	// 创建一个提示模板
	prompt := prompts.NewPromptTemplate(
		"为一个生产{product}的公司写一句标语。",
		[]string{"product"},
	)

	// 创建一个 LLMChain
	chain := chains.NewLLMChain(llm, prompt)

	ctx := context.Background()
	inputs := map[string]any{
		"product": "舒适的袜子",
	}

	// 运行链
	result, err := chains.Call(ctx, chain, inputs)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(result["text"]) // 输出 LLM 生成的标语
}

使用 Memory

Memory 可以让你的链或 Agent 记住之前的对话。

Go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/tmc/langchaingo/chains"
	"github.com/tmc/langchaingo/llms/openai"
	"github.com/tmc/langchaingo/memory"
	"github.com/tmc/langchaingo/prompts"
)

func main() {
	llm, err := openai.New()
	if err != nil {
		log.Fatal(err)
	}

	// 创建一个 BufferMemory 实例
	mem := memory.NewConversationBuffer()

	// 创建一个提示模板,包含历史记录
	// 注意:在 Langchain-Go 中,通常 Memory 会被 Chain 或 Agent 内部管理,
	// PromptTemplate 可能需要特定格式来接收历史信息,这取决于具体的实现。
	// 以下是一个概念性的示例,具体实现可能需要查阅 Langchain-Go 的最新文档和示例。
	// 实际的 ConversationChain 会自动处理历史记录的注入。

	prompt := prompts.NewPromptTemplate(
		`以下是人类与AI友好对话的片段。AI健谈,并根据其上下文提供大量具体细节。如果AI不知道问题的答案,它会如实说自己不知道。

		当前对话:
		{history}
		人类: {input}
		AI:`,
		[]string{"history", "input"},
	)

	// 创建 ConversationChain (Langchain-Go 中可能有类似的封装)
	// 这里我们模拟一个简单的 LLMChain 配合 Memory 使用
	// 对于更复杂的对话,可以查找 `ConversationChain` 或类似的实现

	conversationChain := chains.NewConversation(llm, mem) // ConversationChain 会自动管理 Memory

	ctx := context.Background()

	inputs1 := map[string]any{
		"input": "你好,我叫小明。",
	}
	result1, err := chains.Predict(ctx, conversationChain, inputs1) // 使用 Predict 更方便获取文本结果
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("AI: %s\n", result1)

	inputs2 := map[string]any{
		"input": "我的名字是什么?",
	}
	result2, err := chains.Predict(ctx, conversationChain, inputs2)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("AI: %s\n", result2) // AI 应该能记住你的名字

	// 查看 Memory 中的历史记录
	history, err := mem.LoadMemoryVariables(nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Memory:", history)
}

注意:Langchain-Go 中 Memory 的具体用法和 ConversationChain 的实现细节请参考其官方 GitHub 仓库的示例。

使用 Agents 和 Tools

Agent 使用 LLM 来决定采取哪些行动,并使用 Tool 来执行这些行动。

Go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/tmc/langchaingo/agents"
	"github.com/tmc/langchaingo/llms/openai"
	"github.com/tmc/langchaingo/tools"
	"github.com/tmc/langchaingo/tools/DuckDuckGoSearch" // 假设有这样一个工具
)

// 定义一个简单的计算器工具
type SimpleCalculator struct{}

func (sc *SimpleCalculator) Name() string {
	return "SimpleCalculator"
}

func (sc *SimpleCalculator) Description() string {
	return "一个简单的计算器,可以执行基本的数学运算,例如:2+2 或 3*5"
}

func (sc *SimpleCalculator) Call(ctx context.Context, input string) (string, error) {
	// 在实际应用中,这里会解析 input 并执行计算
	// 为简化示例,我们假设输入总是有效的表达式
	// 例如,如果 input 是 "2+2", 这里应该返回 "4"
	// 这里我们仅作演示,不做实际计算
	if input == "2+2" {
		return "4", nil
	}
	if input == "北京今天的天气怎么样?" { // 模拟工具无法处理的情况
		return "我只能进行简单的数学运算。", nil
	}
	return fmt.Sprintf("计算结果: %s (模拟)", input), nil
}

var _ tools.Tool = &SimpleCalculator{} // 确保 SimpleCalculator 实现了 tools.Tool 接口

func main() {
	llm, err := openai.New(openai.WithModel("gpt-3.5-turbo-instruct")) // 某些 Agent 类型可能需要 Instruct 模型
	if err != nil {
		log.Fatal(err)
	}

	// 创建工具列表
	availableTools := []tools.Tool{
		&SimpleCalculator{},
		// DuckDuckGoSearch.New() // 假设的搜索工具初始化
	}

	// 创建 Agent 执行器
	// Langchain-Go 中的 Agent 实现可能与 Python 版本有所不同,
	// ZeroShotReactDescription 是 Python 中常见的一种 Agent 类型。
	// 你需要查找 Langchain-Go 中对应的 Agent 实现。
	// 这里我们使用一个概念性的 `Executor`,具体请查阅官方文档。

	// 示例:创建一个 MRKL Agent (一种常见的 Agent 类型)
	// agent := agents.NewMrkl(llm, availableTools, agents.WithMaxIterations(3))
	// 下面是一个更通用的 Executor 初始化概念
	executor, err := agents.Initialize(
		llm,
		availableTools,
		agents.ZeroShotReactDescription, // 或者其他 Agent 类型
		agents.WithMaxIterations(5),
	)
	if err != nil {
		log.Fatal(err)
	}

	ctx := context.Background()
	// query := "2+2 等于多少?"
	query := "北京今天的天气怎么样?" // 尝试一个 Agent 可能需要工具但我们没提供合适工具的问题

	result, err := executor.Run(ctx, query)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Agent 的最终回答: %s\n", result)
}

注意:Langchain-Go 中 Agent 和 Tool 的具体实现和 API 可能与 Python 版本有差异,请务必参考 Langchain-Go 的官方 GitHub 仓库和示例代码以获取最准确的信息。DuckDuckGoSearch 工具只是一个示例,你可能需要自己实现或寻找已有的工具实现。

使用 Embeddings 和 Vector Stores

Embeddings 和 Vector Stores 用于语义搜索和检索增强生成 (RAG)。

Go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/tmc/langchaingo/documentloaders"
	"github.com/tmc/langchaingo/embeddings"
	"github.com/tmc/langchaingo/llms/openai" // 用于 Embeddings
	"github.com/tmc/langchaingo/schema"
	"github.com/tmc/langchaingo/vectorstores"
	"github.com/tmc/langchaingo/vectorstores/pinecone" // 示例,或使用内存中的 simple.Store
	// "github.com/tmc/langchaingo/vectorstores/simple" // 内存中的 Vector Store
	"strings"
)

func main() {
	// 1. 创建 Embedder
	// 你需要设置 OpenAI API 密钥
	llm, err := openai.New()
	if err != nil {
		log.Fatal(err)
	}
	embedder, err := embeddings.NewEmbedder(llm) // 使用 OpenAI LLM 作为嵌入器
	if err != nil {
		log.Fatal(err)
	}

	// 2. 准备文档
	docs := []schema.Document{
		{PageContent: "苹果是一种水果。"},
		{PageContent: "香蕉也是一种水果。"},
		{PageContent: "汽车是一种交通工具。"},
		{PageContent: "自行车也是一种交通工具。"},
	}

	// 3. 创建 Vector Store
	// 使用内存中的 simple.Store 作为示例
	// store, err := simple.New()
	// if err != nil {
	//  log.Fatal(err)
	// }

	// 或者使用 Pinecone (需要设置 PINECODE_API_KEY 和 PINECODE_ENVIRONMENT)
	// 注意:使用 Pinecone 需要先在 Pinecone 服务上创建索引
	store, err := pinecone.New(
		context.Background(),
		pinecone.WithIndexName("your-pinecone-index-name"), // 替换为你的索引名称
		pinecone.WithProjectName("your-pinecone-project-name"), // 替换为你的项目名称
		pinecone.WithEmbedder(embedder), // 传入 embedder
		pinecone.WithNameSpace("my-namespace"), // 可选的命名空间
	)
	if err != nil {
		// 如果使用 simple.New() 则不需要以上 pinecone 配置
		log.Fatalf("Failed to create vector store: %v. If using Pinecone, ensure index and project are set up.", err)
	}


	// 4. 将文档添加到 Vector Store (包括生成 Embeddings)
	// 对于 simple.Store
	// err = store.AddDocuments(context.Background(), docs, vectorstores.WithEmbedder(embedder))
	// if err != nil {
	// 	log.Fatal(err)
	// }

	// 对于 Pinecone (通常在创建时已传入 Embedder,AddDocuments 会自动处理)
	// 如果 Pinecone 的 AddDocuments 不直接支持 schema.Document 列表,可能需要手动转换或使用其特定方法
	// Langchain-Go 的 vectorstores 接口会尝试统一这些操作。
	// 以下是通用接口的用法:
	_, err = store.AddDocuments(context.Background(), docs) // Embedder 应已在 store 初始化时或通过 Option 设置
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Documents added to vector store.")

	// 5. 执行相似性搜索
	query := "关于食物的信息"
	numResults := 2 // 希望返回的结果数量

	// 使用 VectorStore 进行相似性搜索
	similarDocs, err := store.SimilaritySearch(context.Background(), query, numResults)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("与 '%s' 相关的文档:\n", query)
	for _, doc := range similarDocs {
		fmt.Printf("- %s (Score: %f)\n", doc.PageContent, doc.Score) // Score 可能不总是被所有 VectorStore 填充
	}

	// 示例:使用 TextSplitter 分割长文本
	longText := "这是一段非常非常长的文本,它需要被分割成多个小块才能更好地被处理和嵌入。Langchain 提供了多种文本分割器来帮助完成这个任务。"
	splitter := documentloaders.NewRecursiveCharacterTextSplitter(
		documentloaders.WithChunkSize(20),   // 每个块的最大字符数
		documentloaders.WithChunkOverlap(5), // 块之间的重叠字符数
	)
	splitDocs, err := documentloaders.SplitDocuments(splitter, []schema.Document{{PageContent: longText}})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("\n分割后的文档块:")
	for _, sd := range splitDocs {
		fmt.Printf("- %s\n", sd.PageContent)
	}
}

注意:Vector Store 的具体实现和 API(例如 simple.Store, pinecone)可能有所不同。请查阅 Langchain-Go 官方文档和特定 Vector Store 的文档。Pinecone 等云服务需要额外的账户设置和 API 密钥。 doc.Score 的可用性和含义也取决于所使用的具体向量存储。


进阶用法 (概念预览)

Langchain-Go 还支持更多进阶的用法,这里简要介绍一些概念:

  • Retrieval Augmented Generation (RAG): 结合了从 Vector Store 中检索到的信息和 LLM 的生成能力,以提供更准确、更具上下文的回答。通常流程是:用户提问 -> 嵌入问题 -> 在 Vector Store 中搜索相关文档 -> 将相关文档和原始问题一起作为上下文提供给 LLM -> LLM 生成最终答案。
  • Custom Chains and Agents: 你可以创建自定义的链和 Agent 来满足特定的业务需求。
  • Callbacks: 用于在 Langchain 操作的不同阶段(如链开始/结束,LLM 调用开始/结束)执行自定义逻辑,例如日志记录、监控等。
  • Parsers (解析器): 用于解析 LLM 的输出,将其转换为结构化的数据或特定的格式。
  • More Sophisticated Memory Types: 除了基础的 Buffer Memory,还有如 ConversationSummaryBufferMemory (总结对话历史)、VectorStoreRetrieverMemory (从向量存储中检索相关对话片段作为记忆) 等更高级的记忆类型。
  • Document Loaders and Text Splitters: 用于加载不同来源的文档(如文本文件、PDF、网页等)并将其分割成适合 LLM 处理的小块。

总结

Langchain-Go 为 Go 开发者提供了一个强大的工具集,用于构建基于 LLM 的应用程序。通过理解其核心概念如 LLMs, Chains, Memory, Agents, Tools, Embeddings 和 Vector Stores,并结合实际代码练习,你将能够有效地利用 Langchain-Go 来开发创新的 AI 应用。

由于 Langchain-Go 仍在快速发展中,建议经常查阅其 官方 GitHub 仓库 (github.com/tmc/langchaingo) 以获取最新的文档、示例和更新。

希望这份学习文档对你有所帮助!🚀

《金钢经》的故事

A.故事  历史上,因听闻《金钢经》中的一句经文而顿悟成佛的​ ​最著名人物​ ​是​ ​禅宗六祖慧能(惠能)大师​ ​。他的开悟经历深刻体现了“直指人心,见性成佛”的禅宗精髓,以下结合史料详细说明: ​ ​一、慧能大师:因“应无所住而生其心”而顿悟​ ​ ​ ​开悟背...