claude-memory-layer 1.0.30 → 1.0.32

package/context.md

@@ -1,636 +0,0 @@
-# Context: Claude Code Memory Plugin
-
-## 1. 프로젝트 배경
-
-이 문서는 Claude Code용 Memory Plugin 개발을 위한 배경 연구와 참조 자료를 정리합니다.
-
-### 1.1 목표
-
-사용자가 Claude Code를 사용할수록 더 똑똑해지는 Agent를 만들기 위한 플러그인 개발:
-- 사용자 prompt와 agent 응답을 지속적으로 기억
-- 새로운 prompt 입력 시 관련된 과거 기억을 검색하여 컨텍스트로 활용
-- 시간이 지남에 따라 개인화된 경험 제공
-
----
-
-## 2. Claude Code Plugin System 분석
-
-### 2.1 플러그인 구조
-
-```
-plugin-name/
-├── .claude-plugin/
-│   └── plugin.json          # 플러그인 메타데이터 (필수)
-├── commands/                # 슬래시 명령어 (선택)
-├── agents/                  # 전문화된 에이전트 (선택)
-├── skills/                  # 에이전트 스킬 (선택)
-├── hooks/                   # 이벤트 핸들러 (선택)
-├── .mcp.json               # MCP 서버 구성 (선택)
-└── README.md               # 문서
-```
-
-### 2.2 사용 가능한 Hook 이벤트
-
-| Hook Event | 용도 | Memory Plugin 활용 |
-|------------|------|-------------------|
-| `SessionStart` | 세션 시작 시 실행 | 이전 세션 기억 로드 |
-| `SessionEnd` | 세션 종료 시 실행 | 현재 세션 기억 저장 |
-| `UserPromptSubmit` | 사용자 입력 시 실행 | 관련 기억 검색 및 주입 |
-| `PreToolUse` | 도구 실행 전 | 도구별 과거 사용 패턴 제공 |
-| `PostToolUse` | 도구 실행 후 | 도구 결과 기억 |
-| `Stop` | Agent 응답 완료 시 | 전체 대화 기억 저장 |
-| `PreCompact` | 컨텍스트 압축 전 | 중요 기억 보존 |
-
-### 2.3 Hook Input/Output 형식
-
-```json
-// UserPromptSubmit hook input
-{
-  "session_id": "...",
-  "prompt": "사용자가 입력한 텍스트",
-  "timestamp": "..."
-}
-
-// Hook은 stdout으로 결과 반환
-// - 빈 출력: 변경 없음
-// - JSON 출력: 컨텍스트 주입 또는 수정
-```
-
----
-
-## 3. AI Memory System 연구
-
-### 3.1 Memory의 종류
-
-| 유형 | 설명 | 지속성 |
-|------|------|--------|
-| **Short-term Memory** | 현재 대화 컨텍스트 | 세션 내 |
-| **Long-term Memory** | 사용자 선호도, 과거 인사이트 | 영구적 |
-| **Episodic Memory** | 구체적인 대화/이벤트 기억 | 영구적 |
-| **Semantic Memory** | 추출된 지식과 관계 | 영구적 |
-
-### 3.2 주요 Memory 솔루션 비교
-
-| 솔루션 | 특징 | 장점 |
-|--------|------|------|
-| **Mem0** | Y Combinator 투자, 그래프 기반 | 복잡한 관계 표현 |
-| **LangChain Memory** | 프레임워크 내장 | 쉬운 통합 |
-| **Zep/Graphiti** | 시간적 지식 그래프 | 시계열 추적 |
-| **AWS AgentCore Memory** | 비동기 파이프라인 | 확장성 |
-| **Google Vertex Memory Bank** | 유사도 검색 | 엔터프라이즈 |
-
-### 3.3 Memory vs RAG
-
-- **RAG**: 외부 문서에서 정보 검색 (stateless)
-- **Memory**: 과거 상호작용에서 컨텍스트 검색 (stateful)
-- **이 플러그인**: Memory 중심 + 선택적 RAG 통합
-
----
-
-## 4. AXIOMMIND Memory System 참조
-
-Gist에서 제공된 AXIOMMIND 시스템의 핵심 개념:
-
-### 4.1 아키텍처 레이어
-
-```
-┌─────────────────────────────────────────────────────────┐
-│  L0 EventStore (Single Source of Truth)                 │
-│  - Append-only events table                             │
-│  - Event deduplication via dedupe_key                   │
-│  - Projection offset tracking                           │
-└─────────────────────────────────────────────────────────┘
-                         ↓
-┌─────────────────────────────────────────────────────────┐
-│  Extraction/Sorting Layer (LLM Processing)              │
-│  - LLM extracts structured JSON from raw input          │
-│  - Evidence alignment and validation                    │
-└─────────────────────────────────────────────────────────┘
-                         ↓
-┌─────────────────────────────────────────────────────────┐
-│  Derived Stores (Rebuildable from Events)               │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
-│  │   DuckDB    │  │   LanceDB   │  │  Relational │    │
-│  │  (FTS/SQL)  │  │  (Vectors)  │  │   Views     │    │
-│  └─────────────┘  └─────────────┘  └─────────────┘    │
-└─────────────────────────────────────────────────────────┘
-```
-
-### 4.2 핵심 원칙
-
-- **Append-only EventStore**: 모든 변경 추적, 파생 저장소에서 언제든 재구성 가능
-- **Canonical Key 정규화**: 동일 개념의 여러 표현을 단일 키로 통합
-- **단일 진실 공급원(SoT)**: events 테이블만 영구 저장, 나머지는 파생
-- **멱등성 보장**: `dedupe_key`로 중복 이벤트 차단
-
-### 4.3 Canonical Key 정규화 (핵심 알고리즘)
-
-```python
-# canonical_key.py - 결정론적 키 생성
-def make_canonical_key(title: str, project: str = None) -> str:
-    """
-    동일한 제목은 항상 동일한 키를 생성
-
-    정규화 단계:
-    1. NFKC 유니코드 정규화
-    2. 소문자 변환
-    3. 구두점 제거
-    4. 연속 공백 정리
-    5. (선택) 프로젝트/도메인 컨텍스트 추가
-    6. 긴 키는 MD5 체크섬으로 truncate
-    """
-    import unicodedata
-    import re
-    import hashlib
-
-    # Step 1-4: 정규화
-    normalized = unicodedata.normalize('NFKC', title)
-    normalized = normalized.lower()
-    normalized = re.sub(r'[^\w\s]', '', normalized)
-    normalized = re.sub(r'\s+', ' ', normalized).strip()
-
-    # Step 5: 컨텍스트 추가
-    if project:
-        key = f"{project}::{normalized}"
-    else:
-        key = normalized
-
-    # Step 6: 긴 키 처리
-    MAX_KEY_LENGTH = 200
-    if len(key) > MAX_KEY_LENGTH:
-        hash_suffix = hashlib.md5(key.encode()).hexdigest()[:8]
-        key = key[:MAX_KEY_LENGTH - 9] + "_" + hash_suffix
-
-    return key
-```
-
-**Memory Plugin 적용**:
-- 사용자 prompt의 canonical key로 중복 질문 감지
-- 유사한 질문들을 그룹화하여 패턴 추출
-
-### 4.4 Matching Thresholds (엄격한 매칭 기준)
-
-```python
-# task_matcher.py - 매칭 임계값
-MATCH_THRESHOLDS = {
-    "min_combined_score": 0.92,   # 최소 결합 점수
-    "min_gap": 0.03,              # 1위와 2위 간 최소 점수 차이
-    "suggestion_threshold": 0.75, # 제안 모드 임계값
-}
-
-def calculate_weighted_score(result: SearchResult) -> float:
-    """
-    가중치 점수 계산 (stage, status, recency)
-    """
-    weights = {
-        "semantic_similarity": 0.4,  # 벡터 유사도
-        "fts_score": 0.25,           # 전문 검색 점수
-        "recency_bonus": 0.2,        # 최신성 가산점
-        "status_weight": 0.15,       # 상태별 가중치
-    }
-
-    score = (
-        result.vector_score * weights["semantic_similarity"] +
-        result.fts_score * weights["fts_score"] +
-        result.recency_score * weights["recency_bonus"] +
-        result.status_score * weights["status_weight"]
-    )
-    return score
-
-def match_with_confidence(query: str, candidates: list) -> MatchResult:
-    """
-    엄격한 매칭: top-1이 확실히 우세할 때만 확정
-    """
-    if len(candidates) == 0:
-        return MatchResult(match=None, confidence="none")
-
-    top = candidates[0]
-
-    if top.score < MATCH_THRESHOLDS["suggestion_threshold"]:
-        return MatchResult(match=None, confidence="none")
-
-    if top.score >= MATCH_THRESHOLDS["min_combined_score"]:
-        if len(candidates) == 1:
-            return MatchResult(match=top, confidence="high")
-
-        gap = top.score - candidates[1].score
-        if gap >= MATCH_THRESHOLDS["min_gap"]:
-            return MatchResult(match=top, confidence="high")
-
-    # 점수가 높지만 확실하지 않음 → 제안 모드
-    return MatchResult(match=top, confidence="suggested")
-```
-
-**Memory Plugin 적용**:
-- 관련 기억 검색 시 엄격한 임계값 적용
-- 애매한 매칭은 "suggested" 상태로 표시
-
-### 4.5 Single-Writer Pattern (벡터 동시성 제어)
-
-```python
-# vector_worker.py - Outbox 패턴으로 동시성 제어
-
-"""
-LanceDB는 동시 쓰기에 취약하므로 Single-Writer 패턴 사용:
-1. 이벤트 저장 시 embedding_outbox 테이블에 작업 추가
-2. 별도 워커가 outbox를 순차적으로 처리
-3. 처리 완료 시 outbox에서 삭제
-"""
-
-# DuckDB의 outbox 테이블
-CREATE TABLE embedding_outbox (
-    id              UUID PRIMARY KEY,
-    event_id        UUID NOT NULL,
-    content         TEXT NOT NULL,
-    status          VARCHAR DEFAULT 'pending',  -- 'pending' | 'processing' | 'done'
-    created_at      TIMESTAMP DEFAULT NOW(),
-    processed_at    TIMESTAMP
-);
-
-# Python 워커 (단일 프로세스)
-class VectorWorker:
-    def __init__(self, db: DuckDB, lance: LanceDB, embedder: Embedder):
-        self.db = db
-        self.lance = lance
-        self.embedder = embedder
-
-    async def process_outbox(self, batch_size: int = 32):
-        """
-        Outbox에서 pending 항목을 가져와 순차 처리
-        """
-        # 1. Pending 항목 가져오기 (락 획득)
-        pending = self.db.execute("""
-            UPDATE embedding_outbox
-            SET status = 'processing'
-            WHERE id IN (
-                SELECT id FROM embedding_outbox
-                WHERE status = 'pending'
-                ORDER BY created_at
-                LIMIT ?
-            )
-            RETURNING *
-        """, [batch_size])
-
-        if not pending:
-            return
-
-        # 2. 배치 임베딩 생성
-        contents = [p.content for p in pending]
-        vectors = await self.embedder.embed_batch(contents)
-
-        # 3. LanceDB에 저장 (단일 쓰기)
-        records = [
-            {"event_id": p.event_id, "content": p.content, "vector": v}
-            for p, v in zip(pending, vectors)
-        ]
-        self.lance.add(records)
-
-        # 4. Outbox 정리
-        ids = [p.id for p in pending]
-        self.db.execute("""
-            DELETE FROM embedding_outbox WHERE id = ANY(?)
-        """, [ids])
-```
-
-**Memory Plugin 적용**:
-- 대화 저장 시 즉시 반환, 임베딩은 비동기 처리
-- 동시성 문제 없이 안정적인 벡터 인덱싱
-
-### 4.6 Blocker/Condition 분류 전략
-
-```python
-# task_resolver.py - 애매한 참조 처리
-
-"""
-Blocker 분류 전략:
-1. Artifact: URL, Jira, GitHub 이슈 등 명확한 참조
-2. Task: 엄격한 매칭만 허용 (score >= 0.92)
-3. Condition: 애매한 참조 흡수 (나중에 해결 가능)
-"""
-
-class BlockerType(Enum):
-    ARTIFACT = "artifact"    # 명확한 외부 참조
-    TASK = "task"            # 확정된 작업 참조
-    CONDITION = "condition"  # 애매한 조건/참조
-
-def classify_blocker(reference: str, match_result: MatchResult) -> BlockerType:
-    # URL, 이슈 번호 등은 Artifact
-    if is_artifact_reference(reference):
-        return BlockerType.ARTIFACT
-
-    # 높은 신뢰도 매칭은 Task
-    if match_result.confidence == "high":
-        return BlockerType.TASK
-
-    # 나머지는 Condition으로 흡수
-    return BlockerType.CONDITION
-
-# Condition은 나중에 실제 Task로 해결될 수 있음
-# resolves_to edge로 연결
-```
-
-**Memory Plugin 적용**:
-- 불완전한 컨텍스트도 일단 저장
-- 나중에 추가 정보로 보강 가능
-
-### 4.7 Query Patterns (효과적인 뷰 활용)
-
-```sql
--- v_task_blockers_effective: Condition 해결을 반영한 최종 blocker 뷰
-CREATE VIEW v_memory_context_effective AS
-SELECT
-    m.id,
-    m.session_id,
-    m.content,
-    m.event_type,
-    m.timestamp,
-    -- Condition이 해결된 경우 실제 참조로 대체
-    COALESCE(r.resolved_content, m.content) as effective_content,
-    COALESCE(r.resolved_id, m.id) as effective_id
-FROM memories m
-LEFT JOIN memory_resolutions r ON m.id = r.condition_id
-WHERE r.resolution_type IS NULL OR r.resolution_type = 'confirmed';
-
--- 4가지 주요 쿼리 패턴
--- 1. 확정된 관련 기억
-SELECT * FROM v_memory_context_effective
-WHERE semantic_score >= 0.92;
-
--- 2. 제안 상태의 기억 (확인 대기)
-SELECT * FROM memories
-WHERE match_confidence = 'suggested';
-
--- 3. 자동 플레이스홀더 감지
-SELECT * FROM memories
-WHERE auto_placeholder = true;
-
--- 4. 해결된 조건 매핑
-SELECT condition_id, resolved_to_id
-FROM memory_resolutions
-WHERE resolution_type = 'confirmed';
-```
-
-### 4.8 Placeholder 자동 생성
-
-```python
-# 정보가 불완전할 때 플레이스홀더 생성
-def create_placeholder_if_needed(event: MemoryEvent) -> Optional[Placeholder]:
-    """
-    컨텍스트가 불완전하면 자동 플레이스홀더 생성
-    - auto_placeholder=true 플래그 설정
-    - 나중에 추가 정보로 해결 가능
-    """
-    if is_incomplete_context(event):
-        return Placeholder(
-            id=generate_uuid(),
-            event_id=event.id,
-            placeholder_type="unknown_context",
-            auto_placeholder=True,
-            created_at=datetime.now()
-        )
-    return None
-```
-
-### 4.9 주요 모듈 요약
-
-| 모듈 | 역할 | Memory Plugin 대응 |
-|------|------|-------------------|
-| `canonical_key.py` | 결정론적 키 정규화 | `normalizer.ts` |
-| `event_store.py` | append-only 이벤트 저장 | `event-store.ts` |
-| `task_matcher.py` | 가중치 기반 매칭 | `matcher.ts` |
-| `task_resolver.py` | 상태 전이 검증 | `resolver.ts` |
-| `projector_task.py` | 이벤트→엔티티 투영 | `projector.ts` |
-| `vector_worker.py` | 단일 쓰기 임베딩 | `vector-worker.ts` |
-
-### 4.10 Memory Graduation Pipeline (L0 → L4)
-
-AXIOMMIND의 핵심 개념인 **다단계 메모리 승격 파이프라인**:
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                    Memory Graduation Pipeline                    │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                  │
-│  L0: EventStore (Raw)                                           │
-│  ├── 원본 채팅 로그, 프롬프트/응답                                │
-│  ├── Append-only, 불변                                          │
-│  └── dedupe_key로 멱등성 보장                                    │
-│                         ↓                                        │
-│  L1: Structured JSON                                            │
-│  ├── LLM이 추출한 구조화된 데이터                                │
-│  ├── 엔티티, 관계, 인사이트                                      │
-│  └── EvidenceAligner로 증거 스팬 정렬                            │
-│                         ↓                                        │
-│  L2: Idris Candidates (검증 대상)                               │
-│  ├── 타입 안전한 표현으로 변환                                   │
-│  ├── 의존적 타입으로 불변식 검증                                 │
-│  └── idris_generator.py가 생성                                  │
-│                         ↓                                        │
-│  L3: Verified Knowledge                                         │
-│  ├── Idris 타입체커 통과                                        │
-│  ├── 모순 없음 확인                                              │
-│  └── 신뢰도 높은 지식                                            │
-│                         ↓                                        │
-│  L4: Active Memory (검색 가능)                                  │
-│  ├── 벡터 인덱싱 완료                                            │
-│  ├── 실시간 검색 가능                                            │
-│  └── 컨텍스트 주입에 사용                                        │
-│                                                                  │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-**Memory Plugin 적용**:
-- L0: 모든 대화를 `events` 테이블에 저장
-- L1: 주기적으로 인사이트 추출 (LLM 기반)
-- L2: TypeScript 강타입으로 검증 (Idris2 개념 적용)
-- L3: 테스트 통과한 검증된 지식
-- L4: LanceDB에 인덱싱되어 검색 가능한 상태
-
-### 4.11 AXIOMMIND 7가지 필수 원칙
-
-| # | 원칙 | 설명 | Memory Plugin 적용 |
-|---|------|------|-------------------|
-| 1 | **진실의 원천(SoT)은 이벤트 로그** | 파생 테이블은 언제든 재구성 가능 | `events` 테이블만 영구 저장 |
-| 2 | **추가전용 구조** | events에 UPDATE/DELETE 금지 | `append()` 메서드만 제공 |
-| 3 | **멱등성 보장** | `dedupe_key`로 중복 제어 | content_hash + session_id |
-| 4 | **증거 범위는 파이프라인이 확정** | LLM은 인용문만, aligner가 스팬 계산 | `EvidenceAligner` 모듈 |
-| 5 | **Task는 엔티티** | 세션마다 새 항목 아닌 기존 업데이트 | `canonical_key`로 동일성 판단 |
-| 6 | **벡터 저장소 정합성** | DuckDB → outbox → LanceDB 단방향 | Single-Writer Pattern |
-| 7 | **DuckDB JSON 사용** | JSONB 제거, 표준 JSON만 | `metadata JSON` 컬럼 |
-
-```typescript
-// 원칙 적용 예시: EventStore 인터페이스
-interface EventStoreInterface {
-  // 원칙 2: 추가전용 - append만 허용
-  append(event: MemoryEvent): Promise<AppendResult>;
-
-  // 조회는 자유롭게
-  getBySession(sessionId: string): Promise<MemoryEvent[]>;
-  getRecent(limit: number): Promise<MemoryEvent[]>;
-
-  // 원칙 2 위반: UPDATE/DELETE 메서드 없음
-  // update(): ❌ 금지
-  // delete(): ❌ 금지
-}
-```
-
-### 4.12 Evidence Aligner (증거 정렬기)
-
-```python
-# evidence_aligner.py - LLM 인용문을 정확한 스팬으로 변환
-
-class EvidenceAligner:
-    """
-    원칙 4: LLM은 인용문만 제공, aligner가 정확한 스팬 계산
-
-    LLM이 추출한 대략적인 인용문을 원본 텍스트에서
-    정확한 (start, end) 위치로 변환
-    """
-
-    def align(
-        self,
-        source_text: str,
-        llm_quote: str,
-        fuzzy_threshold: float = 0.85
-    ) -> Optional[EvidenceSpan]:
-        """
-        1. 정확한 매칭 시도
-        2. 실패 시 fuzzy matching (Levenshtein)
-        3. 임계값 미달 시 None 반환
-        """
-        # 정확한 매칭
-        exact_pos = source_text.find(llm_quote)
-        if exact_pos >= 0:
-            return EvidenceSpan(
-                start=exact_pos,
-                end=exact_pos + len(llm_quote),
-                confidence=1.0,
-                match_type="exact"
-            )
-
-        # Fuzzy 매칭
-        best_match = self._fuzzy_search(source_text, llm_quote)
-        if best_match and best_match.score >= fuzzy_threshold:
-            return EvidenceSpan(
-                start=best_match.start,
-                end=best_match.end,
-                confidence=best_match.score,
-                match_type="fuzzy"
-            )
-
-        return None
-
-    def _fuzzy_search(self, text: str, query: str) -> Optional[FuzzyMatch]:
-        # 슬라이딩 윈도우 + Levenshtein 거리
-        ...
-```
-
-**Memory Plugin 적용**:
-- 사용자가 "이전에 rate limiting 얘기했잖아"라고 하면
-- LLM이 대략적인 인용문 추출
-- EvidenceAligner가 정확한 원본 위치 찾기
-- 해당 컨텍스트를 정확히 주입
-
-### 5.1 Vector Database: LanceDB
-
-선택 이유:
-- **Embedded 모드**: SQLite처럼 서버 없이 로컬 실행
-- **Apache Arrow 기반**: 빠른 디스크 접근
-- **다중 모달 지원**: 텍스트, 이미지, 오디오 임베딩
-- **DuckDB 호환**: SQL 쿼리 가능
-
-```python
-import lancedb
-
-db = lancedb.connect("~/.claude-memory")
-table = db.create_table("conversations", data)
-results = table.search(query_embedding).limit(10).to_list()
-```
-
-### 5.2 관계형 저장소: DuckDB
-
-선택 이유:
-- **임베디드**: 파일 기반, 서버 불필요
-- **분석 최적화**: OLAP 워크로드에 적합
-- **SQL 지원**: 친숙한 쿼리 언어
-- **Lance 포맷 호환**: LanceDB와 통합
-
-### 5.3 Embedding Model
-
-옵션:
-1. **OpenAI text-embedding-3-small**: 고품질, API 비용
-2. **sentence-transformers**: 로컬 실행, 무료
-3. **Ollama embeddings**: 로컬 LLM 활용
-
-권장: sentence-transformers (로컬 우선) + OpenAI fallback
-
----
-
-## 6. Idris2 활용 고려사항
-
-### 6.1 Idris2 개요
-
-- **의존적 타입 시스템**: 타입 수준에서 프로그램 검증
-- **Type-Driven Development**: 타입이 프로그램 설계를 가이드
-- **Quantitative Type Theory (QTT)**: 선형 타입 지원
-
-### 6.2 적용 가능 영역
-
-1. **타입 안전한 이벤트 스키마**
-   ```idris
-   data MemoryEvent : Type where
-     UserPrompt : (sessionId : String) -> (content : String) -> MemoryEvent
-     AgentResponse : (sessionId : String) -> (content : String) -> MemoryEvent
-   ```
-
-2. **불변성 보장**
-   - Append-only EventStore의 불변성을 타입 수준에서 강제
-
-3. **정확성 증명**
-   - 중복 제거 로직의 정확성 검증
-   - 검색 알고리즘의 속성 증명
-
-### 6.3 실용적 접근
-
-Idris2를 직접 사용하기보다 **개념적 영감**으로 활용:
-- TypeScript의 강타입 시스템 적극 활용
-- Zod/io-ts로 런타임 타입 검증
-- 불변 데이터 구조 (Immutable.js 또는 순수 함수형 패턴)
-
----
-
-## 7. 참조 링크
-
-### Claude Code Plugin 개발
-- [Create plugins - Claude Code Docs](https://code.claude.com/docs/en/plugins)
-- [Claude Code Plugins README](https://github.com/anthropics/claude-code/blob/main/plugins/README.md)
-- [Hook Development SKILL](https://github.com/anthropics/claude-code/blob/main/plugins/plugin-dev/skills/hook-development/SKILL.md)
-- [Claude Code Plugins Complete Guide](https://jangwook.net/en/blog/en/claude-code-plugins-complete-guide/)
-
-### AI Memory Systems
-- [Mem0: Building Production-Ready AI Agents](https://arxiv.org/pdf/2504.19413)
-- [AWS AgentCore Long-term Memory](https://aws.amazon.com/blogs/machine-learning/building-smarter-ai-agents-agentcore-long-term-memory-deep-dive/)
-- [Google Vertex AI Memory Bank](https://docs.cloud.google.com/agent-builder/agent-engine/memory-bank/overview)
-- [LangChain Conversational Memory](https://www.pinecone.io/learn/series/langchain/langchain-conversational-memory/)
-
-### Vector Databases
-- [LanceDB](https://lancedb.com/)
-- [Lance Format on GitHub](https://github.com/lance-format/lance)
-
-### Idris2
-- [Idris2 Official Site](https://www.idris-lang.org/)
-- [Idris 2: Quantitative Type Theory in Practice](https://arxiv.org/abs/2104.00480)
-- [Idris2 GitHub](https://github.com/idris-lang/Idris2)
-
----
-
-## 8. 용어 정의
-
-| 용어 | 정의 |
-|------|------|
-| **Memory** | 과거 대화에서 추출/저장된 정보 |
-| **Embedding** | 텍스트를 벡터로 변환한 표현 |
-| **Semantic Search** | 의미 기반 유사도 검색 |
-| **EventStore** | 모든 이벤트를 시간순으로 저장하는 append-only 저장소 |
-| **Hook** | 특정 이벤트 발생 시 실행되는 스크립트 |
-| **MCP** | Model Context Protocol - Claude와 외부 도구 연결 |