3장: 장기 메모리 — 벡터 기반 의미 검색

import { EmbeddingModel } from "./embeddings";
import { VectorDB } from "./vector-db";
 
interface MemoryRecord {
  id: string;
  content: string;
  metadata: {
    userId: string;
    sessionId: string;
    timestamp: number;
    type: "fact" | "preference" | "interaction";
  };
  embedding?: number[];
}
 
class LongTermMemory {
  constructor(
    private embedder: EmbeddingModel,
    private db: VectorDB
  ) {}
 
  async store(content: string, metadata: MemoryRecord["metadata"]): Promise<void> {
    const embedding = await this.embedder.embed(content);
 
    await this.db.upsert({
      id: crypto.randomUUID(),
      content,
      metadata,
      embedding,
    });
  }
 
  async search(
    query: string,
    userId: string,
    topK: number = 5
  ): Promise<MemoryRecord[]> {
    const queryEmbedding = await this.embedder.embed(query);
 
    return this.db.query({
      vector: queryEmbedding,
      filter: { userId },
      topK,
    });
  }
}

// 전략 1: 대화 턴 단위
function chunkByTurn(messages: Message[]): string[] {
  const chunks: string[] = [];
  for (let i = 0; i < messages.length; i += 2) {
    const userMsg = messages[i];
    const assistantMsg = messages[i + 1];
    if (userMsg && assistantMsg) {
      chunks.push(
        `사용자: ${userMsg.content}\n에이전트: ${assistantMsg.content}`
      );
    }
  }
  return chunks;
}
 
// 전략 2: 주제 단위
function chunkByTopic(messages: Message[]): string[] {
  // 주제 전환 감지 후 그룹화
  // 실제로는 LLM이나 토픽 모델링으로 경계를 판단
  return detectTopicBoundaries(messages).map(
    (group) => group.map((m) => `[${m.role}]: ${m.content}`).join("\n")
  );
}
 
// 전략 3: 추출된 사실 단위
function chunkByFact(messages: Message[]): string[] {
  // LLM을 사용하여 대화에서 개별 사실을 추출
  // "사용자는 TypeScript를 선호한다"
  // "프로젝트 마감일은 4월 15일이다"
  return extractFacts(messages);
}

interface MemoryMetadata {
  // 필수 필터링 필드
  userId: string;
  organizationId?: string;
 
  // 시간 관련
  createdAt: number;      // Unix timestamp
  lastAccessedAt: number;
  accessCount: number;
 
  // 분류
  type: "fact" | "preference" | "decision" | "interaction";
  topic: string;           // 주제 태그
  importance: number;      // 0.0 ~ 1.0
 
  // 출처 추적
  sourceSessionId: string;
  sourceMessageIndex: number;
}

interface SearchResult {
  content: string;
  similarity: number;  // 0.0 ~ 1.0
  metadata: MemoryMetadata;
}
 
function filterAndRank(
  results: SearchResult[],
  options: {
    minSimilarity: number;   // 최소 유사도 임계값
    recencyWeight: number;   // 시간 가중치
    importanceWeight: number; // 중요도 가중치
  }
): SearchResult[] {
  const now = Date.now();
 
  return results
    // 1. 임계값 이하 제거
    .filter((r) => r.similarity >= options.minSimilarity)
    // 2. 복합 스코어 계산
    .map((r) => {
      const daysSinceCreation =
        (now - r.metadata.createdAt) / (1000 * 60 * 60 * 24);
      const recencyScore = Math.exp(-daysSinceCreation / 30); // 30일 반감기
 
      const compositeScore =
        r.similarity * 0.5 +
        recencyScore * options.recencyWeight +
        r.metadata.importance * options.importanceWeight;
 
      return { ...r, compositeScore };
    })
    // 3. 복합 스코어 기준 정렬
    .sort((a, b) => b.compositeScore - a.compositeScore);
}

from pinecone import Pinecone
 
pc = Pinecone(api_key="your-api-key")
index = pc.Index("agent-memory")
 
# 메모리 저장
index.upsert(
    vectors=[
        {
            "id": "mem_001",
            "values": embedding_vector,
            "metadata": {
                "user_id": "user_123",
                "type": "preference",
                "content": "사용자는 TypeScript를 선호합니다",
            },
        }
    ]
)
 
# 메모리 검색
results = index.query(
    vector=query_embedding,
    filter={"user_id": "user_123"},
    top_k=5,
    include_metadata=True,
)

-- pgvector 확장 활성화
CREATE EXTENSION IF NOT EXISTS vector;
 
-- 메모리 테이블 생성
CREATE TABLE agent_memories (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id TEXT NOT NULL,
  content TEXT NOT NULL,
  embedding vector(1536),  -- OpenAI ada-002 차원
  memory_type TEXT NOT NULL,
  importance FLOAT DEFAULT 0.5,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  last_accessed_at TIMESTAMPTZ DEFAULT NOW(),
  access_count INTEGER DEFAULT 0
);
 
-- IVFFlat 인덱스 생성 (대량 데이터 시 검색 가속)
CREATE INDEX ON agent_memories
  USING ivfflat (embedding vector_cosine_ops)
  WITH (lists = 100);
 
-- 의미 검색 쿼리
SELECT content, importance,
       1 - (embedding <=> $1::vector) AS similarity
FROM agent_memories
WHERE user_id = $2
  AND 1 - (embedding <=> $1::vector) > 0.7
ORDER BY similarity DESC
LIMIT 5;

async function cleanupStaleMemories(
  db: VectorDB,
  userId: string,
  maxAgeDays: number = 90,
  minAccessCount: number = 2
): Promise<number> {
  const cutoffDate = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
 
  const staleMemories = await db.query({
    filter: {
      userId,
      lastAccessedAt: { $lt: cutoffDate },
      accessCount: { $lt: minAccessCount },
      importance: { $lt: 0.3 },
    },
  });
 
  await db.delete(staleMemories.map((m) => m.id));
  return staleMemories.length;
}