💎🔗 Langchain.rb

⚡ 使用 Ruby 构建基于大语言模型的应用程序 ⚡

如需深度集成 Rails，请参阅：langchainrb_rails gem。

提供付费咨询支持！发送邮件给我。

使用场景

• 检索增强生成 (RAG) 和向量搜索
• 助手（聊天机器人）

目录

• 安装
• 使用
• LLM 统一接口
• 提示管理
• 输出解析器
• 构建 RAG
• 助手
• 评估
• 示例
• 日志记录
• 问题
• 开发
• Discord

安装

通过执行以下命令安装 gem 并将其添加到应用程序的 Gemfile 中：

bundle add langchainrb

如果未使用 Bundler 管理依赖项，则可通过以下命令安装 gem：

gem install langchainrb

可能需要其他 gem。它们默认不包含，因此您可以仅包含所需的部分。

使用

require "langchain"

LLM 统一接口

Langchain::LLM 模块提供了一个用于与各种大型语言模型 (LLM) 提供商交互的统一接口。这种抽象使您无需更改应用程序代码即可轻松切换不同的 LLM 后端。

支持的 LLM 提供商

• Anthropic
• AWS Bedrock
• Azure OpenAI
• Cohere
• Google Gemini
• Google Vertex AI
• HuggingFace
• Mistral AI
• Ollama
• OpenAI
• Replicate

使用

所有 LLM 类都继承自 Langchain::LLM::Base，并为常见操作提供一致的接口：

1. 生成嵌入
2. 生成提示补全
3. 生成聊天补全

初始化

大多数 LLM 类可以使用 API 密钥和可选的默认选项进行初始化：

llm = Langchain::LLM::OpenAI.new(
  api_key: ENV["OPENAI_API_KEY"],
  default_options: { temperature: 0.7, chat_model: "gpt-4o" }
)

生成嵌入

使用 embed 方法为给定文本生成嵌入：

response = llm.embed(text: "Hello, world!")
embedding = response.embedding

embed() 接受的参数

• text:（必填）要嵌入的输入文本。
• model:（可选）使用的模型名称；若未指定，则使用默认嵌入模型。

提示补全

使用 complete 方法为给定提示生成补全：

response = llm.complete(prompt: "Once upon a time")
completion = response.completion

complete() 接受的参数

• prompt:（必填）用于补全的输入提示。
• max_tokens:（可选）要生成的最大标记数。
• temperature:（可选）控制生成过程中的随机性。较高的值（如 0.8）会使输出更具随机性，而较低的值（如 0.2）则使其更具确定性。
• top_p:（可选）作为温度的替代品，控制生成标记的多样性。
• n:（可选）为每个提示生成的补全数量。
• stop:（可选）API 将在此处停止生成更多标记的序列。
• presence_penalty:（可选）根据标记在文本中已出现的频率对新标记进行惩罚。
• frequency_penalty:（可选）根据标记在文本中出现的频率对新标记进行惩罚。

生成聊天补全

使用 chat 方法生成聊天补全：

messages = [
  { role: "system", content: "You are a helpful assistant." },
  { role: "user", content: "What's the weather like today?" }
  # Google Gemini 和 Google VertexAI 要求消息采用不同格式：
  # { role: "user", parts: [{ text: "why is the sky blue?" }]}
]
response = llm.chat(messages: messages)
chat_completion = response.chat_completion

chat() 接受的参数

• messages:（必填）代表对话历史的消息对象数组。
• model:（可选）要使用的特定聊天模型。
• temperature:（可选）控制生成过程中的随机性。
• top_p:（可选）作为温度的替代品，控制生成标记的多样性。
• n:（可选）要生成的聊天补全选项数量。
• max_tokens:（可选）聊天补全中要生成的最大标记数。
• stop:（可选）API 将在此处停止生成更多标记的序列。
• presence_penalty:（可选）根据标记在文本中已出现的频率对新标记进行惩罚。
• frequency_penalty:（可选）根据标记在文本中出现的频率对新标记进行惩罚。
• logit_bias:（可选）修改指定标记出现在补全中的可能性。
• user:（可选）代表最终用户的唯一标识符。
• tools:（可选）模型可能调用的工具列表。
• tool_choice:（可选）控制模型如何调用函数。

切换 LLM 提供商

得益于统一的接口，您可以通过更改实例化的类轻松切换不同的 LLM 提供商：

