@codai/memorai-core
Version:
Core memory engine with vector operations for AI agents
121 lines • 3.79 kB
JavaScript
/**
* @fileoverview Storage adapter for persistent memory storage
*/
/**
* In-memory storage adapter for development and testing
*/
export class InMemoryStorageAdapter {
memories = new Map();
async store(memory) {
this.memories.set(memory.id, { ...memory });
}
async retrieve(id) {
return this.memories.get(id) || null;
}
async update(id, updates) {
const existing = this.memories.get(id);
if (existing) {
this.memories.set(id, { ...existing, ...updates });
}
}
async delete(id) {
this.memories.delete(id);
}
async list(filters = {}) {
let memories = Array.from(this.memories.values());
// Apply filters
if (filters.tenantId) {
memories = memories.filter(m => m.tenant_id === filters.tenantId);
}
if (filters.agentId) {
memories = memories.filter(m => m.agent_id === filters.agentId);
}
if (filters.type) {
memories = memories.filter(m => m.type === filters.type);
}
if (filters.importance !== undefined) {
memories = memories.filter(m => m.importance >= filters.importance);
}
if (filters.since) {
memories = memories.filter(m => m.createdAt >= filters.since);
}
if (filters.until) {
memories = memories.filter(m => m.createdAt <= filters.until);
}
// Sort by createdAt (newest first)
memories.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
// Apply pagination
const offset = filters.offset || 0;
const limit = filters.limit || memories.length;
return memories.slice(offset, offset + limit);
}
async clear(tenantId) {
if (tenantId) {
// Clear only memories for specific tenant
for (const [id, memory] of this.memories.entries()) {
if (memory.tenant_id === tenantId) {
this.memories.delete(id);
}
}
}
else {
// Clear all memories
this.memories.clear();
}
}
}
/**
* PostgreSQL storage adapter (stub for future implementation)
*/
export class PostgreSQLStorageAdapter {
connectionString;
constructor(connectionString) {
this.connectionString = connectionString;
}
async store(memory) {
throw new Error('PostgreSQL adapter not implemented yet');
}
async retrieve(id) {
throw new Error('PostgreSQL adapter not implemented yet');
}
async update(id, updates) {
throw new Error('PostgreSQL adapter not implemented yet');
}
async delete(id) {
throw new Error('PostgreSQL adapter not implemented yet');
}
async list(filters) {
throw new Error('PostgreSQL adapter not implemented yet');
}
async clear(tenantId) {
throw new Error('PostgreSQL adapter not implemented yet');
}
}
/**
* Redis storage adapter (stub for future implementation)
*/
export class RedisStorageAdapter {
redisUrl;
constructor(redisUrl) {
this.redisUrl = redisUrl;
}
async store(memory) {
throw new Error('Redis adapter not implemented yet');
}
async retrieve(id) {
throw new Error('Redis adapter not implemented yet');
}
async update(id, updates) {
throw new Error('Redis adapter not implemented yet');
}
async delete(id) {
throw new Error('Redis adapter not implemented yet');
}
async list(filters) {
throw new Error('Redis adapter not implemented yet');
}
async clear(tenantId) {
throw new Error('Redis adapter not implemented yet');
}
}
//# sourceMappingURL=StorageAdapter.js.map