memories-lite 0.9.0

package/dist/embeddings/openai.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIEmbedder = void 0;
+const openai_1 = __importDefault(require("openai"));
+class OpenAIEmbedder {
+    constructor(config) {
+        this.openai = new openai_1.default({ apiKey: config.apiKey });
+        this.model = config.model || "text-embedding-3-small";
+        this.dimension = config.dimension || 1536;
+    }
+    async embed(text) {
+        const response = await this.openai.embeddings.create({
+            model: this.model,
+            input: text,
+            dimensions: this.dimension,
+        });
+        return response.data[0].embedding;
+    }
+    async embedBatch(texts) {
+        const response = await this.openai.embeddings.create({
+            model: this.model,
+            input: texts,
+            dimensions: this.dimension,
+        });
+        return response.data.map((item) => item.embedding);
+    }
+}
+exports.OpenAIEmbedder = OpenAIEmbedder;

package/dist/graphs/configs.d.ts

@@ -0,0 +1,14 @@
+import { LLMConfig } from "../types";
+export interface Neo4jConfig {
+    url: string | null;
+    username: string | null;
+    password: string | null;
+}
+export interface GraphStoreConfig {
+    provider: string;
+    config: Neo4jConfig;
+    llm?: LLMConfig;
+    customPrompt?: string;
+}
+export declare function validateNeo4jConfig(config: Neo4jConfig): void;
+export declare function validateGraphStoreConfig(config: GraphStoreConfig): void;

package/dist/graphs/configs.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNeo4jConfig = validateNeo4jConfig;
+exports.validateGraphStoreConfig = validateGraphStoreConfig;
+function validateNeo4jConfig(config) {
+    const { url, username, password } = config;
+    if (!url || !username || !password) {
+        throw new Error("Please provide 'url', 'username' and 'password'.");
+    }
+}
+function validateGraphStoreConfig(config) {
+    const { provider } = config;
+    if (provider === "neo4j") {
+        validateNeo4jConfig(config.config);
+    }
+    else {
+        throw new Error(`Unsupported graph store provider: ${provider}`);
+    }
+}

package/dist/graphs/tools.d.ts

