@ainetwork/adk-provider-memory-mongodb 0.1.1 → 0.1.2

package/implements/base.memory.ts

@@ -0,0 +1,52 @@
+import { IMemory } from "node_modules/@ainetwork/adk/dist/esm/modules/memory/base.memory";
+import mongoose, { Mongoose } from "mongoose";
+import { loggers } from "@ainetwork/adk/utils/logger";
+
+export class MongoDBMemory implements IMemory {
+  private _isConnected: boolean = false;
+  private _uri: string;
+  private _mongoose: Mongoose;
+
+  constructor(uri: string) {
+    this._uri = uri;
+    this._mongoose = new Mongoose();
+  }
+
+  public getInstance(): Mongoose {
+    return this._mongoose;
+  }
+
+  public async connect(): Promise<void> {
+		if (this._isConnected) {
+			return;
+		}
+
+		try {
+      await this._mongoose.connect(this._uri);
+			this._isConnected = true;
+			loggers.agent.info("MongoDB connected successfully");
+		} catch (error) {
+			loggers.agent.error("Failed to connect to MongoDB:", error);
+			throw error;
+		}
+  }
+
+  public async disconnect(): Promise<void> {
+		if (!this.isConnected) {
+			return;
+		}
+
+		try {
+			await this._mongoose?.disconnect();
+			this._isConnected = false;
+			loggers.agent.info("MongoDB disconnected successfully");
+		} catch (error) {
+			loggers.agent.error("Failed to disconnect from MongoDB:", error);
+			throw error;
+		}
+  }
+
+  public isConnected(): boolean {
+    return this._isConnected;
+  }
+}

package/implements/intent.memory.ts

@@ -0,0 +1,56 @@
+import { randomUUID } from "node:crypto";
+import type { Intent } from "@ainetwork/adk/types/memory";
+import { IIntentMemory } from "@ainetwork/adk/modules";
+import { MongoDBMemory } from "./base.memory";
+import { IntentModel } from "../models/intent.model";
+
+export class MongoDBIntent extends MongoDBMemory implements IIntentMemory {
+  public async getIntent(intentId: string): Promise<Intent | undefined> {
+    const intent = await IntentModel.findById(intentId);
+    if (intent) {
+      return {
+        name: intent.name,
+        description: intent.description,
+        prompt: intent.prompt,
+        llm: intent.llm,
+      } as Intent;
+    }
+    return undefined;
+  };
+
+	public async saveIntent(intent: Intent): Promise<void> {
+    const newId = randomUUID();
+    await IntentModel.create({
+      _id: newId,
+      name: intent.name,
+      description: intent.description,
+      prompt: intent.prompt,
+      llm: intent.llm,
+    });
+  };
+
+	public async updateIntent(intentId: string, intent: Intent): Promise<void> {
+    await IntentModel.updateOne({
+      _id: intentId,
+    },{
+      name: intent.name,
+      description: intent.description,
+      prompt: intent.prompt,
+      llm: intent.llm,
+    });
+  };
+
+	public async deleteIntent(intentId: string): Promise<void> {
+    await IntentModel.deleteOne({ _id: intentId });
+  };
+
+	public async listIntents(): Promise<Intent[]> {
+    const intents = await IntentModel.find();
+    return intents.map(intent => ({
+      name: intent.name,
+      description: intent.description,
+      prompt: intent.prompt,
+      llm: intent.llm,
+    } as Intent));
+  };
+}

package/implements/session.memory.ts

