最完整的LangChain Go入门指南：从安装到实战

你还在为Go语言缺乏强大的大语言模型（LLM）开发框架而烦恼吗？是否想快速构建智能对话、自动化文档分析等AI应用？本文将带你从零开始，掌握LangChainGo（Go语言版LangChain）的核心功能，通过实战案例实现从环境搭建到复杂应用开发的全流程。读完本文，你将能够独立开发基于LLM的Go应用，掌握对话记忆、链（Chain）组合等高级特性，并了解企业级部署的最佳实践。

什么是LangChainGo？

LangChainGo是LangChain的Go语言实现，旨在通过模块化组件简化LLM应用开发。它提供了与主流AI模型（如OpenAI、Ollama、Mistral）的无缝集成，支持对话记忆、文档处理、工具调用等核心功能。项目结构遵循Go语言最佳实践，主要模块包括：

• LLMs：与各类大语言模型的交互接口，支持OpenAI、Ollama等 llms/
• Chains：将多个LLM操作组合成工作流的组件 chains/
• Agents：具备决策能力的智能代理，可调用工具完成复杂任务 agents/
• Memory：管理对话历史的模块，支持多种存储后端 memory/
• Document Loaders：处理PDF、CSV等文档的工具集 documentloaders/

图1：LangChainGo核心模块架构图，展示了数据流转与组件交互关系

环境准备与安装

前置条件

• Go 1.19+ 环境 安装指南
• Git 版本控制工具
• 可选：OpenAI API密钥（用于云模型访问）或Ollama本地模型

快速安装

通过以下命令克隆仓库并安装依赖：

git clone https://gitcode.com/GitHub_Trending/la/langchaingo
cd langchaingo
go mod download

如需在新项目中使用，直接通过go get安装：

go get github.com/tmc/langchaingo

快速入门：你的第一个LLM应用

1. 基础文本生成

创建main.go，编写一个调用OpenAI生成文本的简单程序：

package main