@@ -0,0 +1,271 @@
+import { z } from "zod";
+export interface GraphToolParameters {
+    source: string;
+    destination: string;
+    relationship: string;
+    source_type?: string;
+    destination_type?: string;
+}
+export interface GraphEntitiesParameters {
+    entities: Array<{
+        entity: string;
+        entity_type: string;
+    }>;
+}
+export interface GraphRelationsParameters {
+    entities: Array<{
+        source: string;
+        relationship: string;
+        destination: string;
+    }>;
+}
+export declare const GraphSimpleRelationshipArgsSchema: z.ZodObject<{
+    source: z.ZodString;
+    relationship: z.ZodString;
+    destination: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    relationship: string;
+    destination: string;
+}, {
+    source: string;
+    relationship: string;
+    destination: string;
+}>;
+export declare const GraphAddRelationshipArgsSchema: z.ZodObject<{
+    source: z.ZodString;
+    relationship: z.ZodString;
+    destination: z.ZodString;
+} & {
+    source_type: z.ZodString;
+    destination_type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    relationship: string;
+    destination: string;
+    source_type: string;
+    destination_type: string;
+}, {
+    source: string;
+    relationship: string;
+    destination: string;
+    source_type: string;
+    destination_type: string;
+}>;
+export declare const GraphExtractEntitiesArgsSchema: z.ZodObject<{
+    entities: z.ZodArray<z.ZodObject<{
+        entity: z.ZodString;
+        entity_type: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entity: string;
+        entity_type: string;
+    }, {
+        entity: string;
+        entity_type: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    entities: {
+        entity: string;
+        entity_type: string;
+    }[];
+}, {
+    entities: {
+        entity: string;
+        entity_type: string;
+    }[];
+}>;
+export declare const GraphRelationsArgsSchema: z.ZodObject<{
+    entities: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        relationship: z.ZodString;
+        destination: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        relationship: string;
+        destination: string;
+    }, {
+        source: string;
+        relationship: string;
+        destination: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    entities: {
+        source: string;
+        relationship: string;
+        destination: string;
+    }[];
+}, {
+    entities: {
+        source: string;
+        relationship: string;
+        destination: string;
+    }[];
+}>;
+export declare const UPDATE_MEMORY_TOOL_GRAPH: {
+    type: string;
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                source: {
+                    type: string;
+                    description: string;
+                };
+                destination: {
+                    type: string;
+                    description: string;
+                };
+                relationship: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+};
+export declare const ADD_MEMORY_TOOL_GRAPH: {
+    type: string;
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                source: {
+                    type: string;
+                    description: string;
+                };
+                destination: {
+                    type: string;
+                    description: string;
+                };
+                relationship: {
+                    type: string;
+                    description: string;
+                };
+                source_type: {
+                    type: string;
+                    description: string;
+                };
+                destination_type: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+};
+export declare const NOOP_TOOL: {
+    type: string;
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {};
+            required: never[];
+            additionalProperties: boolean;
+        };
+    };
+};
+export declare const RELATIONS_TOOL: {
+    type: string;
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                entities: {
+                    type: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            source: {
+                                type: string;
+                                description: string;
+                            };
+                            relationship: {
+                                type: string;
+                                description: string;
+                            };
+                            destination: {
+                                type: string;
+                                description: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+};
+export declare const EXTRACT_ENTITIES_TOOL: {
+    type: string;
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                entities: {
+                    type: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            entity: {
+                                type: string;
+                                description: string;
+                            };
+                            entity_type: {
+                                type: string;
+                                description: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+};
+export declare const DELETE_MEMORY_TOOL_GRAPH: {
+    type: string;
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                source: {
+                    type: string;
+                    description: string;
+                };
+                relationship: {
+                    type: string;
+                    description: string;
+                };
+                destination: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+};

package/dist/graphs/tools.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE_MEMORY_TOOL_GRAPH = exports.EXTRACT_ENTITIES_TOOL = exports.RELATIONS_TOOL = exports.NOOP_TOOL = exports.ADD_MEMORY_TOOL_GRAPH = exports.UPDATE_MEMORY_TOOL_GRAPH = exports.GraphRelationsArgsSchema = exports.GraphExtractEntitiesArgsSchema = exports.GraphAddRelationshipArgsSchema = exports.GraphSimpleRelationshipArgsSchema = void 0;
+const zod_1 = require("zod");
+// --- Zod Schemas for Tool Arguments ---
+// Schema for simple relationship arguments (Update, Delete)
+exports.GraphSimpleRelationshipArgsSchema = zod_1.z.object({
+    source: zod_1.z
+        .string()
+        .describe("The identifier of the source node in the relationship."),
+    relationship: zod_1.z
+        .string()
+        .describe("The relationship between the source and destination nodes."),
+    destination: zod_1.z
+        .string()
+        .describe("The identifier of the destination node in the relationship."),
+});
+// Schema for adding a relationship (includes types)
+exports.GraphAddRelationshipArgsSchema = exports.GraphSimpleRelationshipArgsSchema.extend({
+    source_type: zod_1.z
+        .string()
+        .describe("The type or category of the source node."),
+    destination_type: zod_1.z
+        .string()
+        .describe("The type or category of the destination node."),
+});
+// Schema for extracting entities
+exports.GraphExtractEntitiesArgsSchema = zod_1.z.object({
+    entities: zod_1.z
+        .array(zod_1.z.object({
+        entity: zod_1.z.string().describe("The name or identifier of the entity."),
+        entity_type: zod_1.z.string().describe("The type or category of the entity."),
+    }))
+        .describe("An array of entities with their types."),
+});
+// Schema for establishing relationships
+exports.GraphRelationsArgsSchema = zod_1.z.object({
+    entities: zod_1.z
+        .array(exports.GraphSimpleRelationshipArgsSchema)
+        .describe("An array of relationships (source, relationship, destination)."),
+});
+// --- Tool Definitions (using JSON schema, keep as is) ---
+// Note: The tool definitions themselves still use JSON schema format
+// as expected by the LLM APIs. The Zod schemas above are for internal
+// validation and potentially for use with Langchain's .withStructuredOutput
+// if we adapt it to handle tool calls via schema.
+exports.UPDATE_MEMORY_TOOL_GRAPH = {
+    type: "function",
+    function: {
+        name: "update_graph_memory",
+        description: "Update the relationship key of an existing graph memory based on new information.",
+        parameters: {
+            type: "object",
+            properties: {
+                source: {
+                    type: "string",
+                    description: "The identifier of the source node in the relationship to be updated.",
+                },
+                destination: {
+                    type: "string",
+                    description: "The identifier of the destination node in the relationship to be updated.",
+                },
+                relationship: {
+                    type: "string",
+                    description: "The new or updated relationship between the source and destination nodes.",
+                },
+            },
+            required: ["source", "destination", "relationship"],
+            additionalProperties: false,
+        },
+    },
+};
+exports.ADD_MEMORY_TOOL_GRAPH = {
+    type: "function",
+    function: {
+        name: "add_graph_memory",
+        description: "Add a new graph memory to the knowledge graph.",
+        parameters: {
+            type: "object",
+            properties: {
+                source: {
+                    type: "string",
+                    description: "The identifier of the source node in the new relationship.",
+                },
+                destination: {
+                    type: "string",
+                    description: "The identifier of the destination node in the new relationship.",
+                },
+                relationship: {
+                    type: "string",
+                    description: "The type of relationship between the source and destination nodes.",
+                },
+                source_type: {
+                    type: "string",
+                    description: "The type or category of the source node.",
+                },
+                destination_type: {
+                    type: "string",
+                    description: "The type or category of the destination node.",
+                },
+            },
+            required: [
+                "source",
+                "destination",
+                "relationship",
+                "source_type",
+                "destination_type",
+            ],
+            additionalProperties: false,
+        },
+    },
+};
+exports.NOOP_TOOL = {
+    type: "function",
+    function: {
+        name: "noop",
+        description: "No operation should be performed to the graph entities.",
+        parameters: {
+            type: "object",
+            properties: {},
+            required: [],
+            additionalProperties: false,
+        },
+    },
+};
+exports.RELATIONS_TOOL = {
+    type: "function",
+    function: {
+        name: "establish_relationships",
+        description: "Establish relationships among the entities based on the provided text.",
+        parameters: {
+            type: "object",
+            properties: {
+                entities: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            source: {
+                                type: "string",
+                                description: "The source entity of the relationship.",
+                            },
+                            relationship: {
+                                type: "string",
+                                description: "The relationship between the source and destination entities.",
+                            },
+                            destination: {
+                                type: "string",
+                                description: "The destination entity of the relationship.",
+                            },
+                        },
+                        required: ["source", "relationship", "destination"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["entities"],
+            additionalProperties: false,
+        },
+    },
+};
+exports.EXTRACT_ENTITIES_TOOL = {
+    type: "function",
+    function: {
+        name: "extract_entities",
+        description: "Extract entities and their types from the text.",
+        parameters: {
+            type: "object",
+            properties: {
+                entities: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            entity: {
+                                type: "string",
+                                description: "The name or identifier of the entity.",
+                            },
+                            entity_type: {
+                                type: "string",
+                                description: "The type or category of the entity.",
+                            },
+                        },
+                        required: ["entity", "entity_type"],
+                        additionalProperties: false,
+                    },
+                    description: "An array of entities with their types.",
+                },
+            },
+            required: ["entities"],
+            additionalProperties: false,
+        },
+    },
+};
+exports.DELETE_MEMORY_TOOL_GRAPH = {
+    type: "function",
+    function: {
+        name: "delete_graph_memory",
+        description: "Delete the relationship between two nodes.",
+        parameters: {
+            type: "object",
+            properties: {
+                source: {
+                    type: "string",
+                    description: "The identifier of the source node in the relationship.",
+                },
+                relationship: {
+                    type: "string",
+                    description: "The existing relationship between the source and destination nodes that needs to be deleted.",
+                },
+                destination: {
+                    type: "string",
+                    description: "The identifier of the destination node in the relationship.",
+                },
+            },
+            required: ["source", "relationship", "destination"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/graphs/utils.d.ts

@@ -0,0 +1,9 @@
+export declare const UPDATE_GRAPH_PROMPT = "\nYou are an AI expert specializing in graph memory management and optimization. Your task is to analyze existing graph memories alongside new information, and update the relationships in the memory list to ensure the most accurate, current, and coherent representation of knowledge.\n\nInput:\n1. Existing Graph Memories: A list of current graph memories, each containing source, target, and relationship information.\n2. New Graph Memory: Fresh information to be integrated into the existing graph structure.\n\nGuidelines:\n1. Identification: Use the source and target as primary identifiers when matching existing memories with new information.\n2. Conflict Resolution:\n   - If new information contradicts an existing memory:\n     a) For matching source and target but differing content, update the relationship of the existing memory.\n     b) If the new memory provides more recent or accurate information, update the existing memory accordingly.\n3. Comprehensive Review: Thoroughly examine each existing graph memory against the new information, updating relationships as necessary. Multiple updates may be required.\n4. Consistency: Maintain a uniform and clear style across all memories. Each entry should be concise yet comprehensive.\n5. Semantic Coherence: Ensure that updates maintain or improve the overall semantic structure of the graph.\n6. Temporal Awareness: If timestamps are available, consider the recency of information when making updates.\n7. Relationship Refinement: Look for opportunities to refine relationship descriptions for greater precision or clarity.\n8. Redundancy Elimination: Identify and merge any redundant or highly similar relationships that may result from the update.\n\nMemory Format:\nsource -- RELATIONSHIP -- destination\n\nTask Details:\n======= Existing Graph Memories:=======\n{existing_memories}\n\n======= New Graph Memory:=======\n{new_memories}\n\nOutput:\nProvide a list of update instructions, each specifying the source, target, and the new relationship to be set. Only include memories that require updates.\n";
+export declare const EXTRACT_RELATIONS_PROMPT = "\nYou are an advanced algorithm designed to extract structured information from text to construct knowledge graphs. Your goal is to capture comprehensive and accurate information. Follow these key principles:\n\n1. Extract only explicitly stated information from the text.\n2. Establish relationships among the entities provided.\n3. Use \"USER_ID\" as the source entity for any self-references (e.g., \"I,\" \"me,\" \"my,\" etc.) in user messages.\nCUSTOM_PROMPT\n\nRelationships:\n    - Use consistent, general, and timeless relationship types.\n    - Example: Prefer \"professor\" over \"became_professor.\"\n    - Relationships should only be established among the entities explicitly mentioned in the user message.\n\nEntity Consistency:\n    - Ensure that relationships are coherent and logically align with the context of the message.\n    - Maintain consistent naming for entities across the extracted data.\n\nStrive to construct a coherent and easily understandable knowledge graph by eshtablishing all the relationships among the entities and adherence to the user's context.\n\nAdhere strictly to these guidelines to ensure high-quality knowledge graph extraction.\n";
+export declare const DELETE_RELATIONS_SYSTEM_PROMPT = "\nYou are a graph memory manager specializing in identifying, managing, and optimizing relationships within graph-based memories. Your primary task is to analyze a list of existing relationships and determine which ones should be deleted based on the new information provided.\nInput:\n1. Existing Graph Memories: A list of current graph memories, each containing source, relationship, and destination information.\n2. New Text: The new information to be integrated into the existing graph structure.\n3. Use \"USER_ID\" as node for any self-references (e.g., \"I,\" \"me,\" \"my,\" etc.) in user messages.\n\nGuidelines:\n1. Identification: Use the new information to evaluate existing relationships in the memory graph.\n2. Deletion Criteria: Delete a relationship only if it meets at least one of these conditions:\n   - Outdated or Inaccurate: The new information is more recent or accurate.\n   - Contradictory: The new information conflicts with or negates the existing information.\n3. DO NOT DELETE if their is a possibility of same type of relationship but different destination nodes.\n4. Comprehensive Analysis:\n   - Thoroughly examine each existing relationship against the new information and delete as necessary.\n   - Multiple deletions may be required based on the new information.\n5. Semantic Integrity:\n   - Ensure that deletions maintain or improve the overall semantic structure of the graph.\n   - Avoid deleting relationships that are NOT contradictory/outdated to the new information.\n6. Temporal Awareness: Prioritize recency when timestamps are available.\n7. Necessity Principle: Only DELETE relationships that must be deleted and are contradictory/outdated to the new information to maintain an accurate and coherent memory graph.\n\nNote: DO NOT DELETE if their is a possibility of same type of relationship but different destination nodes. \n\nFor example: \nExisting Memory: alice -- loves_to_eat -- pizza\nNew Information: Alice also loves to eat burger.\n\nDo not delete in the above example because there is a possibility that Alice loves to eat both pizza and burger.\n\nMemory Format:\nsource -- relationship -- destination\n\nProvide a list of deletion instructions, each specifying the relationship to be deleted.\n";
+export declare function getDeleteMessages(existingMemoriesString: string, data: string, userId: string): [string, string];
+export declare function formatEntities(entities: Array<{
+    source: string;
+    relationship: string;
+    destination: string;
+}>): string;

package/dist/graphs/utils.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE_RELATIONS_SYSTEM_PROMPT = exports.EXTRACT_RELATIONS_PROMPT = exports.UPDATE_GRAPH_PROMPT = void 0;
+exports.getDeleteMessages = getDeleteMessages;
+exports.formatEntities = formatEntities;
+exports.UPDATE_GRAPH_PROMPT = `
+You are an AI expert specializing in graph memory management and optimization. Your task is to analyze existing graph memories alongside new information, and update the relationships in the memory list to ensure the most accurate, current, and coherent representation of knowledge.
+
+Input:
+1. Existing Graph Memories: A list of current graph memories, each containing source, target, and relationship information.
+2. New Graph Memory: Fresh information to be integrated into the existing graph structure.
+
+Guidelines:
+1. Identification: Use the source and target as primary identifiers when matching existing memories with new information.
+2. Conflict Resolution:
+   - If new information contradicts an existing memory:
+     a) For matching source and target but differing content, update the relationship of the existing memory.
+     b) If the new memory provides more recent or accurate information, update the existing memory accordingly.
+3. Comprehensive Review: Thoroughly examine each existing graph memory against the new information, updating relationships as necessary. Multiple updates may be required.
+4. Consistency: Maintain a uniform and clear style across all memories. Each entry should be concise yet comprehensive.
+5. Semantic Coherence: Ensure that updates maintain or improve the overall semantic structure of the graph.
+6. Temporal Awareness: If timestamps are available, consider the recency of information when making updates.
+7. Relationship Refinement: Look for opportunities to refine relationship descriptions for greater precision or clarity.
+8. Redundancy Elimination: Identify and merge any redundant or highly similar relationships that may result from the update.
+
+Memory Format:
+source -- RELATIONSHIP -- destination
+
+Task Details:
+======= Existing Graph Memories:=======
+{existing_memories}
+
+======= New Graph Memory:=======
+{new_memories}
+
+Output:
+Provide a list of update instructions, each specifying the source, target, and the new relationship to be set. Only include memories that require updates.
+`;
+exports.EXTRACT_RELATIONS_PROMPT = `
+You are an advanced algorithm designed to extract structured information from text to construct knowledge graphs. Your goal is to capture comprehensive and accurate information. Follow these key principles:
+
+1. Extract only explicitly stated information from the text.
+2. Establish relationships among the entities provided.
+3. Use "USER_ID" as the source entity for any self-references (e.g., "I," "me," "my," etc.) in user messages.
+CUSTOM_PROMPT
+
+Relationships:
+    - Use consistent, general, and timeless relationship types.
+    - Example: Prefer "professor" over "became_professor."
+    - Relationships should only be established among the entities explicitly mentioned in the user message.
+
+Entity Consistency:
+    - Ensure that relationships are coherent and logically align with the context of the message.
+    - Maintain consistent naming for entities across the extracted data.
+
+Strive to construct a coherent and easily understandable knowledge graph by eshtablishing all the relationships among the entities and adherence to the user's context.
+
+Adhere strictly to these guidelines to ensure high-quality knowledge graph extraction.
+`;
+exports.DELETE_RELATIONS_SYSTEM_PROMPT = `
+You are a graph memory manager specializing in identifying, managing, and optimizing relationships within graph-based memories. Your primary task is to analyze a list of existing relationships and determine which ones should be deleted based on the new information provided.
+Input:
+1. Existing Graph Memories: A list of current graph memories, each containing source, relationship, and destination information.
+2. New Text: The new information to be integrated into the existing graph structure.
+3. Use "USER_ID" as node for any self-references (e.g., "I," "me," "my," etc.) in user messages.
+
+Guidelines:
+1. Identification: Use the new information to evaluate existing relationships in the memory graph.
+2. Deletion Criteria: Delete a relationship only if it meets at least one of these conditions:
+   - Outdated or Inaccurate: The new information is more recent or accurate.
+   - Contradictory: The new information conflicts with or negates the existing information.
+3. DO NOT DELETE if their is a possibility of same type of relationship but different destination nodes.
+4. Comprehensive Analysis:
+   - Thoroughly examine each existing relationship against the new information and delete as necessary.
+   - Multiple deletions may be required based on the new information.
+5. Semantic Integrity:
+   - Ensure that deletions maintain or improve the overall semantic structure of the graph.
+   - Avoid deleting relationships that are NOT contradictory/outdated to the new information.
+6. Temporal Awareness: Prioritize recency when timestamps are available.
+7. Necessity Principle: Only DELETE relationships that must be deleted and are contradictory/outdated to the new information to maintain an accurate and coherent memory graph.
+
+Note: DO NOT DELETE if their is a possibility of same type of relationship but different destination nodes. 
+
+For example: 
+Existing Memory: alice -- loves_to_eat -- pizza
+New Information: Alice also loves to eat burger.
+
+Do not delete in the above example because there is a possibility that Alice loves to eat both pizza and burger.
+
+Memory Format:
+source -- relationship -- destination
+
+Provide a list of deletion instructions, each specifying the relationship to be deleted.
+`;
+function getDeleteMessages(existingMemoriesString, data, userId) {
+    return [
+        exports.DELETE_RELATIONS_SYSTEM_PROMPT.replace("USER_ID", userId),
+        `Here are the existing memories: ${existingMemoriesString} \n\n New Information: ${data}`,
+    ];
+}
+function formatEntities(entities) {
+    return entities
+        .map((e) => `${e.source} -- ${e.relationship} -- ${e.destination}`)
+        .join("\n");
+}