用 LangGraph 思考

import { StateGraph, START, END, GraphNode, Command } from "@langchain/langgraph";
import { HumanMessage } from "@langchain/core/messages";
import { ChatAnthropic } from "@langchain/anthropic";

const llm = new ChatAnthropic({ model: "claude-sonnet-4-6" });

const readEmail: GraphNode<typeof EmailAgentState> = async (state, config) => {
  // 提取和解析邮件内容
  // 在生产环境中，这将连接到你的邮件服务
  console.log(`Processing email: ${state.emailContent}`);
  return {};
}

const classifyIntent: GraphNode<typeof EmailAgentState> = async (state, config) => {
  // 使用 LLM 对邮件意图和紧急程度进行分类，然后相应地路由

  // 创建返回 EmailClassification 对象的结构化 LLM
  const structuredLlm = llm.withStructuredOutput(EmailClassificationSchema);

  // 按需格式化提示，不存储在状态中
  const classificationPrompt = `
  分析这封客户邮件并对其进行分类：

  邮件：${state.emailContent}
  来自：${state.senderEmail}

  提供包括意图、紧急程度、主题和摘要在内的分类。
  `;

  // 直接作为对象获取结构化响应
  const classification = await structuredLlm.invoke(classificationPrompt);

  // 根据分类确定下一个节点
  let nextNode: "searchDocumentation" | "humanReview" | "draftResponse" | "bugTracking";

  if (classification.intent === "billing" || classification.urgency === "critical") {
    nextNode = "humanReview";
  } else if (classification.intent === "question" || classification.intent === "feature") {
    nextNode = "searchDocumentation";
  } else if (classification.intent === "bug") {
    nextNode = "bugTracking";
  } else {
    nextNode = "draftResponse";
  }

  // 将分类作为单个对象存储在状态中
  return new Command({
    update: { classification },
    goto: nextNode,
  });
}

import { Command, GraphNode } from "@langchain/langgraph";

const searchDocumentation: GraphNode<typeof EmailAgentState> = async (state, config) => {
  // 搜索知识库以获取相关信息

  // 根据分类构建搜索查询
  const classification = state.classification!;
  const query = `${classification.intent} ${classification.topic}`;

  let searchResults: string[];

  try {
    // 在这里实现你的搜索逻辑
    // 存储原始搜索结果，而不是格式化的文本
    searchResults = [
      "通过设置 > 安全性 > 更改密码来重置密码",
      "密码必须至少 12 个字符",
      "包括大写字母、小写字母、数字和符号",
    ];
  } catch (error) {
    // 对于可恢复的搜索错误，存储错误并继续
    searchResults = [`Search temporarily unavailable: ${error}`];
  }

  return new Command({
    update: { searchResults },  // 存储原始结果或错误
    goto: "draftResponse",
  });
}

const bugTracking: GraphNode<typeof EmailAgentState> = async (state, config) => {
  // 创建或更新错误跟踪工单

  // 在你的错误跟踪系统中创建工单
  const ticketId = "BUG-12345";  // 将通过 API 创建

  return new Command({
    update: { searchResults: [`Bug ticket ${ticketId} created`] },
    goto: "draftResponse",
  });
}

import { Command, interrupt } from "@langchain/langgraph";

const draftResponse: GraphNode<typeof EmailAgentState> = async (state, config) => {
  // 使用上下文生成回复，并根据质量进行路由

  const classification = state.classification!;

  // 按需从原始状态数据格式化上下文
  const contextSections: string[] = [];

  if (state.searchResults) {
    // 为提示格式化搜索结果
    const formattedDocs = state.searchResults.map(doc => `- ${doc}`).join("\n");
    contextSections.push(`相关文档：\n${formattedDocs}`);
  }

  if (state.customerHistory) {
    // 为提示格式化客户数据
    contextSections.push(`客户等级：${state.customerHistory.tier ?? "standard"}`);
  }

  // 使用格式化的上下文构建提示
  const draftPrompt = `
  起草对这封客户邮件的回复：
  ${state.emailContent}

  邮件意图：${classification.intent}
  紧急程度：${classification.urgency}

  ${contextSections.join("\n\n")}

  指南：
  - 专业且乐于助人
  - 解决他们的具体问题
  - 在相关时使用提供的文档
  `;

  const response = await llm.invoke([new HumanMessage(draftPrompt)]);

  // 根据紧急程度和意图确定是否需要人工审核
  const needsReview = (
    classification.urgency === "high" ||
    classification.urgency === "critical" ||
    classification.intent === "complex"
  );

  // 路由到适当的下一个节点
  const nextNode = needsReview ? "humanReview" : "sendReply";

  return new Command({
    update: { responseText: response.content.toString() },  // 只存储原始回复
    goto: nextNode,
  });
}

const humanReview: GraphNode<typeof EmailAgentState> = async (state, config) => {
  // 使用 interrupt 暂停以进行人工审核，并根据决策进行路由
  const classification = state.classification!;

  // interrupt() 必须首先出现 - 它之前的任何代码在恢复时都会重新运行
  const humanDecision = interrupt({
    emailId: state.emailId,
    originalEmail: state.emailContent,
    draftResponse: state.responseText,
    urgency: classification.urgency,
    intent: classification.intent,
    action: "Please review and approve/edit this response",
  });

  // 现在处理人工决策
  if (humanDecision.approved) {
    return new Command({
      update: { responseText: humanDecision.editedResponse || state.responseText },
      goto: "sendReply",
    });
  } else {
    // 拒绝意味着人工将直接处理
    return new Command({ update: {}, goto: END });
  }
}

const sendReply: GraphNode<typeof EmailAgentState> = async (state, config) => {
  // 发送邮件回复
  // 与邮件服务集成
  console.log(`Sending reply: ${state.responseText!.substring(0, 100)}...`);
  return {};
}