# 核心包
npm install langchain @langchain/core
 
# 模型提供商（选你用的）
npm install @langchain/openai      # OpenAI
npm install @langchain/anthropic   # Claude
npm install @langchain/google-genai # Gemini
 
# 工具依赖
npm install zod                     # schema 定义

import { initChatModel } from "langchain";
 
// 设置 API Key（实际项目中用环境变量）
process.env.OPENAI_API_KEY = "your-api-key";
 
// 初始化模型
const model = await initChatModel("gpt-4o-mini");
 
// 调用
const response = await model.invoke("为什么鹦鹉会说话？");
 
console.log(response.content);
// "鹦鹉会说话是因为它们有很强的模仿能力..."

import { createAgent, tool } from "langchain";
import * as z from "zod";
 
// 定义一个工具：查天气
const getWeather = tool(
  // 工具的执行逻辑
  ({ city }) => `今天 ${city} 天气晴朗，温度 25°C`,
  {
    name: "get_weather",              // 工具名称
    description: "查询指定城市的天气",  // AI 看到的描述
    schema: z.object({
      city: z.string().describe("城市名称，如：北京、上海")
    })
  }
);
 
// 创建 Agent
const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [getWeather]
});
 
// 使用
const result = await agent.invoke({
  messages: [{ role: "user", content: "北京今天天气怎么样？" }]
});
 
console.log(result.messages[result.messages.length - 1].content);
// "根据查询结果，北京今天天气晴朗，温度 25°C。适合出门散步！"

// OpenAI
const agent1 = createAgent({
  model: "openai:gpt-4o-mini",
  tools: []
});
 
// Anthropic Claude
const agent2 = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: []
});
 
// Google Gemini
const agent3 = createAgent({
  model: "google-genai:gemini-2.0-flash",
  tools: []
});
 
// Azure OpenAI
const agent4 = createAgent({
  model: "azure_openai:gpt-4o",
  tools: []
});

OPENAI_API_KEY=xxx
ANTHROPIC_API_KEY=xxx
GOOGLE_API_KEY=xxx
AZURE_OPENAI_API_KEY=xxx
AZURE_OPENAI_ENDPOINT=xxx

import { initChatModel } from "langchain";
 
const model = await initChatModel("gpt-4o-mini", {
  temperature: 0.7,    // 创造性：0-1，越高越随机
  maxTokens: 1000,     // 最大输出长度
  timeout: 30,         // 超时时间（秒）
  maxRetries: 3        // 失败重试次数
});
 
const agent = createAgent({
  model,
  tools: []
});

const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [getWeather],
  systemPrompt: `你是一个专业的天气预报助手。
  
你的职责：
1. 查询用户指定城市的天气
2. 用轻松幽默的语气回复
3. 给出穿衣建议
 
如果用户没有指定城市，询问他们的位置。`
});
 
// 使用
await agent.invoke({
  messages: [{ role: "user", content: "今天要穿什么？" }]
});
// AI 会先问 "你在哪个城市？"

import * as z from "zod";
 
// 定义输出格式
const WeatherReport = z.object({
  city: z.string(),
  temperature: z.number(),
  condition: z.enum(["晴", "雨", "多云", "雪"]),
  suggestion: z.string().describe("穿衣建议")
});
 
const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [getWeather],
  responseFormat: WeatherReport  // 强制输出这个格式
});
 
const result = await agent.invoke({
  messages: [{ role: "user", content: "北京天气" }]
});
 
// 直接拿到结构化数据
console.log(result.structuredResponse);
// {
//   city: "北京",
//   temperature: 25,
//   condition: "晴",
//   suggestion: "建议穿短袖，带个薄外套"
// }

import { MemorySaver } from "@langchain/langgraph";
 
// 创建记忆存储
const checkpointer = new MemorySaver();
 
const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [getWeather],
  checkpointer  // 启用记忆
});
 
// 第一次对话
await agent.invoke(
  { messages: [{ role: "user", content: "我叫小明" }] },
  { configurable: { thread_id: "user-123" } }  // thread_id 区分不同用户
);
 
// 第二次对话（同一个 thread_id）
const result = await agent.invoke(
  { messages: [{ role: "user", content: "我叫什么名字？" }] },
  { configurable: { thread_id: "user-123" } }
);
 
