Langchain.js你应该知多点

import { ChatOpenAI } from 'langchain/llms/openai'
import { HumanChatMessage, AIChatMessage, SystemChatMessage } from 'langchain/schema'

// 初始化 ChatOpenAI 模型
const chatModel = new ChatOpenAI({
  openAIApiKey: 'your-api-key',
})

// 定义对话消息
const messages = [
  new SystemChatMessage('你是一位量子物理教授，专业回答科学问题。'),
  new HumanChatMessage('什么是量子纠缠？'),
]

// 模型生成回复
const response = await chatModel.call(messages)

// 输出 AI 的回复
console.log(response)

import { PromptTemplate } from 'langchain/prompts'

// 定义更复杂的模板，包含条件逻辑
const template = `
你好，我叫 {name}。
{#if topic}
今天我想讨论的是 {topic}。
{#else}
我今天没有特定的讨论话题。
{#/if}
`

// 使用 LangChain 内置的模板引擎支持
const prompt = new PromptTemplate({
  template: template,
  inputVariables: ['name', 'topic'],
})

// 当提供了 topic 时，生成不同的 prompt
const finalPromptWithTopic = await prompt.format({ name: '安笛杨', topic: '量子计算' })
console.log(finalPromptWithTopic)

// 当未提供 topic 时，生成的 prompt 会有不同的结构
const finalPromptWithoutTopic = await prompt.format({ name: '安笛杨' })
console.log(finalPromptWithoutTopic)

import { PromptTemplate, PipelinePromptTemplate } from 'langchain/prompts';

// 定义多个 PromptTemplate
const titlePrompt = new PromptTemplate({
  template: "请为以下内容生成一个标题：\n{content}",
  inputVariables: ["content"],
});

const introPrompt = new PromptTemplate({
  template: "请为这个标题生成一个简短的介绍：\n{title}",
  inputVariables: ["title"],
});

const summaryPrompt = new PromptTemplate({
  template: "请为这个介绍生成一个总结：\n{introduction}",
  inputVariables: ["introduction"],
});

// 使用 PipelinePromptTemplate 将多个 PromptTemplate 串联起来
const pipeline = new PipelinePromptTemplate({
  pipelinePrompts: [
    { name: "title", promptTemplate: titlePrompt },
    { name: "introduction", promptTemplate: introPrompt },
    { name: "summary", promptTemplate: summaryPrompt },
  ],
});

// 提供初始输入，并生成最终提示词
const finalPrompt = await pipeline.format({
  content: "量子计算正在改变未来的计算方式。",
});

console.log(finalPrompt);
// 输出：生成的最终提示词，会包含基于内容的标题、介绍和总结

import { OpenAI } from 'langchain/llms/openai'
import { Tool, AgentExecutor } from 'langchain/agents'

// 初始化 OpenAI 模型
const model = new OpenAI({
  openAIApiKey: 'your-api-key',
})

// 定义一个简单的工具函数，用于查询天气
const weatherTool = new Tool({
  name: 'getWeather',
  description: '根据城市名称查询当前天气',
  action: async (input) => {
    // 模拟天气查询逻辑
    const weatherData = {
      北京: '晴天 25°C',
      上海: '小雨 22°C',
    }
    return weatherData[input] || '无法获取该城市的天气数据'
  },
})

// 创建智能代理，允许模型根据输入动态选择工具
const executor = new AgentExecutor({
  tools: [weatherTool],
  llm: model,
})

// 通过模型输入选择工具
const input = '查询一下北京的天气'
const response = await executor.call({ input })
console.log(response) // 输出：北京的天气是晴天 25°C

import { OpenAI } from 'langchain/llms/openai'
import { PromptTemplate } from 'langchain/prompts'
import { SequentialChain } from 'langchain/chains'

// 初始化 OpenAI 模型
const model = new OpenAI({
  openAIApiKey: 'your-api-key',
})

// 定义生成标题的 PromptTemplate
const titlePrompt = new PromptTemplate({
  template: '请为以下内容生成一个标题：\n{content}',
  inputVariables: ['content'],
})

// 定义生成摘要的 PromptTemplate
const summaryPrompt = new PromptTemplate({
  template: '请基于这个标题生成一个简短的内容摘要：\n{title}',
  inputVariables: ['title'],
})

// 创建 SequentialChain，将两个步骤串联
const chain = new SequentialChain({
  chains: [
    new LLMChain({ llm: model, prompt: titlePrompt }), // 第一步：生成标题
    new LLMChain({ llm: model, prompt: summaryPrompt }), // 第二步：生成摘要
  ],
  inputVariables: ['content'], // 初始输入变量
  outputVariables: ['summary'], // 最终输出变量
})

// 执行链
const response = await chain.call({
  content: '量子计算是一种利用量子力学原理进行计算的新型技术。',
})

console.log(response) // 输出：基于标题生成的摘要

import { OpenAI } from 'langchain/llms/openai'
import { PromptTemplate } from 'langchain/prompts'
import { RunnableSequence } from 'langchain/chains'

// 初始化 OpenAI 模型
const model = new OpenAI({
  openAIApiKey: 'your-api-key',
})

// 定义生成摘要的 PromptTemplate
const summaryPrompt = new PromptTemplate({
  template: '请为以下内容生成一个简短的摘要：\n{content}',
  inputVariables: ['content'],
})

// 定义生成介绍的 PromptTemplate
const introductionPrompt = new PromptTemplate({
  template: '请基于这个摘要生成一个简短的介绍：\n{summary}',
  inputVariables: ['summary'],
})

// 使用 LCEL 构建一个链式调用
const chain = RunnableSequence.from([
  summaryPrompt, // 第一步：生成摘要
  model, // 第二步：调用语言模型生成摘要
  introductionPrompt, // 第三步：基于摘要生成介绍
  model, // 第四步：调用模型生成介绍
])

// 执行链式调用，传入初始内容
const response = await chain.call({ content: '量子计算是一种利用量子力学进行计算的技术。' })

console.log(response) // 输出最终生成的介绍

import { OpenAI } from 'langchain/llms/openai'
import { RunnableSequence } from 'langchain/chains'

// 初始化 OpenAI 模型
const model = new OpenAI({
  openAIApiKey: 'your-api-key',
})

// 使用 LCEL 添加条件逻辑
const chain = RunnableSequence.from([
  async (input) => {
    if (input.includes('weather')) {
      return '天气预报'
    } else {
      return '普通文本处理'
    }
  },
  model, // 基于条件选择不同的模型调用
])

// 执行链式调用
const response = await chain.call('Tell me the weather in New York.')
console.log(response) // 根据输入选择不同的模型处理