import { InMemoryMemory, TDAIMemory, TypeORMMemory } from '@ag-kit/agents/storage';

// 根据需求选择实现
const memory = new InMemoryMemory(); // 用于开发
// const memory = new TDAIMemory({ ... }); // 用于生产
// const memory = new TypeORMMemory({ ... }); // 用于自定义数据库

// 所有实现共享相同的接口
await memory.add({
  message: {
    id: 'msg-1',
    role: 'user',
    content: 'Hello, I need help with my project',
    timestamp: new Date()
  },
  state: { userId: 'user-123', context: 'project-help' }
});

// 跨所有实现的常用操作
const events = await memory.list({ limit: 10, maxTokens: 4000 });
const results = await memory.retrieve('project help');
const count = await memory.getCount();

// 配置上下文阈值以进行自动管理
const memory = new SomeMemory({
  enableContextManagement: true,
  thresholds: {
    preRotThreshold: 8000,        // 在 8000 个令牌时开始管理
    compactionTrigger: 0.8,       // 在阈值的 80% 时压缩
    summarizationTrigger: 0.95,   // 在阈值的 95% 时摘要
    recentToKeep: 10              // 始终保留最后 10 条消息
  }
});

// 在操作期间自动管理上下文
await memory.add(event); // 如果需要,自动触发压缩

import { TokenTrimmer, TiktokenTokenizer } from '@ag-kit/agents/storage';

// 创建分词器和修剪器
const tokenizer = new TiktokenTokenizer('gpt-4');
const trimmer = new TokenTrimmer(tokenizer);

// 计数令牌
const tokenCount = tokenizer.countTokens('Hello, world!');

// 修剪消息以适应上下文窗口
const events = await memory.list();
const trimmed = trimmer.trimMessages(events, 4000, 'newest_first');

// 语义搜索相关记忆
const results = await memory.retrieve('project help', {
  limit: 5,
  threshold: 0.7,
  sessionId: 'user-session'
});

// 结果包含相关性分数
results.forEach(event => {
  console.log(`Score: ${event.score}, Content: ${event.message.content}`);
});

// 使用不同的会话
await memory.add(event1, { sessionId: 'session-A' });
await memory.add(event2, { sessionId: 'session-B' });

// 会话实用程序
const sessionIds = memory.getSessionIds?.() || [];
const count = await memory.getCount({ sessionId: 'session-A' });
await memory.clear({ sessionId: 'session-A' });

// 创建并切换到新分支
await memory.branch('experiment-1');
await memory.checkout('experiment-1');

// 列出所有分支
const branches = await memory.listBranches();

// 时间旅行到特定事件
await memory.checkout('msg-5', { type: 'event' });

// 清理未使用的分支
await memory.cleanupBranches();

import { TokenTrimmer, TiktokenTokenizer } from '@ag-kit/agents/storage';

// 创建分词器和修剪器
const tokenizer = new TiktokenTokenizer('gpt-4');
const trimmer = new TokenTrimmer(tokenizer);

// 计数令牌
const tokenCount = tokenizer.countTokens('Hello, world!');

// 修剪消息以适应上下文窗口
const events = await memory.list();
const trimmed = trimmer.trimMessages(events, 4000, 'newest_first');

import { Mem0LongTermMemory } from '@ag-kit/agents/storage';

const longTermMemory = new Mem0LongTermMemory({
  apiKey: 'your-mem0-api-key',
  userId: 'user-123'
});

// 记录记忆
await longTermMemory.record({
  id: 'mem-1',
  strategy: 'user_preferences',
  content: 'User prefers dark mode and minimal UI',
  metadata: { confidence: 0.9 },
  createdAt: new Date()
});

// 语义搜索
const results = await longTermMemory.semanticSearch('UI preferences');

interface MemoryEntity {
  id: string;
  strategy: string;                    // 用于组织的记忆策略/类别
  role?: 'user' | 'assistant';         // 可选角色信息
  content: string;                     // 记忆内容文本
  metadata: Record<string, any>;       // 额外的上下文和元数据
  createdAt: Date;                     // 创建时间戳
  updatedAt?: Date;                    // 最后更新时间戳
}

interface MemoryQuery {
  query?: string;                      // 用于搜索的语义查询文本
  strategy?: string | string[];        // 策略过滤器
  limit?: number;                      // 返回的最大结果数
  offset?: number;                     // 分页偏移量
  threshold?: number;                  // 相似性阈值 (0-1)
  filters?: Record<string, any>;       // 额外过滤器
  orderBy?: Record<string, 'asc' | 'desc'>; // 排序选项
  [key: string]: any;                  // 可扩展以用于特定实现的选项
}

abstract class BaseLongTermMemory {
  // 核心 CRUD 操作
  abstract record(memory: MemoryEntity): Promise<void>;
  abstract recordBatch(memories: MemoryEntity[]): Promise<void>;
  abstract retrieve(query: MemoryQuery): Promise<MemoryEntity[]>;
  abstract delete(memoryId: string | MemoryQuery): Promise<void>;
  abstract update(memoryId: string, updates: Partial<MemoryEntity>): Promise<void>;
  abstract clear(strategy?: string): Promise<void>;

  // 高级功能
  abstract extractAndRecord(messages: Message[], context: Record<string, any>): Promise<MemoryEntity[]>;
  abstract semanticSearch(query: string, options?: MemoryQuery): Promise<MemoryEntity[]>;
  abstract getRelatedMemories(memoryId: string, depth?: number): Promise<MemoryEntity[]>;
  abstract consolidate(): Promise<void>;
}

constructor(config: Mem0LongTermMemoryConfig)

constructor(encodingName?: TiktokenEncoding)

constructor(tokenizer?: ITokenizer)

constructor(tokensPerChar?: number)

import { InMemoryMemory, Mem0LongTermMemory } from '@ag-kit/agents/storage';

class ChatApplication {
  private shortTermMemory: InMemoryMemory;
  private longTermMemory: Mem0LongTermMemory;

  constructor() {
    this.shortTermMemory = new InMemoryMemory();
    this.longTermMemory = new Mem0LongTermMemory({
      apiKey: process.env.MEM0_API_KEY!,
      userId: 'default-user'
    });
  }

  async handleMessage(sessionId: string, userId: string, message: string) {
    // 存储在短期记忆中
    await this.shortTermMemory.add({
      message: {
        id: `msg-${Date.now()}`,
        role: 'user',
        content: message,
        timestamp: new Date()
      },
      state: { userId, sessionId, context: 'chat' }
    }, { sessionId });

    // 获取对话上下文(最后 10 条消息,最多 4000 个令牌)
    const context = await this.shortTermMemory.list({
      sessionId,
      limit: 10,
      order: 'desc',
      maxTokens: 4000
    });

    // 搜索长期记忆以获取相关信息
    const relevantMemories = await this.longTermMemory.semanticSearch(message, {
      threshold: 0.7,
      limit: 5
    });

    return context;
  }
}

// 创建并切换到新分支
await memory.branch('experiment-1');
await memory.checkout('experiment-1');

// 列出所有分支
const branches = await memory.listBranches();

// 时间旅行到特定事件
await memory.checkout('msg-5', { type: 'event' });

// 清理未使用的分支
await memory.cleanupBranches();