@langgraph-js/ui 1.4.0 → 1.6.0

package/src/memory/fulltext-search.ts

@@ -0,0 +1,191 @@
+// minisearch-idb-chinese-search.ts
+
+import MiniSearch, { AsPlainObject, type Options, type SearchOptions, type SearchResult } from "minisearch";
+import { openDB, type IDBPDatabase } from "idb";
+import { BaseDB, BaseDBConfig } from "./BaseDB";
+import { MemoryRecord } from "./db";
+
+/**
+ * 搜索服务配置接口
+ */
+export interface FullTextSearchConfig extends BaseDBConfig {
+    miniSearchOptions?: Partial<Options<MemoryRecord>>;
+}
+
+// 默认配置
+const DEFAULT_CONFIG: Required<FullTextSearchConfig> = {
+    dbName: "minisearch_memory_db",
+    dbVersion: 1,
+    storeName: "memory",
+    miniSearchOptions: {
+        fields: ["text", "path", "tags", "referencePath"],
+        storeFields: ["text", "path", "tags", "referencePath"],
+        tokenize: chineseWordSegmenter,
+    },
+};
+
+// --- 1. 中文分词器 ---
+/**
+ * 中文分词器，使用 Intl.Segmenter 将中文文本分割成词语。
+ * @param text 需要分词的中文文本。
+ * @returns 词语数组。
+ */
+function chineseWordSegmenter(text: string): string[] {
+    // 移除所有空格，因为中文词语之间通常没有空格
+    const cleanText = text.replace(/ /g, "");
+
+    // 使用 Intl.Segmenter 进行词语分词
+    // 'zh-CN' 或 'cn' 都可以表示中文（中国大陆）
+    const segmenter = new Intl.Segmenter("zh-CN", { granularity: "word" });
+
+    // 获取分词结果并只保留词语内容
+    const segments = Array.from(segmenter.segment(cleanText)).map((item) => item.segment);
+
+    return segments;
+}
+
+export class FullTextSearchService extends BaseDB<MemoryRecord> {
+    private miniSearch!: MiniSearch<MemoryRecord>;
+    protected config: Required<FullTextSearchConfig>;
+    protected db!: IDBPDatabase;
+    constructor(config?: FullTextSearchConfig) {
+        const mergedConfig = {
+            ...DEFAULT_CONFIG,
+            ...config,
+            miniSearchOptions: {
+                ...DEFAULT_CONFIG.miniSearchOptions,
+                ...(config?.miniSearchOptions || {}),
+            },
+        };
+        super(mergedConfig);
+        this.config = mergedConfig;
+    }
+
+    public async initialize(): Promise<void> {
+        if (this.isInitialized) {
+            return;
+        }
+
+        const { storeName } = this.config;
+        this.db = await openDB(this.config.dbName, this.config.dbVersion, {
+            upgrade(db) {
+                if (!db.objectStoreNames.contains(storeName)) {
+                    db.createObjectStore(storeName, { keyPath: "id", autoIncrement: true });
+                }
+                if (!db.objectStoreNames.contains("minisearch_index")) {
+                    db.createObjectStore("minisearch_index");
+                }
+            },
+        });
+
+        // 确保 miniSearchOptions 包含所有必需的字段
+        const miniSearchOptions: Options<MemoryRecord> = {
+            fields: this.config.miniSearchOptions.fields || ["text"],
+            storeFields: this.config.miniSearchOptions.storeFields || ["text"],
+            tokenize: this.config.miniSearchOptions.tokenize || chineseWordSegmenter,
+        };
+
+        this.miniSearch = new MiniSearch(miniSearchOptions);
+
+        try {
+            const savedIndex = await this.loadMiniSearchIndex();
+            if (savedIndex) {
+                console.log(savedIndex);
+                this.miniSearch = await MiniSearch.loadJSAsync(savedIndex, miniSearchOptions);
+                console.log("MiniSearch index loaded from IndexedDB.");
+            } else {
+                console.log("No saved index found, building from documents...");
+                const allDocs = await this.getAll();
+                if (allDocs.length > 0) {
+                    this.miniSearch.addAll(allDocs);
+                    await this.saveMiniSearchIndex(this.miniSearch.toJSON());
+                    console.log(`MiniSearch index built from ${allDocs.length} documents and saved.`);
+                } else {
+                    console.log("No documents found, index is empty.");
+                }
+            }
+            this.isInitialized = true;
+        } catch (error) {
+            console.error("Failed to initialize FullTextSearchService:", error);
+            throw error;
+        }
+    }
+
+    public async insert(doc: Partial<MemoryRecord>): Promise<number> {
+        const transaction = this.db.transaction(this.config.storeName, "readwrite");
+        const store = transaction.objectStore(this.config.storeName);
+        const newDoc: MemoryRecord = { ...doc } as MemoryRecord;
+
+        const id = await store.add(newDoc);
+        newDoc.id = Number(id);
+
+        await transaction.done;
+
+        this.miniSearch.add(newDoc);
+        await this.saveMiniSearchIndex(this.miniSearch.toJSON());
+
+        return newDoc.id;
+    }
+
+    public async update(id: number, doc: Partial<MemoryRecord>): Promise<void> {
+        const transaction = this.db.transaction(this.config.storeName, "readwrite");
+        const store = transaction.objectStore(this.config.storeName);
+        const updatedDoc = { ...doc, id } as MemoryRecord;
+        await store.put(updatedDoc);
+
+        // MiniSearch 没有 update 方法，我们需要先删除再添加
+        const existingDoc = await store.get(id);
+        if (existingDoc) {
+            this.miniSearch.remove(existingDoc);
+        }
+        this.miniSearch.add(updatedDoc);
+        await this.saveMiniSearchIndex(this.miniSearch.toJSON());
+    }
+
+    public async delete(id: number): Promise<void> {
+        const transaction = this.db.transaction(this.config.storeName, "readwrite");
+        const store = transaction.objectStore(this.config.storeName);
+        const doc = await store.get(id);
+        if (doc) {
+            this.miniSearch.remove(doc);
+        }
+        await store.delete(id);
+        await this.saveMiniSearchIndex(this.miniSearch.toJSON());
+    }
+
+    public async query(query: string, options?: SearchOptions & { limit?: number }): Promise<MemoryRecord[]> {
+        const results = this.miniSearch.search(query, options);
+        // 将 SearchResult 转换为 MemoryRecord
+        return results.slice(0, options?.limit ?? 5).map((i) => {
+            const { id, text, ...rest } = i;
+            return {
+                id,
+                text,
+                tags: rest.tags,
+                path: rest.path,
+                type: rest.type,
+                score: Math.round(i.score),
+                referencePath: rest.referencePath,
+            } as unknown as MemoryRecord;
+        });
+    }
+
+    public async get(id: number): Promise<MemoryRecord | undefined> {
+        return this.db.transaction(this.config.storeName, "readonly").objectStore(this.config.storeName).get(id);
+    }
+
+    public async getAll(): Promise<MemoryRecord[]> {
+        return this.db.transaction(this.config.storeName, "readonly").objectStore(this.config.storeName).getAll();
+    }
+
+    private async loadMiniSearchIndex(): Promise<AsPlainObject | null> {
+        return this.db.transaction("minisearch_index", "readonly").objectStore("minisearch_index").get("indexData");
+    }
+
+    private async saveMiniSearchIndex(indexData: AsPlainObject): Promise<void> {
+        const tx = this.db.transaction("minisearch_index", "readwrite");
+        const store = tx.objectStore("minisearch_index");
+        await store.put(indexData, "indexData");
+        await tx.done;
+    }
+}