# 使用 Anthropic
anthropic_llm = Langchain::LLM::Anthropic.new(api_key: ENV["ANTHROPIC_API_KEY"])

# 使用 Google Gemini
gemini_llm = Langchain::LLM::GoogleGemini.new(api_key: ENV["GOOGLE_GEMINI_API_KEY"])

# 使用 OpenAI
openai_llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])

响应对象

每个 LLM 方法都会返回一个响应对象，该对象提供了一致的接口来访问结果：

• embedding: 返回嵌入向量
• completion: 返回生成的文本补全
• chat_completion: 返回生成的聊天补全
• tool_calls: 返回 LLM 执行的工具调用
• prompt_tokens: 返回提示中的标记数
• completion_tokens: 返回补全中的标记数
• total_tokens: 返回使用的总标记数

[!注意] 虽然核心接口在各提供商之间保持一致，但某些 LLM 可能提供额外的功能或参数。请查阅每个 LLM 类的文档，以了解特定提供商的功能和选项。

提示管理

提示模板

创建带有输入变量的提示：

prompt = Langchain::Prompt::PromptTemplate.new(template: "给我讲一个关于{content}的{adjective}笑话。", input_variables: ["adjective", "content"])
prompt.format(adjective: "有趣", content: "鸡") # "给我讲一个关于鸡的有趣笑话。"

仅使用提示文本而不带输入变量创建 PromptTemplate：

prompt = Langchain::Prompt::PromptTemplate.from_template("给我讲一个关于鸡的有趣笑话。")
prompt.input_variables # []
prompt.format # "给我讲一个关于鸡的有趣笑话。"

将提示模板保存为 JSON 文件：

prompt.save(file_path: "spec/fixtures/prompt/prompt_template.json")

使用 JSON 文件加载新的提示模板：

prompt = Langchain::Prompt.load_from_path(file_path: "spec/fixtures/prompt/prompt_template.json")
prompt.input_variables # ["adjective", "content"]

少量示例提示模板

创建包含少量示例的提示：

prompt = Langchain::Prompt::FewShotPromptTemplate.new(
  prefix: "为以下词语写出反义词。",
  suffix: "输入：{adjective}\n输出：",
  example_prompt: Langchain::Prompt::PromptTemplate.new(
    input_variables: ["input", "output"],
    template: "输入：{input}\n输出：{output}"
  ),
  examples: [
    { "input": "happy", "output": "sad" },
    { "input": "tall", "output": "short" }
  ],
  input_variables: ["adjective"]
)

prompt.format(adjective: "good")

# 为以下词语写出反义词。
#
# 输入：happy
# 输出：sad
#
# 输入：tall
# 输出：short
#
# 输入：good
# 输出：

将提示模板保存为 JSON 文件：

prompt.save(file_path: "spec/fixtures/prompt/few_shot_prompt_template.json")

使用 JSON 文件加载新的提示模板：

prompt = Langchain::Prompt.load_from_path(file_path: "spec/fixtures/prompt/few_shot_prompt_template.json")
prompt.prefix # "为以下词语写出反义词。"

使用 YAML 文件加载新的提示模板：

prompt = Langchain::Prompt.load_from_path(file_path: "spec/fixtures/prompt/prompt_template.yaml")
prompt.input_variables #=> ["adjective", "content"]

输出解析器

将 LLM 的文本响应解析为结构化输出，例如 JSON。

结构化输出解析器

您可以使用 StructuredOutputParser 生成一个提示，指示 LLM 提供符合特定 JSON 模式的 JSON 响应：

json_schema = {
  type: "object",
  properties: {
    name: {
      type: "string",
      description: "人的姓名"
    },
    age: {
      type: "number",
      description: "人的年龄"
    },
    interests: {
      type: "array",
      items: {
        type: "object",
        properties: {
          interest: {
            type: "string",
            description: "一个感兴趣的领域"
          },
          levelOfInterest: {
            type: "number",
            description: "表示该人对该兴趣的兴趣程度，取值范围为 0 到 100"
          }
        },
        required: ["interest", "levelOfInterest"],
        additionalProperties: false
      },
      minItems: 1,
      maxItems: 3,
      description: "列出该人的兴趣爱好"
    }
  },
  required: ["name", "age", "interests"],
  additionalProperties: false
}
parser = Langchain::OutputParsers::StructuredOutputParser.from_json_schema(json_schema)
prompt = Langchain::Prompt::PromptTemplate.new(template: "生成一个虚构角色的详细信息。\n{format_instructions}\n角色描述：{description}", input_variables: ["description", "format_instructions"])
prompt_text = prompt.format(description: "韩国化学系学生", format_instructions: parser.get_format_instructions)
# 生成一个虚构角色的详细信息。
# 您必须将输出格式化为符合给定“JSON Schema”实例的 JSON 值。
# ...

