한 줄 요약: 계층적 메모리(Hierarchical Memory)란, AI 에이전트가 정보를 접근 빈도·중요도·저장 기간에 따라 인메모리(단기), 세션(중기), 외부 저장소(장기) 등 여러 계층으로 나눠 관리하는 메모리 아키텍처이다.

1. 계층적 메모리란 무엇인가?

인간의 기억 구조를 떠올려 보세요. 지금 읽는 이 문장은 작업 기억(Working Memory)에 있습니다. 오늘 아침 식사 내용은 단기 기억(Short-term Memory)에, 어린 시절 기억은 장기 기억(Long-term Memory)에 저장되어 있습니다.

AI 에이전트도 단일 메모리 공간으로는 방대한 정보를 효율적으로 처리하기 어렵습니다. 계층적 메모리는 정보의 특성에 맞는 저장소를 사용해 최적의 성능을 달성합니다.

2. 핵심 개념 이해하기

계층별 특성

┌────────────────────────────────────────────┐
│         L1: 인컨텍스트 메모리 (Fastest)     │
│  • 위치: 컨텍스트 윈도우                     │
│  • 용량: ~200K 토큰                         │
│  • 지속성: 세션 중                           │
│  • 접근: 즉시 (0ms)                         │
├────────────────────────────────────────────┤
│         L2: 외부 캐시 메모리 (Fast)          │
│  • 위치: Redis, 인메모리 DB                  │
│  • 용량: GB 단위                            │
│  • 지속성: TTL 기반                          │
│  • 접근: 매우 빠름 (<10ms)                   │
├────────────────────────────────────────────┤
│         L3: 벡터 메모리 (Medium)            │
│  • 위치: Pinecone, Chroma, Weaviate         │
│  • 용량: TB 단위                            │
│  • 지속성: 영구                              │
│  • 접근: 유사도 검색 (~50ms)                 │
├────────────────────────────────────────────┤
│         L4: 구조적 메모리 (Slow)            │
│  • 위치: 관계형 DB, 파일 시스템              │
│  • 용량: 무제한                             │
│  • 지속성: 영구                              │
│  • 접근: 쿼리 (~100ms+)                     │
└────────────────────────────────────────────┘

메모리 유형별 용도

유형 저장 내용 예시
인컨텍스트 현재 대화, 즉시 필요한 정보 현재 세션 메시지
에피소딕 과거 대화·작업 히스토리 “지난주 사용자가 요청했던…”
시맨틱 사실, 개념, 도메인 지식 회사 정책, 제품 정보
절차적 수행 방법, 루틴 코드 작성 패턴, 워크플로우

3. 실무 적용 예시

계층적 메모리 시스템 구현 예시입니다.

import json
from datetime import datetime, timedelta
from anthropic import Anthropic
from typing import Optional

# 간단한 인메모리 캐시 (L2 역할)
class SimpleCache:
    def __init__(self, ttl_minutes: int = 60):
        self._store = {}
        self._ttl = timedelta(minutes=ttl_minutes)

    def set(self, key: str, value: str):
        self._store[key] = {"value": value, "expires": datetime.now() + self._ttl}

    def get(self, key: str) -> Optional[str]:
        if key in self._store:
            entry = self._store[key]
            if datetime.now() < entry["expires"]:
                return entry["value"]
        return None

class HierarchicalMemoryAgent:
    def __init__(self):
        self.client = Anthropic()
        self.l1_context = []           # L1: 인컨텍스트 (현재 세션)
        self.l2_cache = SimpleCache()   # L2: 빠른 캐시
        self.l3_semantic = {}           # L3: 시맨틱 메모리 (실제 구현은 벡터 DB)
        self.l4_episodic = []           # L4: 에피소딕 기록 (실제 구현은 DB)

    def remember(self, key: str, value: str, level: int = 3):
        """정보를 지정된 계층에 저장합니다."""
        if level <= 2:
            self.l2_cache.set(key, value)
        if level <= 3:
            self.l3_semantic[key] = value
        if level <= 4:
            self.l4_episodic.append({
                "timestamp": datetime.now().isoformat(),
                "key": key, "value": value
            })

    def recall(self, query: str) -> str:
        """계층 순서대로 관련 메모리를 검색합니다."""
        # L2 빠른 캐시 먼저 확인
        cached = self.l2_cache.get(query)
        if cached:
            return f"[캐시] {cached}"

        # L3 시맨틱 메모리 검색 (실제로는 벡터 유사도 검색)
        for key, value in self.l3_semantic.items():
            if query.lower() in key.lower():
                return f"[시맨틱] {value}"

        # L4 에피소딕 검색
        for episode in reversed(self.l4_episodic):
            if query.lower() in episode["key"].lower():
                return f"[에피소딕 {episode['timestamp'][:10]}] {episode['value']}"

        return ""

    def chat(self, user_message: str) -> str:
        """계층적 메모리를 활용한 대화."""
        # 관련 메모리 검색
        memory = self.recall(user_message)
        if memory:
            enhanced_message = f"[참고 메모리: {memory}]\n\n사용자 질문: {user_message}"
        else:
            enhanced_message = user_message

        self.l1_context.append({"role": "user", "content": enhanced_message})

        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            system="당신은 사용자의 이전 정보를 기억하는 개인 AI 어시스턴트입니다.",
            messages=self.l1_context[-10:]  # 최근 10개만 유지
        )

        assistant_message = response.content[0].text
        self.l1_context.append({"role": "assistant", "content": assistant_message})

        # 중요 정보 자동 저장
        if "좋아해" in user_message or "싫어해" in user_message:
            self.remember(f"사용자 선호: {user_message}", user_message, level=3)

        return assistant_message

4. 계층적 메모리 vs 유사 개념 비교

구분 계층적 메모리 단순 컨텍스트 외부 DB만 사용
속도 ✅ 계층별 최적화 ✅ 빠름 ❌ 느림
용량 ✅ 무제한 ❌ 컨텍스트 제한 ✅ 무제한
지속성 ✅ 세션 초월 ❌ 세션 내 ✅
복잡도 높음 낮음 중간
비용 중간 낮음 낮음

5. 마치며

계층적 메모리는 장기적으로 학습하고 개인화되는 AI 에이전트를 구현하는 핵심 인프라입니다. 모든 정보를 하나의 계층에 저장하려는 유혹을 피하고, 정보의 특성(접근 빈도, 중요도, 지속성)에 맞는 계층을 선택하는 것이 핵심입니다.

참고 자료

함께 읽으면 좋은 용어

이 개념과 함께 알아두면 이해가 깊어지는 관련 용어들입니다.

컨텍스트 윈도우 세션 관리 RAG 컨텍스트 엔지니어링 VectorDB

댓글 남기기

참고