Atopos

1
// 1. invoke - 标准调用，等待完整结果
2
const result = await llm.invoke(messages);
3

4
// 2. stream - 流式调用，逐 token 输出（打字机效果）
5
const stream = await llm.stream(messages);
6
for await (const chunk of stream) {
7
    process.stdout.write(chunk.content?.toString() || "");
8
}
9

10
// 3. batch - 批量调用，并行处理多个输入
11
const results = await llm.batch([["用户问题1"], ["用户问题2"], ["用户问题3"]]);

1
const history = new InMemoryChatMessageHistory();
2

3
// 每一轮对话都 push 新消息
4
history.addUserMessage("我叫小明");
5
history.addAIMessage("你好小明！");
6

7
// 获取全部历史传给 LLM
8
const allMessages = await history.getMessages();
9
const response = await llm.invoke(allMessages);

1
const WINDOW_SIZE = 3; // 保留最近 3 轮
2
const maxMessages = WINDOW_SIZE * 2;
3

4
function getRecentMessages(allMessages: BaseMessage[]): BaseMessage[] {
5
    if (allMessages.length <= maxMessages) return allMessages;
6
    return allMessages.slice(allMessages.length - maxMessages);
7
}

1
const SUMMARIZE_THRESHOLD = 6;
2
const RECENT_MESSAGES_TO_KEEP = 4;
3

4
const summarizerPrompt = PromptTemplate.fromTemplate(
5
    `请用中文总结以下对话的核心信息，保留所有关键事实：
6
{conversation}
7

8
摘要：`,
9
);
10

11
if (allMessages.length >= SUMMARIZE_THRESHOLD) {
12
    // 用 LLM 生成摘要
13
    const summary = await summarizerPrompt
14
        .pipe(llm)
15
        .pipe(new StringOutputParser())
16
        .invoke({ conversation: oldMessages });
17

18
    // 清除后重建：摘要 + 最近 N 条消息
19
    await history.clear();
20
    await history.addMessages([
21
        new SystemMessage(`对话摘要：${summary}`),
22
        ...recentMessages,
23
    ]);
24
}

1
import { OpenAIEmbeddings } from "@langchain/openai";
2

3
const embeddings = new OpenAIEmbeddings({
4
    configuration: { baseURL: "https://dashscope.aliyuncs.com/compat-mode/v1" },
5
});
6

7
// 存储结构
8
interface VectorEntry {
9
    text: string;
10
    vector: number[];
11
    metadata: { timestamp: number; role: string };
12
}
13

14
// 检索最相关记忆
15
async function retrieveRelevantMemories(query: string, topK = 2) {
16
    const queryVector = await embeddings.embedQuery(query);
17

18
    const scored = vectorStore.map((entry) => ({
19
        ...entry,
20
        score: cosineSimilarity(queryVector, entry.vector),
21
    }));
22

23
    return scored.sort((a, b) => b.score - a.score).slice(0, topK);
24
}
25

26
// 余弦相似度计算
27
function cosineSimilarity(a: number[], b: number[]): number {
28
    const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
29
    const normA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
30
    const normB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
31
    return dotProduct / (normA * normB);
32
}

1
import { RunnableSequence } from "@langchain/core/runnables";
2

3
const deepChain = RunnableSequence.from([
4
    // 第一步：分析问题
5
    {
6
        analysis: async (input: { question: string }) => {
7
            const analysis = await analysisPrompt.pipe(llm).invoke(input);
8
            return { ...input, analysis: analysis.content };
9
        },
10
    },
11
    // 第二步：深入研究
12
    {
13
        research: async (input) => {
14
            const research = await researchPrompt.pipe(llm).invoke(input);
15
            return { ...input, research: research.content };
16
        },
17
    },
18
    // 第三步：综合回答
19
    async (input) => {
20
        const conclusion = await synthesizePrompt.pipe(llm).invoke(input);
21
        return conclusion.content;
22
    },
23
]);

1
// 服务端：流式逐帧推送
2
ws.send(
3
    JSON.stringify({
4
        type: "chunk",
5
        content: "正在",
6
        mode: "stream",
7
    }),
8
);
9

10
// 客户端：逐帧累积
11
socket.onmessage = (event) => {
12
    const msg = JSON.parse(event.data);
13
    if (msg.type === "chunk") {
14
        setContent((prev) => prev + msg.content);
15
    } else if (msg.type === "done") {
16
        setIsComplete(true);
17
    }
18
};

1
// 简单的每会话每分钟限流
2
const now = Date.now();
3
const windowStart = now - 60_000;
4
const recentRequests = session.timestamps.filter((t) => t > windowStart);
5

6
if (recentRequests.length >= MAX_REQUESTS_PER_MINUTE) {
7
    ws.send(JSON.stringify({ type: "error", content: "请求过于频繁" }));
8
    return;
9
}

1
process.on("SIGTERM", async () => {
2
    console.log("收到 SIGTERM，正在关闭服务...");
3
    wss.close(() => {
4
        console.log("WebSocket 服务已关闭");
5
        process.exit(0);
6
    });
7
});