然后解析 LLM 的响应：

llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
llm_response = llm.chat(messages: [{role: "user", content: prompt_text}]).completion
parser.parse(llm_response)
# {
#   "name" => "金智贤",
#   "age" => 22,
#   "interests" => [
#     {
#       "interest" => "有机化学",
#       "levelOfInterest" => 85
#     },
#     ...
#   ]
# }

如果解析器无法解析 LLM 的响应，可以使用 OutputFixingParser。它会将错误信息、之前的输出和原始提示文本发送给 LLM，请求其提供“修复后”的响应：

begin
  parser.parse(llm_response)
rescue Langchain::OutputParsers::OutputParserException => e
  fix_parser = Langchain::OutputParsers::OutputFixingParser.from_llm(
    llm: llm,
    parser: parser
  )
  fix_parser.parse(llm_response)
end

或者，如果您不需要处理 OutputParserException，可以简化代码：

# 我们已经有了 `OutputFixingParser`：
# parser = Langchain::OutputParsers::StructuredOutputParser.from_json_schema(json_schema)
fix_parser = Langchain::OutputParsers::OutputFixingParser.from_llm(
  llm: llm,
  parser: parser
)
fix_parser.parse(llm_response)

具体示例请参见 这里。

构建检索增强生成（RAG）系统

RAG 是一种帮助 LLM 生成准确且最新信息的方法论。 典型的 RAG 工作流程遵循以下 3 个步骤：

1. 从知识库（通常是向量搜索数据库）中检索相关知识（或数据）。
2. 构建包含上述检索到的知识的提示。
3. LLM 接收上述提示并生成文本补全。 RAG 系统最常见的用法是支持问答系统，用户可以用自然语言提问，并以自然语言获得答案。

向量搜索数据库

Langchain.rb 在支持的向量搜索数据库之上提供了一个便捷的统一接口，使配置索引、添加数据、查询和检索变得非常容易。

支持的向量搜索数据库及功能：

数据库	开源	云服务
Chroma	✅	✅
Hnswlib	✅	❌
Milvus	✅	✅ Zilliz Cloud
Pinecone	❌	✅
Pgvector	✅	✅
Qdrant	✅	✅
Weaviate	✅	✅
Elasticsearch	✅	✅

使用向量搜索数据库 🔍

选择你要使用的向量搜索数据库，添加 gem 依赖并实例化客户端：

gem "weaviate-ruby", "~> 0.8.9"

选择并实例化你将用于生成嵌入的 LLM 提供者：

llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])

client = Langchain::Vectorsearch::Weaviate.new(
    url: ENV["WEAVIATE_URL"],
    api_key: ENV["WEAVIATE_API_KEY"],
    index_name: "Documents",
    llm: llm
)

你也可以实例化其他任何支持的向量搜索数据库：

client = Langchain::Vectorsearch::Chroma.new(...)   # `gem "chroma-db", "~> 0.6.0"`
client = Langchain::Vectorsearch::Hnswlib.new(...)  # `gem "hnswlib", "~> 0.8.1"`
client = Langchain::Vectorsearch::Milvus.new(...)   # `gem "milvus", "~> 0.9.3"`
client = Langchain::Vectorsearch::Pinecone.new(...) # `gem "pinecone", "~> 1.0"`
client = Langchain::Vectorsearch::Pgvector.new(...) # `gem "pgvector", "~> 0.2"`
client = Langchain::Vectorsearch::Qdrant.new(...)   # `gem "qdrant-ruby", "~> 0.9.3"`
client = Langchain::Vectorsearch::Elasticsearch.new(...)   # `gem "elasticsearch", "~> 8.2.0"`

创建默认模式：

client.create_default_schema

将纯文本数据添加到你的向量搜索数据库中：