console.log(result.messages[result.messages.length - 1].content);
// "你叫小明，你刚才告诉我的。"

import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";
 
const checkpointer = PostgresSaver.fromConnString(
  "postgresql://user:pass@localhost:5432/mydb"
);

import { tool, type ToolRuntime } from "langchain";
 
// 定义上下文类型
type MyContext = { user_id: string; user_name: string };
 
const getUserInfo = tool(
  async (_, config: ToolRuntime<unknown, MyContext>) => {
    // 从 config.context 获取上下文
    const { user_id, user_name } = config.context;
    
    // 模拟查询数据库
    return `用户 ${user_name}（ID: ${user_id}）已登录 3 天`;
  },
  {
    name: "get_user_info",
    description: "获取当前用户信息",
    schema: z.object({})
  }
);
 
const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [getUserInfo],
  contextSchema: z.object({
    user_id: z.string(),
    user_name: z.string()
  })
});
 
// 调用时传入上下文
await agent.invoke(
  { messages: [{ role: "user", content: "我是谁？" }] },
  { context: { user_id: "abc123", user_name: "张三" } }
);

const agent = createAgent({
  model: "gpt-4o-mini",
  tools: []
});
 
const stream = await agent.stream(
  { messages: [{ role: "user", content: "讲一个笑话" }] },
  { streamMode: "values" }
);
 
// 逐块输出
for await (const chunk of stream) {
  const lastMessage = chunk.messages[chunk.messages.length - 1];
  if (lastMessage.role === "assistant") {
    console.log(lastMessage.content);  // 逐步打印
  }
}

// 1. 返回字符串（最常见）
const search = tool(
  ({ query }) => `找到 3 条关于 "${query}" 的结果`,
  { name: "search", schema: z.object({ query: z.string() }) }
);
 
// 2. 返回对象（结构化数据）
const getWeatherData = tool(
  ({ city }) => ({
    city,
    temperature: 25,
    humidity: 60,
    wind: "东北风 3级"
  }),
  { name: "get_weather_data", schema: z.object({ city: z.string() }) }
);
 
// 3. 返回 Command（更新 Agent 状态）
import { Command } from "@langchain/langgraph";
import { ToolMessage } from "@langchain/core/messages";
 
const setLanguage = tool(
  async ({ language }, config) => {
    return new Command({
      update: {
        preferredLanguage: language,
        messages: [
          new ToolMessage({
            content: `语言已切换为 ${language}`,
            tool_call_id: config.toolCallId
          })
        ]
      }
    });
  },
  {
    name: "set_language",
    schema: z.object({ language: z.string() })
  }
);

import { createAgent, tool } from "langchain";
import * as z from "zod";
import { MemorySaver } from "@langchain/langgraph";
 
// 查询订单工具
const queryOrder = tool(
  async ({ orderId }) => {
    // 模拟数据库查询
    const orders = {
      "12345": { status: "已发货", items: ["iPhone 15", "AirPods"], total: 9999 },
      "67890": { status: "待支付", items: ["MacBook Pro"], total: 19999 }
    };
    const order = orders[orderId as keyof typeof orders];
    return order 
      ? `订单 ${orderId}: ${order.status}, 商品: ${order.items.join(", ")}, 总价: ¥${order.total}`
      : `未找到订单 ${orderId}`;
  },
  {
    name: "query_order",
    description: "查询订单状态和详情",
    schema: z.object({
      orderId: z.string().describe("订单号")
    })
  }
);
 
// 申请退款工具
const requestRefund = tool(
  async ({ orderId, reason }) => {
    // 模拟退款处理
    return `退款申请已提交：订单 ${orderId}, 原因: ${reason}。预计 3-5 个工作日处理。`;
  },
  {
    name: "request_refund",
    description: "申请订单退款",
    schema: z.object({
      orderId: z.string().describe("订单号"),
      reason: z.string().describe("退款原因")
    })
  }
);
 
// 创建客服 Agent
const customerServiceAgent = createAgent({
  model: "gpt-4o-mini",
  tools: [queryOrder, requestRefund],
  systemPrompt: `你是电商平台的客服助手。
 
你的职责：
1. 查询用户订单状态
2. 处理退款申请
3. 解答常见问题
 
规则：
- 用户询问订单时，先查订单状态再回复
- 退款需要用户提供订单号和原因
- 保持礼貌、专业的语气`,
  checkpointer: new MemorySaver()  // 启用记忆
});
 