@@ -0,0 +1,103 @@
+import { randomUUID } from "node:crypto";
+import type { ChatObject, SessionMetadata, SessionObject } from "@ainetwork/adk/types/memory";
+import { ISessionMemory } from "@ainetwork/adk/modules";
+import { MongoDBMemory } from "./base.memory";
+import {
+	ChatDocument,
+	ChatRole,
+  ChatObjectSchema,
+  SessionObjectSchema,
+  SessionDocument
+} from "../models/chats.model";
+import { loggers } from "@ainetwork/adk/utils/logger";
+import { Model } from "mongoose";
+
+export class MongoDBSession extends MongoDBMemory implements ISessionMemory {
+  private chatModel: Model<ChatDocument>;
+  private sessionModel: Model<SessionDocument>;
+
+  constructor(uri: string) {
+    super(uri);
+    const _mongoose = super.getInstance();
+    this.chatModel = _mongoose.model<ChatDocument>("Chat", ChatObjectSchema);
+    this.sessionModel = _mongoose.model<SessionDocument>("Session", SessionObjectSchema);
+  }
+
+  public async getSession(sessionId: string, userId?: string): Promise<SessionObject | undefined> {
+		const chats = await this.chatModel.find({ sessionId }).sort({
+			timestamp: 1,
+		});
+
+		loggers.agent.debug(`Found ${chats.length} chats for session ${sessionId}`);
+
+		const sessionObject: SessionObject = { chats: {} };
+		chats.forEach((chat: ChatDocument) => {
+			const chatId = chat._id?.toString() || chat.id;
+			sessionObject.chats[chatId] = {
+				role: chat.role as ChatRole,
+				content: chat.content,
+				timestamp: chat.timestamp,
+				metadata: chat.metadata,
+			};
+		});
+
+		return sessionObject;
+  };
+
+	public async createSession(userId: string, sessionId: string): Promise<void> {
+    await this.sessionModel.create({
+      sessionId,
+      userId,
+      updated_at: Date.now(),
+      created_at: Date.now(),
+    });
+  };
+
+	public async addChatToSession(userId: string, sessionId: string, chat: ChatObject): Promise<void> {
+    const newId = randomUUID();
+    const session = await this.sessionModel.findOne({ sessionId, userId });
+    if (!session) {
+      await this.createSession(userId, sessionId);
+    } else {
+      await this.sessionModel.updateOne({ sessionId, userId }, {
+        updated_at: Date.now(),
+      });
+    }
+		await this.chatModel.create({
+			sessionId,
+      chatId: newId,
+      userId,
+			role: chat.role,
+			content: chat.content,
+			timestamp: chat.timestamp,
+			metadata: chat.metadata,
+		});
+  };
+
+	public async deleteSession(userId: string, sessionId: string): Promise<void> {
+		const chats = await this.chatModel.find({ userId, sessionId }).sort({
+			timestamp: 1,
+		});
+
+		chats?.forEach((chat: ChatDocument) => {
+      chat.deleteOne();
+		});
+    
+    const session = await this.sessionModel.findOne({ sessionId, userId });
+    session?.deleteOne();
+  };
+
+	public async listSessions(userId: string): Promise<SessionMetadata[]> {
+    const sessions = await this.sessionModel.find({ userId }).sort({
+      updated_at: -1,
+    });
+    const data: SessionMetadata[] = sessions.map((session: SessionDocument) => {
+      return {
+        sessionId: session.sessionId,
+        title: session.title,
+        updatedAt: session.updated_at
+      } as SessionMetadata;
+    })
+    return data;
+  };
+}

package/index.ts

@@ -1,107 +1,2 @@
-import { BaseMemory } from "@ainetwork/adk/modules";
-import type { ChatObject, SessionObject } from "@ainetwork/adk/types/memory";
-import { loggers } from "@ainetwork/adk/utils/logger";
-import mongoose from "mongoose";
-import {
-	type ChatDocument,
-	ChatModel,
-	ChatRole,
-} from "./models/chats.model";
-
-export class MongoDBMemory extends BaseMemory {
-	private isConnected = false;
-
-	constructor(uri: string) {
-		super();
-		this.connect(uri);
-	}
-
-	public async connect(uri: string): Promise<void> {
-		if (this.isConnected) {
-			return;
-		}
-
-		try {
-			await mongoose.connect(uri);
-			this.isConnected = true;
-			loggers.agent.info("MongoDB connected successfully");
-		} catch (error) {
-			loggers.agent.error("Failed to connect to MongoDB:", error);
-			throw error;
-		}
-	}
-
-	public async disconnect(): Promise<void> {
-		if (!this.isConnected) {
-			return;
-		}
-
-		try {
-			await mongoose.disconnect();
-			this.isConnected = false;
-			loggers.agent.info("MongoDB disconnected successfully");
-		} catch (error) {
-			loggers.agent.error("Failed to disconnect from MongoDB:", error);
-			throw error;
-		}
-	}
-
-	public async getSessionHistory(sessionId: string): Promise<SessionObject> {
-		const chats = await ChatModel.find({ sessionId }).sort({
-			timestamp: 1,
-		});
-
-		loggers.agent.info(`Found ${chats.length} chats for session ${sessionId}`);
-
-		const sessionObject: SessionObject = { chats: {} };
-		chats.forEach((chat: ChatDocument) => {
-			const chatId = chat._id?.toString() || chat.id;
-			sessionObject.chats[chatId] = {
-				role: chat.role as ChatRole,
-				content: chat.content,
-				timestamp: chat.timestamp,
-				metadata: chat.metadata,
-			};
-		});
-
-		return sessionObject;
-	}
-
-	public async updateSessionHistory(
-		sessionId: string,
-		chat: ChatObject,
-	): Promise<void> {
-		loggers.agent.info(`Updating session history for session ${sessionId}`);
-		loggers.agent.info(`Chat: ${JSON.stringify(chat)}`);
-
-		await ChatModel.create({
-			sessionId,
-			role: chat.role,
-			content: chat.content,
-			timestamp: chat.timestamp,
-			metadata: chat.metadata,
-		});
-	}
-
-	public async storeQueryAndIntent(
-		query: string,
-		intent: string,
-		sessionId: string,
-	): Promise<void> {
-		// Intent 정보를 metadata에 저장
-		const chat: ChatObject = {
-			role: ChatRole.USER,
-			content: {
-				type: "text",
-				parts: [query],
-			},
-			timestamp: Date.now(),
-			metadata: {
-				intent,
-				query,
-			},
-		};
-
-		await this.updateSessionHistory(sessionId, chat);
-	}
-}
+export { MongoDBSession } from "./implements/session.memory";
+export { MongoDBIntent } from "./implements/intent.memory";