client.add_texts(
  texts: [
    "首先预热烤箱至 375°F（190°C）。准备四块去骨去皮鸡胸肉，在每块鸡胸肉的一侧切开一个口袋，注意不要完全切断。根据口味用盐和胡椒粉给鸡肉调味。在一口大煎锅中，用中火融化 2 汤匙无盐黄油。加入 1 个小洋葱丁和 2 瓣蒜末，炒至变软，约 3-4 分钟。加入 8 盎司新鲜菠菜，炒至菠菜变软，约 3 分钟。将锅从火上移开，让混合物稍微冷却。",
      "在一个碗中，将菠菜混合物与 4 盎司软化的奶油奶酪、1/4 杯磨碎的帕尔马干酪、1/4 杯马苏里拉奶酪丝以及 1/4 茶匙红辣椒碎混合均匀。将混合物均匀地填入每块鸡胸肉的口袋中。如有必要，可用牙签封住口袋。在同一口锅中，用中高火加热 1 汤匙橄榄油，放入酿好的鸡胸肉，每面煎 3-4 分钟，或直至金黄色。"
  ]
)

或者使用文件解析器加载、解析并将数据索引到你的数据库中：

my_pdf = Langchain.root.join("path/to/my.pdf")
my_text = Langchain.root.join("path/to/my.txt")
my_docx = Langchain.root.join("path/to/my.docx")

client.add_data(paths: [my_pdf, my_text, my_docx])

支持的文件格式：docx、html、pdf、text、json、jsonl、csv、xlsx、eml、pptx。

根据传入的查询字符串检索相似文档：

client.similarity_search(
  query:,
  k:       # 要检索的结果数量
)

根据通过 HyDE 技术 传入的查询字符串检索相似文档：

client.similarity_search_with_hyde()

根据传入的嵌入向量检索相似文档：

client.similarity_search_by_vector(
  embedding:,
  k:       # 要检索的结果数量
)

基于 RAG 的查询：

client.ask(question: "...")

助手

Langchain::Assistant 是一个强大而灵活的类，它结合了大型语言模型 (LLMs)、工具和对话管理，以创建智能、交互式的助手。它旨在处理复杂的对话、执行工具操作，并根据交互上下文提供连贯的响应。

特性

• 支持多个 LLM 提供商（OpenAI、Google Gemini、Anthropic、Mistral AI 以及通过 Ollama 使用的开源模型）
• 可集成多种工具以扩展功能
• 管理对话线程
• 处理自动和手动工具执行
• 支持不同 LLM 提供商的多种消息格式

使用方法

llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
assistant = Langchain::Assistant.new(
  llm: llm,
  instructions: "你是一位乐于助人的 AI 助手",
  tools: [Langchain::Tool::NewsRetriever.new(api_key: ENV["NEWS_API_KEY"])]
)

# 添加用户消息并运行助手
assistant.add_message_and_run!(content: "关于人工智能的最新消息是什么？")

# 向助手提供一张图片
assistant.add_message_and_run!(
  content: "请描述这张图片。",
  image_url: "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
)

# 访问对话线程
messages = assistant.messages

# 以自动工具执行方式运行助手
assistant.run(auto_tool_execution: true)

# 如果你想流式传输响应，可以添加一个响应处理器
assistant = Langchain::Assistant.new(
  llm: llm,
  instructions: "你是一位乐于助人的 AI 助手",
  tools: [Langchain::Tool::NewsRetriever.new(api_key: ENV["NEWS_API_KEY"])]
) do |response_chunk|
  # ...处理响应流
  # print(response_chunk.inspect)
end
assistant.add_message(content: "你好")
assistant.run(auto_tool_execution: true)

请注意，目前并非所有 LLM 都支持流式传输。

配置

• llm: 要使用的 LLM 实例（必填）
• tools: 工具实例数组（可选）
• instructions: 助手的系统指令（可选）
• tool_choice: 指定工具的选择方式。默认值为 "auto"。也可以传入具体的工具函数名称，这将强制助手始终使用该函数。
• parallel_tool_calls: 是否允许并行调用多个工具。默认值为 true。
• add_message_callback: 当有消息被添加到对话中时调用的回调函数（proc 或 lambda）（可选）

assistant.add_message_callback = -> (message) { puts "新消息: #{message}" }

• tool_execution_callback: 在工具执行之前调用的回调函数（proc 或 lambda）（可选）

assistant.tool_execution_callback = -> (tool_call_id, tool_name, method_name, tool_arguments) { puts "正在执行 tool_call_id: #{tool_call_id}, tool_name: #{tool_name}, method_name: #{method_name}, tool_arguments: #{tool_arguments}" }