// 使用示例
const config = { configurable: { thread_id: "customer-001" } };
 
// 用户查订单
await customerServiceAgent.invoke(
  { messages: [{ role: "user", content: "帮我查一下订单 12345" }] },
  config
);
 
// 用户申请退款（Agent 会记住订单号）
await customerServiceAgent.invoke(
  { messages: [{ role: "user", content: "我想退款，东西不喜欢" }] },
  config
);

// 执行代码工具（模拟）
const runCode = tool(
  async ({ code, language }) => {
    // 实际项目中可以用沙箱执行
    if (language === "javascript") {
      try {
        const result = eval(code);
        return `执行结果: ${result}`;
      } catch (e) {
        return `错误: ${e.message}`;
      }
    }
    return `暂不支持 ${language}`;
  },
  {
    name: "run_code",
    description: "执行代码并返回结果",
    schema: z.object({
      code: z.string().describe("要执行的代码"),
      language: z.enum(["javascript", "python"]).describe("编程语言")
    })
  }
);
 
// 搜索文档工具（模拟）
const searchDocs = tool(
  async ({ query }) => {
    // 实际项目中调用搜索引擎
    const docs = {
      "react useState": "useState 是 React 的状态管理 Hook...",
      "vue computed": "computed 是 Vue 的计算属性..."
    };
    return docs[query as keyof typeof docs] || `未找到 "${query}" 相关文档`;
  },
  {
    name: "search_docs",
    description: "搜索技术文档",
    schema: z.object({
      query: z.string().describe("搜索关键词")
    })
  }
);
 
const codeAgent = createAgent({
  model: "gpt-4o-mini",
  tools: [runCode, searchDocs],
  systemPrompt: `你是一个代码助手。
 
职责：
1. 解释代码逻辑
2. 生成代码示例
3. 搜索技术文档
4. 执行简单代码
 
规则：
- 生成代码后，询问是否需要执行
- 解释要清晰、有注释
- 推荐最佳实践`
});
 
// 使用
await codeAgent.invoke({
  messages: [{ 
    role: "user", 
    content: "帮我写一个 React 计数器组件" 
  }]
});

// 定义输出格式：分析报告
const AnalysisReport = z.object({
  summary: z.string().describe("数据摘要"),
  trends: z.array(z.string()).describe("发现趋势"),
  recommendations: z.array(z.string()).describe("建议"),
  confidence: z.number().min(0).max(1).describe("置信度")
});
 
// 查询数据库工具
const queryDatabase = tool(
  async ({ table, conditions }) => {
    // 模拟数据库查询
    return `查询 ${table} 表，条件: ${conditions.join(", ")}。返回 100 条记录。`;
  },
  {
    name: "query_database",
    description: "查询数据库",
    schema: z.object({
      table: z.string().describe("表名"),
      conditions: z.array(z.string()).describe("查询条件")
    })
  }
);
 
// 生成图表工具
const generateChart = tool(
  async ({ type, data, title }) => {
    // 实际项目中生成真实图表
    return `已生成 ${type} 图表："${title}"。数据包含 ${data.length} 个点。`;
  },
  {
    name: "generate_chart",
    description: "生成数据图表",
    schema: z.object({
      type: z.enum(["bar", "line", "pie"]),
      data: z.array(z.number()),
      title: z.string()
    })
  }
);
 
const dataAnalystAgent = createAgent({
  model: "gpt-4o-mini",
  tools: [queryDatabase, generateChart],
  responseFormat: AnalysisReport,  // 强制输出结构化报告
  systemPrompt: `你是数据分析助手。
 
工作流程：
1. 理解用户分析需求
2. 查询相关数据
3. 分析数据趋势
4. 生成可视化图表
5. 输出结构化报告
 
报告必须包含：摘要、趋势、建议、置信度。`
});
 
// 使用
const result = await dataAnalystAgent.invoke({
  messages: [{ 
    role: "user", 
    content: "分析最近一周的用户注册数据" 
  }]
});
 
console.log(result.structuredResponse);

