03-relationships-implicit

Dec 7, 2025

Implicit Relationships

📁 관련 코드: lib/types/relationships/implicit.ts

자동으로 추론되는 관계입니다. LLM 추출 없이 구조적 속성에서 유도됩니다.

핵심 개념: Implicit vs Explicit

┌─────────────────────────────────────────────────────────────┐
│  Implicit (암시적)                                          │
│  "같은 스레드에 있으니까 관련 있을 것이다"                      │
│  → 시스템이 자동 추론                                        │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│  Explicit (명시적)                                          │
│  "이 메모리는 ABC회사를 언급한다"                             │
│  → LLM이 내용에서 추출                                       │
└─────────────────────────────────────────────────────────────┘

	Implicit	Explicit
생성 방법	시스템 자동	LLM 추출
근거	구조적 (threadId, 시간 등)	의미적 (내용 분석)
신뢰도	높음 (확정적)	가변적 (confidence)
비용	낮음	높음 (LLM 호출)

ImplicitRelationType

enum ImplicitRelationType {
  SAME_THREAD = 'same_thread',
  SAME_SENDER = 'same_sender',
  SAME_ENTITY = 'same_entity',
  TEMPORAL_ADJACENT = 'temporal_adjacent',
  SIMILAR_CONTENT = 'similar_content',
}

각 타입 상세

SAME_THREAD

[Memory: 미팅 시간] ←── SAME_THREAD ──→ [Memory: 미팅 장소]
         │                                      │
         └────────── threadId: "abc" ───────────┘

강도: 1.0 (확정적) 의미: 같은 이메일 스레드에서 추출된 두 메모리

SAME_SENDER

[Memory A] ←── SAME_SENDER ──→ [Memory B]
     │                              │
     └── sender: kim@company.com ───┘

강도: 0.8 의미: 같은 발신자가 보낸 이메일에서 추출

SAME_ENTITY

[Memory: ABC회사 계약] ←── SAME_ENTITY ──→ [Memory: ABC회사 미팅]
              │                                    │
              └────── entityId: [ABC회사] ─────────┘

강도: 0.7 의미: 같은 엔티티를 언급하는 두 메모리

TEMPORAL_ADJACENT

[Memory: 1/15 09:00] ←── TEMPORAL_ADJACENT ──→ [Memory: 1/15 10:00]

강도: 시간 차이에 반비례

0시간 차이 → 1.0
24시간 차이 → 0.5
48시간 차이 → 0.25

의미: 시간적으로 가까운 두 메모리

SIMILAR_CONTENT

[Memory A] ←── SIMILAR_CONTENT (0.85) ──→ [Memory B]
     │                                         │
     └── embedding cosine similarity ──────────┘

강도: 임베딩 유사도 점수 (0-1) 의미: 내용이 유사한 두 메모리

Strength (관계 강도)

strength: number;  // 0-1

강도의 의미

강도	의미	예시
1.0	확정적 관계	같은 threadId
0.8+	강한 관계	같은 발신자
0.5-0.8	중간 관계	유사 내용
0.3-0.5	약한 관계	시간적 인접 (하루 이상)

강도 활용

// 강한 관계만 사용하여 그래프 탐색
const strongRelations = relations.filter(r => r.strength >= 0.7);

// 관계 강도를 가중치로 사용
const score = relations.reduce(
  (sum, r) => sum + r.strength,
  0
);

Factory Functions

createSameThreadRelation

const relation = createSameThreadRelation(
  memoryA.id,
  memoryB.id,
  threadId
);
// strength: 1.0 (고정)

createSimilarContentRelation

const similarity = cosineSimilarity(embeddingA, embeddingB);

if (similarity >= 0.7) {  // 임계값
  const relation = createSimilarContentRelation(
    memoryA.id,
    memoryB.id,
    similarity
  );
  // strength: similarity 값 사용
}

createTemporalAdjacentRelation

const hoursDiff = Math.abs(
  dateA.getTime() - dateB.getTime()
) / (1000 * 60 * 60);

const relation = createTemporalAdjacentRelation(
  memoryA.id,
  memoryB.id,
  hoursDiff
);
// strength: 1 / (1 + hoursDiff/24)

그래프에서의 역할

     SAME_THREAD                    SAME_SENDER
         │                              │
         ▼                              ▼
┌─────────────────────────────────────────────────────┐
│  Memory A ◄──────────────────────────► Memory B    │
│     │                                     │        │
│     │         SIMILAR_CONTENT             │        │
│     │              (0.82)                 │        │
│     │                                     │        │
│     └──────────── SAME_ENTITY ────────────┘        │
│                   (ABC회사)                        │
└─────────────────────────────────────────────────────┘

관계 탐색 우선순위

1. SAME_THREAD (1.0) - 같은 대화 맥락
2. SAME_SENDER (0.8) - 같은 사람의 말
3. SAME_ENTITY (0.7) - 같은 주제
4. SIMILAR_CONTENT - 유사 내용
5. TEMPORAL_ADJACENT - 시간적 근접

자동 생성 시점

새 Memory 저장 시

async function saveMemoryWithRelations(memory: MemoryNode) {
  // 1. Memory 저장
  await saveNode(memory);

  // 2. 같은 Thread의 다른 Memory 찾기
  const sameThread = await findByThreadId(memory.sourceId);
  for (const other of sameThread) {
    const rel = createSameThreadRelation(memory.id, other.id, threadId);
    await saveRelation(rel);
  }

  // 3. 같은 Sender의 다른 Memory 찾기
  const sameSender = await findBySender(senderEmail);
  for (const other of sameSender) {
    const rel = createSameSenderRelation(memory.id, other.id, senderEmail);
    await saveRelation(rel);
  }

  // 4. 유사 콘텐츠 검색 (Batch로 나중에)
  // 5. 시간적 인접 (Batch로 나중에)
}

다음 문서

→ Explicit Relationships: LLM 추출 관계
→ MemoryNode: 관계의 주요 대상

‹

›