主要方法

• add_message: 将用户消息添加到消息数组中。
• run!: 处理对话并生成响应。
• add_message_and_run!: 结合添加消息和运行助手的功能。
• submit_tool_output: 手动提交工具调用的输出。
• messages: 返回当前正在进行的消息列表。

内置工具 🛠️

• Langchain::Tool::Calculator: 用于计算数学表达式。需要安装 gem "eqn"。
• Langchain::Tool::Database: 连接你的 SQL 数据库。需要安装 gem "sequel"。
• Langchain::Tool::FileSystem: 与文件系统交互（读写）。
• Langchain::Tool::GoogleSearch: 基于 SerpApi 的 Google 搜索 API 封装。需要安装 gem "google_search_results"。
• Langchain::Tool::NewsRetriever: 基于 NewsApi.org 的新闻文章获取封装。
• Langchain::Tool::RubyCodeInterpreter: 用于执行生成的 Ruby 代码。需要安装 gem "safe_ruby"（仍在寻找更好的解决方案）。
• Langchain::Tool::Tavily: 基于 Tavily AI 的封装。
• Langchain::Tool::Vectorsearch: 向量搜索类的封装。
• Langchain::Tool::Weather: 调用 Open Weather API 获取当前天气。
• Langchain::Tool::Wikipedia: 调用 Wikipedia API。需要安装 gem "wikipedia-client"。

创建自定义工具

可以通过创建继承 Langchain::ToolDefinition 模块并实现所需方法的类，轻松扩展 Langchain::Assistant 的功能。

class MovieInfoTool
  extend Langchain::ToolDefinition

  define_function :search_movie, description: "MovieInfoTool：按标题搜索电影" do
    property :query, type: "string", description: "要搜索的电影标题", required: true
  end

  define_function :get_movie_details, description: "MovieInfoTool：获取特定电影的详细信息" do
    property :movie_id, type: "integer", description: "电影的 TMDb ID", required: true
  end

  def initialize(api_key:)
    @api_key = api_key
  end

  def search_movie(query:)
    tool_response(...)
  end

  def get_movie_details(movie_id:)
    tool_response(...)
  end
end

使用示例：

movie_tool = MovieInfoTool.new(api_key: "...")

assistant = Langchain::Assistant.new(
  llm: llm,
  instructions: "你是一个可以帮助提供电影信息的AI助手",
  tools: [movie_tool]
)

assistant.add_message_and_run(content: "你能告诉我关于电影《盗梦空间》的信息吗？")
# 查看对话中最后一条消息的回复
assistant.messages.last

错误处理

助手内置了对无效输入、不支持的 LLM 类型以及工具执行失败等情况的错误处理机制。它使用状态机来管理对话流程，并优雅地处理各种场景。

演示

1. 构建一个操作模拟电商商店的AI助手
2. 新的 Langchain.rb 助手界面
3. Langchain.rb 助手演示：结合 NewsRetriever 和 Gemini 的函数调用 - 代码

评估 (Evals)

评估模块是一组工具，可用于评估和跟踪 LLM 及其 RAG（检索增强生成）流水线的输出性能。

RAGAS

Ragas 帮助你评估你的检索增强生成（RAG）流水线。其实现基于这篇论文和原始的 Python 仓库。Ragas 会跟踪以下 3 个指标，并给出 0.0 到 1.0 的分数：

• 忠实度 - 答案基于给定的上下文。
• 上下文相关性 - 检索到的上下文集中且几乎没有无关信息。
• 答案相关性 - 生成的答案直接回答了提出的问题。

# 我们建议使用 Langchain::LLM::OpenAI 作为 Ragas 的 LLM
ragas = Langchain::Evals::Ragas::Main.new(llm: llm)

# LLM 生成的答案
# 提出的问题（或原始提示）
# 检索到的上下文（通常来自向量搜索数据库）
ragas.score(answer: "", question: "", context: "")
# =>
# {
#   ragas_score: 0.6601257446503674,
#   answer_relevance_score: 0.9573145866787608,
#   context_relevance_score: 0.6666666666666666,
#   faithfulness_score: 0.5
# }

示例

更多示例请参见：/examples

日志记录

Langchain.rb 使用标准的 Ruby Logger 机制，默认日志级别为 Logger::DEBUG。

若需显示所有日志消息：

Langchain.logger.level = Logger::DEBUG