import { createAgent, tool } from "langchain";
import * as z from "zod";
 
// 天气查询
const getWeather = tool(
  ({ city }) => `${city}: 晴, 28°C`,
  { name: "get_weather", schema: z.object({ city: z.string() }) }
);
 
// 餐厅推荐
const searchRestaurants = tool(
  ({ city, cuisine }) => `${city} 有 5 家 ${cuisine} 餐厅推荐`,
  { 
    name: "search_restaurants", 
    schema: z.object({ 
      city: z.string(), 
      cuisine: z.string().optional() 
    }) 
  }
);
 
// 电影查询
const getMovies = tool(
  ({ genre }) => `推荐 3 部 ${genre} 电影`,
  { name: "get_movies", schema: z.object({ genre: z.string() }) }
);
 
// 日程安排
const scheduleEvent = tool(
  ({ date, time, event }) => `已安排：${date} ${time} - ${event}`,
  { 
    name: "schedule_event", 
    schema: z.object({ 
      date: z.string(), 
      time: z.string(), 
      event: z.string() 
    }) 
  }
);
 
// 万能助手
const superAgent = createAgent({
  model: "gpt-4o-mini",
  tools: [getWeather, searchRestaurants, getMovies, scheduleEvent],
  systemPrompt: `你是万能助手，可以帮用户：
- 查天气
- 推荐餐厅
- 推荐电影
- 安排日程
 
根据用户需求，自动选择合适的工具组合。
例如用户说"周末安排"，你可以：
1. 查周末天气
2. 推荐餐厅
3. 推荐电影
4. 生成日程安排`,
  checkpointer: new MemorySaver()
});
 
// 使用：用户一句话，Agent 自动调用多个工具
const result = await superAgent.invoke({
  messages: [{ role: "user", content: "帮我安排北京这周末的活动" }]
});

// backend.ts - 后端 API
import { createAgent, tool } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
 
const chatAgent = createAgent({
  model: "gpt-4o-mini",
  tools: [],
  checkpointer: new MemorySaver()
});
 
// Express API
app.post("/chat", async (req, res) => {
  const { message, threadId } = req.body;
  
  const stream = await chatAgent.stream(
    { messages: [{ role: "user", content: message }] },
    { configurable: { thread_id: threadId }, streamMode: "values" }
  );
  
  // 返回流式响应
  res.setHeader("Content-Type", "text/event-stream");
  for await (const chunk of stream) {
    const msg = chunk.messages[chunk.messages.length - 1];
    if (msg.role === "assistant") {
      res.write(`data: ${JSON.stringify({ content: msg.content })}\n\n`);
    }
  }
  res.end();
});

// frontend.tsx - React 组件
import { useState } from "react";
 
function ChatComponent() {
  const [messages, setMessages] = useState<Array<{role: string, content: string}>>([]);
  const [input, setInput] = useState("");
  const threadId = "user-" + Math.random().toString(36).slice(2);
 
  async function sendMessage() {
    setMessages(prev => [...prev, { role: "user", content: input }]);
    setInput("");
 
    // 流式接收
    const response = await fetch("/chat", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ message: input, threadId })
    });
 
    const reader = response.body?.getReader();
    const decoder = new TextDecoder();
    let aiMessage = "";
 
    while (reader) {
      const { done, value } = await reader.read();
      if (done) break;
      
      const chunk = decoder.decode(value);
      const lines = chunk.split("\n").filter(l => l.startsWith("data:"));
      
      for (const line of lines) {
        const data = JSON.parse(line.slice(5));
        aiMessage += data.content;
        setMessages(prev => {
          const last = prev[prev.length - 1];
          if (last?.role === "assistant") {
            return [...prev.slice(0, -1), { role: "assistant", content: aiMessage }];
          }
          return [...prev, { role: "assistant", content: aiMessage }];
        });
      }
    }
  }
 
  return (
    <div className="chat">
      {messages.map((msg, i) => (
        <div key={i} className={`message ${msg.role}`}>
          {msg.content}
        </div>
      ))}
      <input 
        value={input} 
        onChange={e => setInput(e.target.value)}
        onKeyDown={e => e.key === "Enter" && sendMessage()}
      />
      <button onClick={sendMessage}>发送</button>
    </div>
  );
}

