1
import { SystemMessage, HumanMessage, AIMessage, BaseMessage } from "@langchain/core/messages";
2

3
// 会话状态
4
interface Session {
5
  id: string;
6
  messages: BaseMessage[];  // 存储所有历史消息
7
  // ...其他配置
8
}
9

10
// Buffer 策略：全量返回所有消息
11
function bufferContext(session: Session): BaseMessage[] {
12
  return session.messages;
13
}

1
interface Session {
2
  id: string;
3
  messages: BaseMessage[];
4
  memoryStrategy: "buffer" | "window" | "summary" | "vector";
5
  windowSize: number;  // ← 窗口大小：保留最近 N 轮
6
}
7

8
function windowContext(session: Session): BaseMessage[] {
9
  // 去掉 System Message，取最近的 windowSize × 2 条消息（一轮两条）
10
  const nonSystem = session.messages.filter(m => m._getType() !== "system");
11
  const recent = nonSystem.slice(-session.windowSize * 2);
12

13
  // 如果有 System Message，放最前面
14
  const sys = session.messages.find(m => m._getType() === "system");
15
  return sys ? [sys, ...recent] : recent;
16
}

1
import { PromptTemplate } from "@langchain/core/prompts";
2
import { StringOutputParser } from "@langchain/core/output_parsers";
3

4
interface Session {
5
  id: string;
6
  messages: BaseMessage[];
7
  memoryStrategy: "buffer" | "window" | "summary" | "vector";
8
  summaryThreshold: number;  // 超过 N 条消息触发压缩
9
  recentToKeep: number;      // 压缩后保留最近 M 条原文
10
  summary?: string;           // 压缩后的摘要
11
}
12

13
// 摘要 Prompt
14
const summaryPrompt = PromptTemplate.fromTemplate(`
15
请将以下对话历史压缩为一段简洁的摘要，保留所有关键信息（人名、偏好、决策、重要事实等）。
16

17
{previous_summary}
18

19
对话历史：
20
{history}
21

22
请输出压缩后的摘要（只输出摘要内容，不要加任何前缀）：
23
`);
24

25
function formatMessages(messages: BaseMessage[]): string {
26
  return messages.map((msg) => {
27
    const role = msg instanceof HumanMessage ? "用户"
28
      : msg instanceof AIMessage ? "助手" : "系统";
29
    const content = typeof msg.content === "string" ? msg.content : String(msg.content);
30
    return `${role}：${content}`;
31
  }).join("\n");
32
}
33

34
async function summaryContext(session: Session): Promise<BaseMessage[]> {
35
  // 不管有没有摘要，都保留最近几条的原文
36
  const nonSystem = session.messages.filter(m => m._getType() !== "system");
37
  const recent = nonSystem.slice(-session.recentToKeep * 2);
38

39
  // 消息数量超过阈值 → 触发压缩
40
  if (nonSystem.length >= session.summaryThreshold) {
41
    const oldMessages = nonSystem.slice(0, -session.recentToKeep * 2);
42
    const historyText = formatMessages(oldMessages);
43

44
    // 调用 LLM 生成摘要
45
    const chain = summaryPrompt.pipe(llm).pipe(parser);
46
    session.summary = await chain.invoke({
47
      previous_summary: session.summary || "",
48
      history: historyText,
49
    });
50
  }
51

52
  // 构建上下文：System + 摘要 + 最近几条原文
53
  const result: BaseMessage[] = [];
54
  const sys = session.messages.find(m => m._getType() === "system");
55
  if (sys) result.push(sys);
56
  if (session.summary) {
57
    result.push(new SystemMessage(`之前的对话摘要：${session.summary}`));
58
  }
59
  result.push(...recent);
60
  return result;
61
}

1
import { Embeddings } from "@langchain/core/embeddings";
2
import { MemoryVectorStore } from "@langchain/classic/vectorstores/memory";
3

4
interface VectorEntry {
5
  text: string;
6
  vector: number[];
7
  metadata: { user: string; assistant: string };
8
}
9

10
interface Session {
11
  id: string;
12
  messages: BaseMessage[];
13
  memoryStrategy: "buffer" | "window" | "summary" | "vector";
14
  vectorEntries: VectorEntry[];  // 向量化的历史对话
15
  recentToKeep: number;
16
}
17

18
// 纯 JS 实现的 TF-IDF Embedding（不需要 API）
19
class TfIdfEmbeddings extends Embeddings {
20
  // ...省略实现（详见 RAG 那篇）
21
}
22

23
const embeddings = new TfIdfEmbeddings();
24

25
// 每轮对话结束，把这一轮存入向量库
26
export async function addToVectorStore(
27
  session: Session,
28
  userInput: string,
29
  aiResponse: string,
30
): Promise<void> {
31
  const text = `用户：${userInput}\n助手：${aiResponse}`;
32
  const [vector] = await embeddings.embedDocuments([text]);
33
  session.vectorEntries.push({
34
    text,
35
    vector,
36
    metadata: { user: userInput, assistant: aiResponse },
37
  });
38
}
39

40
// 余弦相似度计算
41
function cosineSimilarity(a: number[], b: number[]): number {
42
  const dot = a.reduce((sum, v, i) => sum + v * b[i], 0);
43
  const normA = Math.sqrt(a.reduce((sum, v) => sum + v * v, 0));
44
  const normB = Math.sqrt(b.reduce((sum, v) => sum + v * v, 0));
45
  return dot / (normA * normB);
46
}
47

48
// 构建上下文时，先检索相关历史
49
async function vectorContext(
50
  session: Session,
51
  currentInput: string,
52
): Promise<BaseMessage[]> {
53
  const result: BaseMessage[] = [];
54

55
  // System Message 放最前面
56
  const sys = session.messages.find(m => m._getType() === "system");
57
  if (sys) result.push(sys);
58

59
  // 检索相关历史对话（取 Top 3）
60
  if (session.vectorEntries.length > 0) {
61
    const queryVector = await embeddings.embedQuery(currentInput);
62
    const topK = session.vectorEntries
63
      .map(entry => ({
64
        entry,
65
        similarity: cosineSimilarity(queryVector, entry.vector),
66
      }))
67
      .sort((a, b) => b.similarity - a.similarity)
68
      .slice(0, 3)
69
      .map(item => item.entry.text);
70

71
    if (topK.length > 0) {
72
      result.push(new SystemMessage(
73
        `以下是从历史对话中检索到的相关内容：\n${topK.join("\n\n")}`
74
      ));
75
    }
76
  }
77

78
  // 再加上最近 N 轮对话原文
79
  const nonSystem = session.messages.filter(m => m._getType() !== "system");
80
  const recent = nonSystem.slice(-session.recentToKeep * 2);
81
  result.push(...recent);
82

83
  return result;
84
}

1
export async function getContextMessages(
2
  session: Session,
3
  currentInput?: string,
4
): Promise<BaseMessage[]> {
5
  switch (session.memoryStrategy) {
6
    case "buffer":
7
      return bufferContext(session);
8
    case "window":
9
      return windowContext(session);
10
    case "summary":
11
      return await summaryContext(session);
12
    case "vector":
13
      return await vectorContext(session, currentInput || "");
14
    default:
15
      return bufferContext(session);
16
  }
17
}

1
// 不管用什么策略，Handler 只需要调用这一行
2
const contextMessages = await getContextMessages(session, content);