mmp-mcp/build/src/services/memoryService.js

Model Memory Protocol MCP - 一种用于AI模型记忆管理的开放协议实现

import { v4 as uuidv4 } from "uuid";
/**
 * 记忆管理服务
 */
class MemoryService {
    defaultMemoryId = "";
    /**
     * 设置默认记忆ID
     */
    setDefaultMemoryId(memoryId) {
        this.defaultMemoryId = memoryId;
    }
    /**
     * 获取默认记忆ID
     */
    getDefaultMemoryId() {
        return this.defaultMemoryId;
    }
    /**
     * 发送RPC请求
     * @param method RPC方法名
     * @param params 参数对象
     * @returns Promise<any>
     */
    async sendRpcRequest(method, params) {
        const rpcEndpoint = process.env.MMP_RPC_ENDPOINT;
        if (!rpcEndpoint) {
            throw new Error("RPC endpoint not configured");
        }
        try {
            const request = {
                jsonrpc: "2.0",
                id: uuidv4(),
                method,
                params,
            };
            const response = await fetch(rpcEndpoint, {
                method: "POST",
                headers: {
                    "Content-Type": "application/json",
                },
                body: JSON.stringify(request),
            });
            if (!response.ok) {
                throw new Error(`HTTP error: ${response.status}`);
            }
            const result = await response.json();
            if (result.error) {
                throw new Error(`RPC error: ${result.error.message || JSON.stringify(result.error)}`);
            }
            return result.result;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * 创建新的记忆集合
     * @param params 创建记忆集合的参数
     * @returns Promise<CreateMemoryResponse>
     */
    async createMemory(params) {
        return this.sendRpcRequest("memManager.Create", params);
    }
    /**
     * 获取待初始化节点
     * @param params 获取待初始化节点的参数
     * @returns Promise<GetInitNodesResponse>
     */
    async getInitNodes(params) {
        // 如果没有指定memoryId，使用默认值
        const memoryId = this.defaultMemoryId || params.memoryId;
        if (!memoryId) {
            throw new Error("No memoryId provided and no default memoryId set");
        }
        return this.sendRpcRequest("memory.GetInitNodes", {
            ...params,
            memoryId,
        });
    }
    /**
     * 添加记忆节点
     * @param params 添加记忆节点的参数
     * @returns Promise<AddNodeResponse>
     */
    async addNode(params) {
        // 如果没有指定memoryId，使用默认值
        const memoryId = this.defaultMemoryId || params.memoryId;
        if (!memoryId) {
            throw new Error("No memoryId provided and no default memoryId set");
        }
        return this.sendRpcRequest("memory.Add", {
            ...params,
            memoryId,
        });
    }
    /**
     * 获取记忆节点
     * @param params 获取记忆节点的参数
     * @returns Promise<MemoryNode>
     */
    async getNode(params) {
        // 如果没有指定memoryId，使用默认值
        const memoryId = this.defaultMemoryId || params.memoryId;
        if (!memoryId) {
            throw new Error("No memoryId provided and no default memoryId set");
        }
        return this.sendRpcRequest("memory.Get", {
            ...params,
            memoryId,
        });
    }
    /**
     * 获取记忆节点列表
     * @param params 获取记忆节点列表的参数
     * @returns Promise<ListNodesResponse>
     */
    async listNodes(params) {
        // 如果没有指定memoryId，使用默认值
        const memoryId = this.defaultMemoryId || params.memoryId;
        if (!memoryId) {
            throw new Error("No memoryId provided and no default memoryId set");
        }
        return this.sendRpcRequest("memory.List", {
            ...params,
            memoryId,
        });
    }
    /**
     * 更新记忆节点
     * @param params 更新记忆节点的参数
     * @returns Promise<UpdateNodeResponse>
     */
    async updateNode(params) {
        // 如果没有指定memoryId，使用默认值
        const memoryId = this.defaultMemoryId || params.memoryId;
        if (!memoryId) {
            throw new Error("No memoryId provided and no default memoryId set");
        }
        return this.sendRpcRequest("memory.Update", {
            ...params,
            memoryId,
        });
    }
    /**
     * 删除记忆节点
     * @param params 删除记忆节点的参数
     * @returns Promise<DeleteNodeResponse>
     */
    async deleteNode(params) {
        // 如果没有指定memoryId，使用默认值
        const memoryId = this.defaultMemoryId || params.memoryId;
        if (!memoryId) {
            throw new Error("No memoryId provided and no default memoryId set");
        }
        return this.sendRpcRequest("memory.Delete", {
            ...params,
            memoryId,
        });
    }
    /**
     * 为指定的记忆ID应用一组记忆节点模板
     * @param params 应用模板的参数
     * @returns Promise<ApplyTemplateResponse>
     */
    async applyTemplate(params) {
        // 如果没有指定memoryId，使用默认值
        const memoryId = this.defaultMemoryId || params.memoryId;
        if (!memoryId) {
            throw new Error("No memoryId provided and no default memoryId set");
        }
        return this.sendRpcRequest("memManager.ApplyTemplate", {
            ...params,
            memoryId,
        });
    }
    /**
     * 批量获取记忆节点
     * @param params 批量获取记忆节点的参数
     * @returns Promise<MemoryNode[]>
     */
    async batchGetNodes(params) {
        // 处理每个请求中可能需要的默认memoryId
        const requests = params.requests.map((req) => ({
            ...req,
            memoryId: this.defaultMemoryId || req.memoryId,
        }));
        // 检查每个请求是否都有memoryId
        for (const req of requests) {
            if (!req.memoryId) {
                throw new Error("One or more requests have no memoryId and no default memoryId is set");
            }
        }
        return this.sendRpcRequest("memory.Batch", {
            requests,
        });
    }
}
// 创建单例实例
const memoryService = new MemoryService();
export { memoryService };