import (
  "context"
  "fmt"
  "log"

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

func main() {
  ctx := context.Background()
  // 初始化OpenAI客户端（默认读取环境变量OPENAI_API_KEY）
  llm, err := openai.New()
  if err != nil {
    log.Fatal(err)
  }
  // 生成文本
  prompt := "为一家生产彩色袜子的公司起5个创意名称"
  completion, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println("生成结果：", completion)
}

设置API密钥并运行：

export OPENAI_API_KEY="your-api-key"
go run main.go

预期输出类似：

生成结果： 1. 彩虹袜语 2. 色阶织造 3. 缤纷足界 4. 袜彩工坊 5. 色谱袜仓

2. 本地模型部署（Ollama）

对于注重隐私或无网络环境，推荐使用Ollama运行本地模型。首先安装Ollama并拉取模型：

# 安装Ollama（参考官方文档）
ollama pull llama3  # 拉取Llama 3模型

修改代码使用Ollama客户端 examples/ollama-completion-example/：

package main

import (
  "context"
  "fmt"
  "log"

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

func main() {
  ctx := context.Background()
  // 连接本地Ollama服务，指定模型
  llm, err := ollama.New(ollama.WithModel("llama3"))
  if err != nil {
    log.Fatal(err)
  }
  // 流式输出响应
  stream, err := llms.GenerateStream(ctx, llm, llms.WithPrompt("介绍Go语言的优势"))
  if err != nil {
    log.Fatal(err)
  }
  defer stream.Close()

  fmt.Println("流式响应：")
  for {
    chunk, err := stream.Recv()
    if err != nil {
      break
    }
    fmt.Print(chunk)
  }
}

核心功能实战

构建带记忆的对话系统

对话记忆是构建连续交互应用的基础。LangChainGo提供多种记忆策略，以下是基于缓冲区的实现 memory/：

package main

import (
  "bufio"
  "context"
  "fmt"
  "os"
  "strings"

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

func main() {
  // 初始化LLM和记忆组件
  llm, _ := openai.New()
  chatMemory := memory.NewConversationBuffer()
  // 创建对话链（自动管理记忆）
  conversationChain := chains.NewConversation(llm, chatMemory)
  
  ctx := context.Background()
  reader := bufio.NewReader(os.Stdin)
  
  fmt.Println("对话开始（输入'quit'退出）")
  for {
    fmt.Print("你: ")
    input, _ := reader.ReadString('\n')
    input = strings.TrimSpace(input)
    
    if input == "quit" {
      break
    }
    
    // 运行对话链
    result, _ := chains.Run(ctx, conversationChain, input)
    fmt.Printf("AI: %s\n\n", result)
  }
}

代码解析：ConversationBuffer存储完整对话历史，NewConversation创建预配置的对话链，自动将历史消息注入当前 prompt。

文档处理与问答系统

利用文档加载器和检索链，可构建基于自有文档的问答系统。以下示例使用PDF加载器处理文档 documentloaders/：

package main

import (
  "context"
  "fmt"

  "github.com/tmc/langchaingo/chains"
  "github.com/tmc/langchaingo/documentloaders"
  "github.com/tmc/langchaingo/embeddings/openai"
  "github.com/tmc/langchaingo/llms/openai"
  "github.com/tmc/langchaingo/textsplitter"
  "github.com/tmc/langchaingo/vectorstores/chroma"
)

func main() {
  ctx := context.Background()
  
  // 1. 加载PDF文档
  loader := documentloaders.NewPDF("docs/guide.pdf")
  docs, _ := loader.LoadAndSplit(ctx, textsplitter.NewRecursiveCharacterTextSplitter(
    textsplitter.WithChunkSize(1000),
    textsplitter.WithChunkOverlap(200),
  ))
  
  // 2. 创建向量存储（使用Chroma）
  embedder, _ := openai.NewEmbedding()
  vectorStore, _ := chroma.New(
    chroma.WithEmbedder(embedder),
    chroma.WithPersistDir("./chroma_db"),
  )
  vectorStore.AddDocuments(ctx, docs)
  
  // 3. 创建检索问答链
  retrievalQA := chains.NewRetrievalQA(
    chains.WithRetriever(vectorStore.AsRetriever()),
    chains.WithLLM(openai.New()),
  )
  
  // 4. 执行问答
  query := "LangChainGo支持哪些文档格式？"
  result, _ := chains.Run(ctx, retrievalQA, query)
  fmt.Printf("Q: %s\nA: %s\n", query, result)
}

工作流程：PDF → 文本分割 → 向量存储 → 相似性检索 → LLM生成答案

高级应用：智能代码审查助手

结合工具调用和代理功能，构建能分析代码的智能助手。以下是简化版实现 agents/：

package main

import (
  "context"
  "fmt"

  "github.com/tmc/langchaingo/agents"
  "github.com/tmc/langchaingo/llms/openai"
  "github.com/tmc/langchaingo/tools"
  "github.com/tmc/langchaingo/tools/sqldatabase"
)

func main() {
  // 初始化LLM和工具
  llm, _ := openai.New(openai.WithModel("gpt-4"))
  // 创建代码审查工具（伪代码）
  codeReviewTool := tools.NewFunction(
    func(ctx context.Context, input string) (string, error) {
      // 实际实现可调用静态分析工具
      return "代码审查结果：未发现明显bug，但建议添加错误处理", nil
    },
    tools.WithName("CodeReviewer"),
    tools.WithDescription("审查Go代码的语法和最佳实践"),
  )
  
  // 创建工具代理
  agent := agents.NewOpenAIFunctionsAgent(llm, []tools.Tool{codeReviewTool})
  executor := agents.NewExecutor(agent)
  
  // 运行代理
  result, _ := agents.Run(ctx, executor, "审查以下代码：\n"+
    "func add(a, b int) int { return a + b }")
  
  fmt.Println(result)
}

扩展方向：集成go/analysis包实现实际代码分析，或添加文件系统工具实现批量代码审查。

项目结构与最佳实践

推荐项目布局

your-project/
├── cmd/              # 应用入口
│   └── api/          # HTTP服务
├── internal/         # 内部模块
│   ├── llmclient/    # LLM客户端封装
│   └── handlers/     # 业务逻辑
├── pkg/              # 公共库
│   └── ai/           # LangChainGo封装
├── configs/          # 配置文件
└── go.mod

性能优化建议

1. 缓存机制：使用prompt_caching减少重复计算 llms/prompt_caching.go
2. 流式响应：对长文本生成使用GenerateStream降低延迟
3. 错误处理：利用errors_mapper统一错误处理 llms/errors_mapper.go
4. 资源控制：设置超时和令牌限制避免过度消耗

// 带超时和令牌控制的LLM配置
llm, _ := openai.New(
  openai.WithTimeout(30*time.Second),
  openai.WithMaxTokens(1000),
)

学习资源与社区支持

官方文档与示例

• 快速入门：docs/docs/getting-started/
  • OpenAI集成指南 guide-openai.mdx
  • Ollama本地部署 guide-ollama.mdx
• 教程案例：examples/tutorial-basic-chat-app/
• API参考：pkg.go.dev

常见问题解决

• 模型访问问题：检查网络代理和API密钥权限，本地模型确保Ollama服务运行
• 依赖冲突：使用go mod why分析依赖，推荐Go 1.21+模块模式
• 性能瓶颈：通过logging_transport分析API耗时 httputil/logging_transport.go

总结与展望

LangChainGo为Go开发者提供了构建LLM应用的完整工具链，通过模块化设计降低了AI应用开发门槛。本文涵盖了从基础安装到高级代理的核心知识点，关键收获包括：

1. 掌握LLM客户端初始化与基础文本生成
2. 使用记忆组件构建连续对话系统
3. 利用链和工具实现复杂工作流
4. 文档处理与检索增强生成（RAG）的实现

未来版本将进一步增强多模态支持和工具生态，建议关注项目CONTRIBUTING.md参与社区开发，或通过Discord获取实时支持。

下一步行动：

• 尝试教程案例中的智能日志分析器
• 为项目贡献新的文档加载器或向量存储适配器
• 关注parity_matrix.md了解与Python版LangChain的功能对比