package/src/memory/index.ts

@@ -0,0 +1,4 @@
+export * from "./tools";
+export * from "./db";
+export * from "./fulltext-search";
+export * from "./BaseDB";

package/src/memory/tools.ts

@@ -0,0 +1,170 @@
+import { createToolUI } from "@langgraph-js/sdk";
+import type { BaseDB, MemoryRecord } from "./BaseDB";
+
+// 获取命名空间（这里简化为标识符）
+function getNamespace(userId?: string): string {
+    return userId || "default";
+}
+
+// 确保 JSON 可序列化
+function ensureJsonSerializable(content: any): any {
+    if (typeof content === "string" || typeof content === "number" || typeof content === "boolean" || content === null) {
+        return content;
+    }
+    if (Array.isArray(content) || typeof content === "object") {
+        return content;
+    }
+    return String(content);
+}
+
+export const createMemoryTool = (store: BaseDB<MemoryRecord>) => {
+    return {
+        manageMemory: createToolUI({
+            name: "manage_memory",
+            description: `这是一个**结构化**工具，用于**管理跨对话的持久化记忆**，以保留上下文、用户偏好和学习到的见解。它支持**创建、更新、检索和删除记忆条目**，从而在互动中保持连续性和个性化。
+
+### 你需要记录记忆的场景
+
+1. 请你第一时间敏锐记录下用户的细节偏好，包括对话风格、习惯、内容、方式等。
+2. 记录下高价值的问答，比如用户对你的纠正、任务过程中的关键信息
+
+
+### 核心功能
+
+该工具具备以下关键能力：
+
+* **记忆生命周期管理：** 对记忆条目进行**全生命周期管理**，包括创建、更新、检索和删除。
+* **分段与标签支持：** 支持**分段或打标签的记忆条目**，方便分类和高效检索。
+* **存储选项灵活：** 提供**临时和永久两种存储选项**，以适应不同类型信息的存储需求。
+`,
+            parameters: [
+                {
+                    name: "path",
+                    type: "string",
+                    description: "记忆路径（创建时需要）",
+                },
+                {
+                    name: "tags",
+                    type: "string[]",
+                    description: "记忆标签（创建或更新时需要）",
+                },
+                {
+                    name: "content",
+                    type: "string",
+                    description: "记忆内容（创建或更新时需要）",
+                },
+                {
+                    name: "action",
+                    type: "string",
+                    enum: ["create", "update", "delete"],
+                    description: "操作类型：create（创建）、update（更新）、delete（删除）",
+                },
+                {
+                    name: "id",
+                    type: "string",
+                    description: "记忆ID（更新或删除时需要，创建时会自动生成）",
+                    required: false,
+                },
+                {
+                    name: "referencePath",
+                    type: "string",
+                    description: "引用文档的 URL",
+                    required: false,
+                },
+            ],
+            handler: async (args) => {
+                const { content, action, id, tags, path, referencePath } = args;
+
+                if ((action === "delete" || action === "update") && !id) {
+                    throw new Error("删除或更新记忆时必须提供记忆ID");
+                }
+
+                if ((action === "create" || action === "update") && !content) {
+                    throw new Error("创建或更新记忆时必须提供内容");
+                }
+
+                try {
+                    if (action === "delete") {
+                        await store.delete(Number(id));
+                        return `已删除记忆 ${id}`;
+                    }
+
+                    const memoryData: MemoryRecord = {
+                        text: content as string,
+                        content: ensureJsonSerializable(content),
+                        createdAt: new Date().toISOString(),
+                        updatedAt: new Date().toISOString(),
+                        namespace: getNamespace(),
+                        tags: tags as string[],
+                        path: path as string,
+                        type: "document",
+                        referencePath: referencePath as string,
+                    };
+
+                    if (action === "create") {
+                        const key = await store.insert(memoryData);
+                        return `已创建记忆 ${key}`;
+                    } else {
+                        await store.update(Number(id), memoryData);
+                        return `已更新记忆 ${id}`;
+                    }
+                } catch (error) {
+                    throw new Error(`记忆操作失败: ${error}`);
+                }
+            },
+        }),
+        searchMemory: createToolUI({
+            name: "search_memory",
+            description: `搜索长期记忆中的相关信息，帮助维护对话上下文`,
+            parameters: [
+                {
+                    name: "query",
+                    type: "string",
+                    description: "请使用中文关键词进行搜索",
+                },
+                {
+                    name: "tags",
+                    type: "string[]",
+                    description: "记忆标签",
+                    required: false,
+                },
+                {
+                    name: "path",
+                    type: "string",
+                    description: "记忆路径，memory://user_id/path/to/memory_name",
+                    required: false,
+                },
+                {
+                    name: "limit",
+                    type: "number",
+                    description: "返回结果的最大数量（默认10）",
+                    required: false,
+                },
+            ],
+            handler: async (args) => {
+                const { query, limit = 10, tags, path } = args;
+
+                if (!query || (typeof query === "string" && query.trim().length === 0)) {
+                    throw new Error("搜索查询不能为空");
+                }
+
+                try {
+                    const results = await store.query(query.toString(), {
+                        limit: limit as number,
+                    });
+
+                    return {
+                        query: query.toString(),
+                        results: results,
+                        total: results.length,
+                        limit: Number(limit),
+                    };
+                } catch (error) {
+                    throw new Error(`搜索记忆失败: ${error}`);
+                }
+            },
+        }),
+    };
+};
+
+export { getNamespace, ensureJsonSerializable };