import { ToolNode } from "@langchain/langgraph/prebuilt";
 
// 默认：错误会中断执行
const toolNode = new ToolNode(tools);
 
// 捕获错误，继续执行
const toolNode = new ToolNode(tools, { 
  handleToolErrors: true  // 或传自定义消息
});
 
const toolNode = new ToolNode(tools, { 
  handleToolErrors: "工具执行失败，请稍后重试"
});

import { createMiddleware } from "langchain";
import { RemoveMessage, REMOVE_ALL_MESSAGES } from "@langchain/langgraph";
 
const trimMessages = createMiddleware({
  name: "TrimMessages",
  beforeModel: (state) => {
    const messages = state.messages;
    
    if (messages.length <= 5) return;
    
    // 保留第一条 + 最近 4 条
    const firstMsg = messages[0];
    const recent = messages.slice(-4);
    const newMessages = [firstMsg, ...recent];
    
    return {
      messages: [
        new RemoveMessage({ id: REMOVE_ALL_MESSAGES }),
        ...newMessages
      ]
    };
  }
});
 
const agent = createAgent({
  model: "gpt-4o-mini",
  middleware: [trimMessages],
  checkpointer: new MemorySaver()
});

process.env.OPENAI_API_KEY = "xxx";
const agent = createAgent({ model: "gpt-4o-mini", tools: [] });

// 方案 1：通过后端代理
const response = await fetch("/api/chat", {
  method: "POST",
  body: JSON.stringify({ message })
});
 
// 方案 2：使用边缘函数（Vercel/Cloudflare）
// API Key 在边缘函数中，不暴露给前端

# 设置环境变量
LANGSMITH_TRACING=true
LANGSMITH_API_KEY=xxx

// 改进工具描述
const search = tool(
  ({ query }) => `结果`,
  {
    name: "web_search",
    description: "当用户询问实时信息、新闻、天气时使用此工具",  // 明确触发条件
    schema: z.object({ query: z.string() })
  }
);
 
// 确认模型支持工具调用
// OpenAI: gpt-4o, gpt-4o-mini, gpt-4-turbo
// Anthropic: claude-3.5-sonnet, claude-3-opus
// Gemini: gemini-1.5-pro, gemini-2.0-flash

import { createMiddleware } from "langchain";
 
const dynamicTools = createMiddleware({
  name: "DynamicTools",
  wrapModelCall: (request, handler) => {
    const userRole = request.runtime?.context?.userRole;
    
    let filteredTools = request.tools;
    
    if (userRole === "guest") {
      // 游客只能用查询工具
      filteredTools = request.tools.filter(
        t => t.name.startsWith("query_")
      );
    } else if (userRole === "admin") {
      // 管理员可以用所有工具
    }
    
    return handler({ ...request, tools: filteredTools });
  }
});
 
const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [queryTool, deleteTool, updateTool],
  middleware: [dynamicTools]
});

import * as z from "zod";
 
// 基础类型
const BasicSchema = z.object({
  name: z.string(),
  age: z.number(),
  email: z.string().email()
});
 
// 可选字段
const OptionalSchema = z.object({
  title: z.string(),
  subtitle: z.string().optional(),
  tags: z.array(z.string()).optional()
});
 
// 嵌套对象
const NestedSchema = z.object({
  user: z.object({
    name: z.string(),
    address: z.object({
      city: z.string(),
      zip: z.string()
    })
  }),
  orders: z.array(z.object({
    id: z.string(),
    amount: z.number()
  }))
});
 
// 带描述（AI 看得到）
const DescribedSchema = z.object({
  query: z.string().describe("搜索关键词，最多 50 字"),
  limit: z.number().min(1).max(100).describe("返回结果数量，1-100")
});
 
// 枚举
const EnumSchema = z.object({
  status: z.enum(["pending", "completed", "cancelled"]),
  priority: z.enum(["low", "medium", "high"])
});

// 最小 Agent
const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [myTool]
});
 
// 带 Memory
const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [],
  checkpointer: new MemorySaver()
});
 
// 带结构化输出
const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [],
  responseFormat: z.object({ result: z.string() })
});
 
// 带提示词
const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [],
  systemPrompt: "你是..."
});
 
// 调用
await agent.invoke({ messages: [{ role: "user", content: "..." }] });