memories-lite 0.9.0

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./memory";
+export * from "./memory/memory.types";
+export * from "./types";
+export * from "./prompts";
+export * from "./embeddings/base";
+export * from "./embeddings/openai";
+export * from "./embeddings/google";
+export * from "./llms/base";
+export * from "./llms/openai";
+export * from "./llms/openai_structured";
+export * from "./vectorstores/base";
+export * from "./vectorstores/llm";
+export * from "./vectorstores/lite";
+export * from "./utils/factory";

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./memory"), exports);
+__exportStar(require("./memory/memory.types"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./prompts"), exports);
+__exportStar(require("./embeddings/base"), exports);
+__exportStar(require("./embeddings/openai"), exports);
+__exportStar(require("./embeddings/google"), exports);
+__exportStar(require("./llms/base"), exports);
+__exportStar(require("./llms/openai"), exports);
+__exportStar(require("./llms/openai_structured"), exports);
+__exportStar(require("./vectorstores/base"), exports);
+__exportStar(require("./vectorstores/llm"), exports);
+__exportStar(require("./vectorstores/lite"), exports);
+__exportStar(require("./utils/factory"), exports);

package/dist/llms/base.d.ts

@@ -0,0 +1,16 @@
+import { Message } from "../types";
+export interface LLMResponse {
+    content: string;
+    role: string;
+    toolCalls?: Array<{
+        name: string;
+        arguments: string;
+    }>;
+}
+export interface LLM {
+    generateResponse(messages: Array<{
+        role: string;
+        content: string;
+    }>, response_format?: any, tools?: any[], structuredOutput?: boolean, model?: string): Promise<any>;
+    generateChat(messages: Message[]): Promise<LLMResponse>;
+}

package/dist/llms/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/llms/google.d.ts

@@ -0,0 +1,11 @@
+import { LLM, LLMResponse } from "./base";
+import { LLMConfig, Message } from "../types";
+export declare class GoogleLLM implements LLM {
+    private google;
+    private model;
+    constructor(config: LLMConfig);
+    generateResponse(messages: Message[], responseFormat?: {
+        type: string;
+    }, tools?: any[]): Promise<string | LLMResponse>;
+    generateChat(messages: Message[]): Promise<LLMResponse>;
+}

package/dist/llms/google.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleLLM = void 0;
+const genai_1 = require("@google/genai");
+class GoogleLLM {
+    constructor(config) {
+        this.google = new genai_1.GoogleGenAI({ apiKey: config.apiKey });
+        this.model = config.model || "gemini-2.0-flash";
+    }
+    async generateResponse(messages, responseFormat, tools) {
+        const completion = await this.google.models.generateContent({
+            contents: messages.map((msg) => ({
+                parts: [
+                    {
+                        text: typeof msg.content === "string"
+                            ? msg.content
+                            : JSON.stringify(msg.content),
+                    },
+                ],
+                role: msg.role === "system" ? "model" : "user",
+            })),
+            model: this.model,
+            // config: {
+            //   responseSchema: {}, // Add response schema if needed
+            // },
+        });
+        const text = completion.text
+            ?.replace(/^```json\n/, "")
+            .replace(/\n```$/, "");
+        return text || "";
+    }
+    async generateChat(messages) {
+        const completion = await this.google.models.generateContent({
+            contents: messages,
+            model: this.model,
+        });
+        const response = completion.candidates[0].content;
+        return {
+            content: response.parts[0].text || "",
+            role: response.role,
+        };
+    }
+}
+exports.GoogleLLM = GoogleLLM;

package/dist/llms/openai.d.ts

@@ -0,0 +1,9 @@
+import { LLM, LLMResponse } from "./base";
+import { LLMConfig, Message } from "../types";
+export declare class OpenAILLM implements LLM {
+    private openai;
+    private model;
+    constructor(config: LLMConfig);
+    generateResponse(messages: Message[], responseFormat?: any, tools?: any[], structuredOutput?: boolean, model?: string): Promise<string | LLMResponse>;
+    generateChat(messages: Message[]): Promise<LLMResponse>;
+}

package/dist/llms/openai.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAILLM = void 0;
+const openai_1 = __importDefault(require("openai"));
+class OpenAILLM {
+    constructor(config) {
+        this.openai = new openai_1.default({ apiKey: config.apiKey });
+        this.model = config.model || "gpt-4.1-mini";
+    }
+    async generateResponse(messages, responseFormat, tools, structuredOutput = false, model) {
+        const msg = messages.map((msg) => {
+            const role = msg.role;
+            return {
+                role,
+                content: typeof msg.content === "string"
+                    ? msg.content
+                    : JSON.stringify(msg.content),
+            };
+        });
+        // DEPRECATED: use structured ouput message with `await openai.beta.chat.completions.parse(...)`
+        // https://platform.openai.com/docs/guides/structured-outputs?api-mode=chat&lang=javascript
+        // ⚠️ SyntaxError: Unexpected non-whitespace character after JSON at position 13
+        const fnCall = structuredOutput ?
+            this.openai.beta.chat.completions.parse.bind(this.openai.beta.chat.completions) : this.openai.chat.completions.create.bind(this.openai.chat.completions);
+        const completion = await fnCall({
+            messages: msg,
+            model: model || this.model,
+            top_p: .8, temperature: .2,
+            ...(structuredOutput && { logit_bias: { "1734": -100 } }),
+            response_format: responseFormat,
+            ...(tools && { tools, tool_choice: "auto" }),
+        });
+        const response = completion.choices[0].message;
+        if (response.tool_calls) {
+            return {
+                content: response.content || "",
+                role: response.role,
+                toolCalls: response.tool_calls.map((call) => ({
+                    name: call.function.name,
+                    arguments: call.function.arguments,
+                })),
+            };
+        }
+        const result = structuredOutput ? response.parsed : response.content;
+        //const result = response.content;
+        // console.log("--- DBG query:", msg);
+        // console.log("\n\n--- DBG result:", result);
+        return result || "";
+    }
+    async generateChat(messages) {
+        const completion = await this.openai.chat.completions.create({
+            messages: messages.map((msg) => {
+                const role = msg.role;
+                return {
+                    role,
+                    content: typeof msg.content === "string"
+                        ? msg.content
+                        : JSON.stringify(msg.content),
+                };
+            }),
+            model: this.model,
+        });
+        const response = completion.choices[0].message;
+        return {
+            content: response.content || "",
+            role: response.role,
+        };
+    }
+}
+exports.OpenAILLM = OpenAILLM;

package/dist/llms/openai_structured.d.ts

@@ -0,0 +1,11 @@
+import { LLM, LLMResponse } from "./base";
+import { LLMConfig, Message } from "../types";
+export declare class OpenAIStructuredLLM implements LLM {
+    private openai;
+    private model;
+    constructor(config: LLMConfig);
+    generateResponse(messages: Message[], responseFormat?: {
+        type: string;
+    } | null, tools?: any[]): Promise<string | LLMResponse>;
+    generateChat(messages: Message[]): Promise<LLMResponse>;
+}

package/dist/llms/openai_structured.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIStructuredLLM = void 0;
+const openai_1 = __importDefault(require("openai"));
+class OpenAIStructuredLLM {
+    constructor(config) {
+        this.openai = new openai_1.default({ apiKey: config.apiKey });
+        this.model = config.model || "gpt-4-turbo-preview";
+    }
+    async generateResponse(messages, responseFormat, tools) {
+        const completion = await this.openai.chat.completions.create({
+            messages: messages.map((msg) => ({
+                role: msg.role,
+                content: typeof msg.content === "string"
+                    ? msg.content
+                    : JSON.stringify(msg.content),
+            })),
+            model: this.model,
+            ...(tools
+                ? {
+                    tools: tools.map((tool) => ({
+                        type: "function",
+                        function: {
+                            name: tool.function.name,
+                            description: tool.function.description,
+                            parameters: tool.function.parameters,
+                        },
+                    })),
+                    tool_choice: "auto",
+                }
+                : responseFormat
+                    ? {
+                        response_format: {
+                            type: responseFormat.type,
+                        },
+                    }
+                    : {}),
+        });
+        const response = completion.choices[0].message;
+        if (response.tool_calls) {
+            return {
+                content: response.content || "",
+                role: response.role,
+                toolCalls: response.tool_calls.map((call) => ({
+                    name: call.function.name,
+                    arguments: call.function.arguments,
+                })),
+            };
+        }
+        return response.content || "";
+    }
+    async generateChat(messages) {
+        const completion = await this.openai.chat.completions.create({
+            messages: messages.map((msg) => ({
+                role: msg.role,
+                content: typeof msg.content === "string"
+                    ? msg.content
+                    : JSON.stringify(msg.content),
+            })),
+            model: this.model,
+        });
+        const response = completion.choices[0].message;
+        return {
+            content: response.content || "",
+            role: response.role,
+        };
+    }
+}
+exports.OpenAIStructuredLLM = OpenAIStructuredLLM;

package/dist/memory/index.d.ts

@@ -0,0 +1,42 @@
+import { MemoryConfig, MemoryItem, Message, SearchResult } from "../types";
+import { VectorStore } from "../vectorstores/base";
+import { AddMemoryOptions, SearchMemoryOptions, DeleteAllMemoryOptions, GetAllMemoryOptions } from "./memory.types";
+export declare class MemoriesLite {
+    private config;
+    private customPrompt;
+    private embedder;
+    private vectorStoreConfig;
+    private llm;
+    private db;
+    private collectionName;
+    private apiVersion;
+    private graphMemory?;
+    private enableGraph;
+    telemetryId: string;
+    constructor(config?: Partial<MemoryConfig>);
+    private _initializeTelemetry;
+    private _getTelemetryId;
+    private _captureEvent;
+    private $t;
+    private addToVectorStore;
+    static fromConfig(configDict: Record<string, any>): MemoriesLite;
+    getVectorStore(userId: string): Promise<VectorStore>;
+    capture(messages: string | Message[], userId: string, config: AddMemoryOptions): Promise<SearchResult>;
+    get(memoryId: string, userId: string): Promise<MemoryItem | null>;
+    retrieve(query: string, userId: string, config: SearchMemoryOptions): Promise<SearchResult>;
+    update(memoryId: string, data: string, userId: string): Promise<{
+        message: string;
+    }>;
+    delete(memoryId: string, userId: string): Promise<{
+        message: string;
+    }>;
+    deleteAll(userId: string, config: DeleteAllMemoryOptions): Promise<{
+        message: string;
+    }>;
+    history(memoryId: string): Promise<any[]>;
+    reset(userId: string): Promise<void>;
+    getAll(userId: string, config: GetAllMemoryOptions): Promise<SearchResult>;
+    private createMemory;
+    private updateMemory;
+    private deleteMemory;
+}