package/models/chats.model.ts

@@ -1,4 +1,4 @@
-import mongoose, { type Document, Schema } from "mongoose";
+import { type Document, Schema } from "mongoose";
 
 // ChatRole enum
 export enum ChatRole {
@@ -7,8 +7,43 @@ export enum ChatRole {
 	MODEL = "MODEL",
 }
 
+export const SessionObjectSchema = new Schema(
+	{
+		sessionId: {
+			type: String,
+			required: true,
+			index: true,
+		},
+		userId: {
+			type: String,
+			required: true,
+			index: true,
+		},
+		title: {
+			type: String,
+			required: false,
+		},
+		created_at: {
+			type: Number,
+			required: true,
+		},
+		updated_at: {
+			type: Number,
+			required: true,
+		}
+	},
+);
+
+export interface SessionDocument extends Document {
+	sessionId: string;
+	userId: string;
+	title?: string;
+	created_at: number;
+	updated_at: number;
+}
+
 // ChatContentObject schema
-const ChatContentObjectSchema = new Schema(
+export const ChatContentObjectSchema = new Schema(
 	{
 		type: { type: String, required: true },
 		parts: { type: [Schema.Types.Mixed], required: true },
@@ -17,7 +52,7 @@ const ChatContentObjectSchema = new Schema(
 );
 
 // ChatObject schema - 개별 문서로 저장
-const ChatObjectSchema = new Schema(
+export const ChatObjectSchema = new Schema(
 	{
 		sessionId: {
 			type: String,
@@ -42,9 +77,6 @@ const ChatObjectSchema = new Schema(
 			default: {},
 		},
 	},
-	{
-		timestamps: true,
-	},
 );
 
 // Chat Document interface
@@ -60,6 +92,3 @@ export interface ChatDocument extends Document {
 	createdAt: Date;
 	updatedAt: Date;
 }
-
-// Export the model
-export const ChatModel = mongoose.model<ChatDocument>("Chat", ChatObjectSchema);

package/models/intent.model.ts

@@ -0,0 +1,32 @@
+import mongoose, { type Document, Schema } from "mongoose";
+
+const IntentObjectSchema = new Schema(
+	{
+		name: {
+			type: String,
+			required: true,
+			index: true,
+		},
+		description: {
+			type: String,
+			required: true,
+		},
+		prompt: {
+			type: String,
+			required: false,
+		},
+		llm: {
+			type: String,
+			required: false,
+		},
+	}
+);
+
+export interface IntentDocument extends Document {
+	name: string;
+	description: string;
+	prompt?: string;
+	llm?: string;
+}
+
+export const IntentModel = mongoose.model<IntentDocument>("Intent", IntentObjectSchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainetwork/adk-provider-memory-mongodb",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "author": "AI Network (https://ainetwork.ai)",
   "type": "module",
   "engines": {
@@ -26,7 +26,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@ainetwork/adk": "^0.1.2",
+    "@ainetwork/adk": "^0.1.7",
     "mongoose": "^8.16.5"
   },
   "devDependencies": {
@@ -36,5 +36,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cb6205738fd84533ce56bbeeab00ea9dfe2aaf3a"
+  "gitHead": "4098aacea7a18099aa020ef5d331cdce0d59c3f3"
 }

package/models/intentTriggeringInfos.model.ts

@@ -1,50 +0,0 @@
-import mongoose, { type Document, Schema } from "mongoose";
-
-const MessageSchema = new Schema(
-	{
-		role: {
-			type: String,
-			enum: ["system", "user", "assistant", "tool", "function"],
-			required: true,
-		},
-		content: {
-			type: Schema.Types.Mixed, // string 또는 object array
-			required: true,
-		},
-	},
-	{ _id: false },
-);
-
-export interface IntentTriggeringInfoDocument extends Document {
-	context: {
-		messages: Array<{
-			role: string;
-			content:
-				| string
-				| Array<
-						| { type: "text"; text: string }
-						| { type: "image_url"; image_url: { url: string } }
-				  >;
-		}>;
-	};
-	intent: {
-		name: string;
-		description: string;
-	};
-}
-
-const IntentTriggeringInfoSchema = new Schema<IntentTriggeringInfoDocument>({
-	context: {
-		messages: [MessageSchema],
-	},
-	intent: {
-		name: { type: String, required: true },
-		description: { type: String, required: true },
-	},
-});
-
-export const IntentTriggeringInfoModel =
-	mongoose.model<IntentTriggeringInfoDocument>(
-		"IntentTriggeringInfo",
-		IntentTriggeringInfoSchema,
-	);