Memory

import { Agent, BufferMemory, AnthropicProvider, ToolRegistry } from '@lov3kaizen/agentsea-core';

// Create buffer memory with max 50 messages
const memory = new BufferMemory(50);

// Create agent with memory
const agent = new Agent(
  {
    name: 'chat-agent',
    model: 'claude-sonnet-4-20250514',
    provider: 'anthropic',
    systemPrompt: 'You are a helpful assistant.',
  },
  new AnthropicProvider(),
  new ToolRegistry(),
  memory, // Pass memory to agent
);

// First conversation
await agent.execute('My name is Alice', {
  conversationId: 'user-123',
  sessionData: {},
  history: [],
});

// Agent remembers from previous message
await agent.execute('What is my name?', {
  conversationId: 'user-123',
  sessionData: {},
  history: [],
});
// Response: "Your name is Alice"

import { Agent, RedisMemory, AnthropicProvider, ToolRegistry } from '@lov3kaizen/agentsea-core';

// Create Redis memory
const memory = new RedisMemory({
  url: process.env.REDIS_URL || 'redis://localhost:6379',
  ttl: 86400, // 24 hours (optional)
  keyPrefix: 'agent:', // Optional key prefix
});

// Create agent with Redis memory
const agent = new Agent(
  config,
  new AnthropicProvider(),
  new ToolRegistry(),
  memory,
);

// Memory persists across server restarts
await agent.execute('Remember: my favorite color is blue', context);

// Later, even after server restart
await agent.execute('What is my favorite color?', context);
// Response: "Your favorite color is blue"

// Cleanup when done
await memory.disconnect();

import { Agent, SummaryMemory, AnthropicProvider, ToolRegistry } from '@lov3kaizen/agentsea-core';

// Create summary memory
const memory = new SummaryMemory(
  new AnthropicProvider(),
  {
    maxMessages: 20, // Keep last 20 messages
    summaryModel: 'claude-haiku-4-20250514', // Use fast model for summaries
    summaryPrompt: 'Summarize the key points from this conversation:', // Optional
  },
);

// Create agent
const agent = new Agent(
  config,
  new AnthropicProvider(),
  new ToolRegistry(),
  memory,
);

// As conversation grows, old messages are automatically summarized
// This keeps token usage low while maintaining context

interface MemoryStore {
  // Save messages for a conversation
  save(conversationId: string, messages: Message[]): Promise<void>;

  // Load messages for a conversation
  load(conversationId: string): Promise<Message[]>;

  // Clear messages for a conversation
  clear(conversationId: string): Promise<void>;

  // Optional: Check if conversation exists
  exists?(conversationId: string): Promise<boolean>;
}

import { MemoryStore, Message } from '@lov3kaizen/agentsea-core';

export class DatabaseMemory implements MemoryStore {
  private db: Database;

  constructor(databaseConnection: Database) {
    this.db = databaseConnection;
  }

  async save(conversationId: string, messages: Message[]): Promise<void> {
    await this.db.conversations.upsert({
      where: { id: conversationId },
      update: {
        messages: messages,
        updatedAt: new Date(),
      },
      create: {
        id: conversationId,
        messages: messages,
        createdAt: new Date(),
      },
    });
  }

  async load(conversationId: string): Promise<Message[]> {
    const conversation = await this.db.conversations.findUnique({
      where: { id: conversationId },
    });

    return conversation?.messages || [];
  }

  async clear(conversationId: string): Promise<void> {
    await this.db.conversations.update({
      where: { id: conversationId },
      data: { messages: [] },
    });
  }

  async exists(conversationId: string): Promise<boolean> {
    const count = await this.db.conversations.count({
      where: { id: conversationId },
    });
    return count > 0;
  }
}

// Use custom memory
const memory = new DatabaseMemory(prismaClient);
const agent = new Agent(config, provider, toolRegistry, memory);

import { Agent, TenantBufferMemory, AnthropicProvider, ToolRegistry } from '@lov3kaizen/agentsea-core';

// Create tenant-aware memory
const memory = new TenantBufferMemory({ maxMessages: 50 });

// Create agent with tenant memory
const agent = new Agent(
  {
    name: 'support-agent',
    model: 'claude-sonnet-4-20250514',
    provider: 'anthropic',
    systemPrompt: 'You are a customer support assistant.',
  },
  new AnthropicProvider(),
  new ToolRegistry(),
  { type: 'custom', store: memory },
);

// Save conversation for specific tenant
await memory.save('tenant-123', 'conv-456', [
  { role: 'user', content: 'How do I upgrade my plan?' },
  { role: 'assistant', content: 'I can help you upgrade your plan...' },
]);

// Load conversation only for this tenant
const history = await memory.load('tenant-123', 'conv-456');

// Complete tenant isolation - Tenant A cannot access Tenant B's data
const tenantAHistory = await memory.load('tenant-a', 'conv-1'); // ✅ Returns tenant A's data
const tenantBHistory = await memory.load('tenant-b', 'conv-1'); // ✅ Returns tenant B's data (different)

// Clear tenant-specific conversation
await memory.clear('tenant-123', 'conv-456');

// Get all conversation IDs for a tenant
const conversationIds = await memory.getConversationIds('tenant-123');

// Clear conversation history
await memory.clear('conversation-123');

// Load existing history
const history = await memory.load('conversation-123');

// Pass history directly to agent
const response = await agent.execute('Hello', {
  conversationId: 'user-123',
  sessionData: {},
  history: history, // Use pre-loaded history
});

// Check if conversation exists
const exists = await memory.exists('conversation-123');
if (!exists) {
  console.log('Starting new conversation');
}

const context = {
  conversationId: 'user-123',
  sessionData: {
    userId: '12345',
    userName: 'Alice',
    preferences: {
      language: 'en',
      timezone: 'America/Los_Angeles',
    },
    metadata: {
      source: 'web',
      device: 'desktop',
    },
  },
  history: [],
};

const response = await agent.execute('What time is it?', context);

// Agent can reference session data in responses
// "Based on your timezone (America/Los_Angeles), it is currently..."