package/test/main.tsx

@@ -1,5 +1,5 @@
-import React from "react";
 import ReactDOM from "react-dom/client";
 import App from "./App";
-
+import "@unocss/reset/tailwind-compat.css";
+import "virtual:uno.css";
 ReactDOM.createRoot(document.getElementById("root")!).render(<App />);

package/vite.config.ts

@@ -2,11 +2,12 @@ import react from "@vitejs/plugin-react";
 import { defineConfig } from "vite";
 import basicSsl from "@vitejs/plugin-basic-ssl";
 import path from "node:path";
+import UnoCSS from "unocss/vite";
 // https://vitejs.dev/config/
 export default defineConfig(({ mode }) => {
     const isHttps = mode === "https";
     return {
-        plugins: [react(), isHttps ? basicSsl() : undefined],
+        plugins: [UnoCSS(), react(), isHttps ? basicSsl() : undefined],
         resolve: {
             alias: {
                 "@langgraph-js/sdk": new URL("../langgraph-client/src", import.meta.url).pathname,
@@ -16,6 +17,11 @@ export default defineConfig(({ mode }) => {
             exclude: ["@langgraph-js/ui", "@langgraph-js/sdk"],
         },
         server: {
+            headers: {
+                "Cross-Origin-Opener-Policy": "same-origin",
+                "Cross-Origin-Embedder-Policy": "require-corp",
+                "cross-origin-resource-policy": "cross-origin",
+            },
             port: 1111,
         },
     };