Skip to main content

Overview

The MemoryService is the primary entry point for memory operations in ADK-TS. It orchestrates:
  • Storage: Where and how memories are persisted
  • Summarization: How sessions are transformed into memories
  • Embeddings: How semantic search is enabled

Constructor

config
MemoryServiceConfig
required
Configuration for the memory service.

Setup Examples

import { MemoryService, InMemoryStorageProvider } from '@iqai/adk';

const memoryService = new MemoryService({
  storage: new InMemoryStorageProvider(),
});

Methods

addSessionToMemory

Add a session to memory. The session will be summarized (if configured) and stored for later retrieval. Flow:
  1. If summaryProvider configured: summarize session into MemoryContent
  2. If embeddingProvider configured: generate embedding for the content
  3. Store the memory record via storage provider
session
Session
required
The session to add to memory.
options
object
Additional options for the memory record.
returns
Promise<MemoryRecord>
The created memory record.
const session = await sessionService.endSession('my-app', 'user-123', 'session-id');

if (session) {
  const memory = await memoryService.addSessionToMemory(session);
  console.log('Memory created:', memory.id);
}
Search memories for a user using semantic or keyword search. Flow:
  1. If embeddingProvider configured: generate query embedding
  2. Delegate search to storage provider
query
object
required
Search query parameters.
returns
Promise<MemorySearchResult[]>
Array of matching memories with relevance scores.
const results = await memoryService.search({
  query: 'conversations about Python programming',
  userId: 'user-123',
  appName: 'my-app',
  limit: 5,
  filters: {
    after: '2024-01-01T00:00:00Z'
  }
});

for (const result of results) {
  console.log(`Memory ${result.memory.id} - Score: ${result.score}`);
  console.log(`Summary: ${result.memory.content.summary}`);
}

delete

Delete memories matching the filter.
filter
MemoryDeleteFilter
required
Filter criteria for deletion.
returns
Promise<number>
Number of memories deleted.
// Delete old memories
const deleted = await memoryService.delete({
  userId: 'user-123',
  before: '2023-01-01T00:00:00Z'
});

console.log(`Deleted ${deleted} old memories`);

count

Count memories matching the filter (if supported by storage).
filter
MemoryDeleteFilter
required
Filter criteria for counting.
returns
Promise<number | undefined>
Number of matching memories, or undefined if not supported by the storage provider.
const count = await memoryService.count({
  userId: 'user-123',
  appName: 'my-app'
});

if (count !== undefined) {
  console.log(`User has ${count} memories`);
}

getEmbeddingProvider

Get the configured embedding provider. Useful for generating embeddings externally.
returns
EmbeddingProvider | undefined
The embedding provider, or undefined if not configured.

getSummaryProvider

Get the configured summary provider. Useful for generating summaries externally.
returns
MemorySummaryProvider | undefined
The summary provider, or undefined if not configured.

getStorageProvider

Get the configured storage provider. Useful for direct storage operations.
returns
MemoryStorageProvider
The storage provider.

Memory Content Structure

The MemoryContent type is flexible and depends on your SummaryProvider:
type MemoryContent = {
  // Human-readable summary
  summary?: string;
  
  // Topic segments for granular search
  segments?: TopicSegment[];
  
  // Named entities mentioned
  entities?: Entity[];
  
  // Key facts to remember
  keyFacts?: string[];
  
  // Raw text (if no summarization)
  rawText?: string;
  
  // Custom fields - define your own schema
  [key: string]: unknown;
};

Usage with Agents

import { AgentBuilder, MemoryService, InMemoryStorageProvider } from '@iqai/adk';

const memoryService = new MemoryService({
  storage: new InMemoryStorageProvider()
});

const agent = new AgentBuilder()
  .withModel('gpt-4')
  .withMemoryService(memoryService)
  .withInstruction('You are a helpful assistant with memory')
  .buildLlm();

// Memory is automatically searched and injected into prompts
const response = await agent.ask('What did we talk about last time?');

Build docs developers (and LLMs) love