默认情况下，日志会输出到 STDOUT。若要配置日志目标（例如写入文件），可以这样做：

Langchain.logger = Logger.new("path/to/file", **Langchain::LOGGER_OPTIONS)

问题

如果在安装 pragmatic_segmenter 所需的 unicode gem 时遇到问题，可以尝试运行以下命令：

gem install unicode -- --with-cflags="-Wno-incompatible-function-pointer-types"

开发

1. git clone https://github.com/patterns-ai-core/langchainrb.git
2. cp .env.example .env，然后填写 .env 文件中的环境变量。
3. bundle exec rake 来确保测试通过，并运行 standardrb。
4. bin/console 加载 gem 进入 REPL 会话。你可以自由添加自己的 LLM、工具、代理等实例，并进行实验。
5. 也可以选择安装 lefthook git hooks 用于 pre-commit 自动 lint：gem install lefthook && lefthook install -f

Discord

加入我们的 Langchain.rb Discord 服务器。

星标历史

贡献

欢迎在 GitHub 上提交 bug 报告和 pull 请求：https://github.com/patterns-ai-core/langchainrb。

许可证

该 gem 以开源形式发布，遵循 MIT 许可证 的条款。

Langchain.rb 快速上手指南

Langchain.rb 是一个用于在 Ruby 中构建大语言模型（LLM）驱动应用的开源库。它提供了统一的接口来连接多种 LLM 提供商，支持检索增强生成（RAG）、聊天机器人等场景。

环境准备

• 系统要求: 需要安装 Ruby (建议版本 3.0+)。
• 前置依赖:
  • 包管理工具：bundler (推荐) 或 gem。
  • API Key：根据你选择的 LLM 提供商（如 OpenAI, Anthropic, Google Gemini 等），需提前申请对应的 API Key 并配置为环境变量。
• 网络提示: 由于 LLM 服务大多位于海外，国内开发者可能需要配置代理或使用特定的网络加速方案以确保连接稳定。

安装步骤

方式一：使用 Bundler（推荐 Rails 或标准项目）

在项目根目录执行以下命令，将 gem 添加到 Gemfile 并安装：

bundle add langchainrb

方式二：直接安装

如果不使用 Bundler 管理依赖，可直接执行：

gem install langchainrb

注意：核心库不包含所有提供商的依赖。如果你需要使用特定的 LLM（如 anthropic 或 google-generative-ai），可能需要额外安装对应的 gem，具体请参考各提供商的文档说明。

基本使用

1. 引入库

在你的 Ruby 脚本或控制台入口文件中引入：

require "langchain"

2. 初始化 LLM 客户端

Langchain.rb 提供统一接口。以下以 OpenAI 为例，初始化客户端并设置默认参数：

llm = Langchain::LLM::OpenAI.new(
  api_key: ENV["OPENAI_API_KEY"],
  default_options: { temperature: 0.7, chat_model: "gpt-4o" }
)

注：切换其他提供商只需更改类名，例如 Langchain::LLM::Anthropic.new 或 Langchain::LLM::GoogleGemini.new。

3. 发起对话请求

构建消息历史并调用 chat 方法获取回复：

messages = [
  { role: "system", content: "You are a helpful assistant." },
  { role: "user", content: "请用中文介绍什么是 RAG？" }
]

response = llm.chat(messages: messages)
puts response.chat_completion

4. 进阶：结构化输出（可选）

如果你需要让 LLM 返回固定的 JSON 格式数据，可以使用 StructuredOutputParser：

# 定义 JSON Schema
json_schema = {
  type: "object",
  properties: {
    name: { type: "string", description: "人物姓名" },
    age: { type: "number", description: "人物年龄" }
  },
  required: ["name", "age"]
}

# 创建解析器
parser = Langchain::OutputParsers::StructuredOutputParser.from_json_schema(json_schema)

# 构建包含格式指令的 Prompt
prompt = Langchain::Prompt::PromptTemplate.new(
  template: "生成一个虚构人物的信息。\n{format_instructions}\n描述：{description}",
  input_variables: ["description", "format_instructions"]
)

prompt_text = prompt.format(description: "一位年轻的 Ruby 开发者", format_instructions: parser.get_format_instructions)

# 发送请求并解析结果
llm_response = llm.chat(messages: [{role: "user", content: prompt_text}]).completion
result = parser.parse(llm_response)

puts result 
# 输出示例：{"name"=>"张三", "age"=>28}