4장: 에피소딕 메모리 — 경험에서 학습하기

interface Episode {
  id: string;
  userId: string;
 
  // 시간 정보
  startedAt: number;
  endedAt: number;
  duration: number; // 밀리초
 
  // 맥락 정보
  trigger: string;       // 에피소드를 시작한 사용자 요청
  goal: string;          // 사용자의 목표
  domain: string;        // 주제 영역 (코딩, 분석, 창작 등)
 
  // 진행 과정
  steps: EpisodeStep[];  // 단계별 행동과 결과
  toolsUsed: string[];   // 사용된 도구 목록
 
  // 결과
  outcome: "success" | "partial" | "failure";
  resolution: string;    // 최종 결과 요약
  userSatisfaction?: number; // 사용자 만족도 (추정)
 
  // 학습 포인트
  lessonsLearned: string[];  // 이 에피소드에서 배운 점
  tags: string[];            // 검색을 위한 태그
 
  // 벡터 검색용
  embedding?: number[];      // 에피소드 요약의 임베딩
}
 
interface EpisodeStep {
  index: number;
  action: string;      // 에이전트가 취한 행동
  reasoning: string;   // 행동의 이유
  result: string;      // 행동의 결과
  wasEffective: boolean;
}

function detectEpisodeBoundary(
  currentMessage: Message,
  previousMessages: Message[]
): "new_episode" | "continue" | "end_episode" {
  const signals = {
    // 새 에피소드 시작 신호
    newTopicIndicators: [
      "다른 질문", "새로운 주제", "그건 그렇고",
      "다음으로", "별개의 문제",
    ],
    // 에피소드 종료 신호
    closingIndicators: [
      "감사합니다", "해결됐습니다", "완료",
      "이해했습니다", "좋습니다",
    ],
  };
 
  const content = currentMessage.content.toLowerCase();
 
  // 종료 신호 감지
  if (signals.closingIndicators.some((s) => content.includes(s))) {
    return "end_episode";
  }
 
  // 새 에피소드 신호 감지
  if (signals.newTopicIndicators.some((s) => content.includes(s))) {
    return "new_episode";
  }
 
  // 장시간 공백 후 메시지
  const lastMessage = previousMessages[previousMessages.length - 1];
  if (lastMessage) {
    const timeSinceLast = Date.now() - (lastMessage.timestamp ?? 0);
    if (timeSinceLast > 30 * 60 * 1000) { // 30분 이상 공백
      return "new_episode";
    }
  }
 
  return "continue";
}

async function finalizeEpisode(
  episode: Episode,
  llm: LLMClient,
  embedder: EmbeddingModel,
  episodeDB: VectorDB,
  longTermMemory: LongTermMemory
): Promise<void> {
  // 1. 에피소드 요약 생성
  const summary = await llm.complete({
    messages: [{
      role: "system",
      content: `다음 에피소드를 3-5문장으로 요약하세요.
        사용자의 목표, 핵심 진행 과정, 최종 결과를 포함하세요.`,
    }, {
      role: "user",
      content: JSON.stringify(episode.steps),
    }],
  });
 
  // 2. 교훈 추출
  const lessons = await llm.complete({
    messages: [{
      role: "system",
      content: `이 에피소드에서 배울 수 있는 교훈을 추출하세요.
        유사한 상황에서 참고할 수 있는 구체적인 인사이트를 포함하세요.`,
    }, {
      role: "user",
      content: JSON.stringify({ steps: episode.steps, outcome: episode.outcome }),
    }],
  });
 
  // 3. 임베딩 생성 및 저장
  const embedding = await embedder.embed(summary.content);
 
  await episodeDB.upsert({
    id: episode.id,
    content: summary.content,
    metadata: {
      userId: episode.userId,
      outcome: episode.outcome,
      domain: episode.domain,
      tags: episode.tags,
      lessonsLearned: lessons.content,
      startedAt: episode.startedAt,
    },
    embedding,
  });
 
  // 4. 사실을 장기 메모리로 이관
  const facts = await extractFacts(episode, llm);
  for (const fact of facts) {
    await longTermMemory.store(fact.content, fact.metadata);
  }
}

async function findSimilarEpisodes(
  currentContext: string,
  userId: string,
  episodeDB: VectorDB,
  embedder: EmbeddingModel,
  options: {
    topK?: number;
    minSimilarity?: number;
    outcomeFilter?: "success" | "failure";
  } = {}
): Promise<Episode[]> {
  const { topK = 3, minSimilarity = 0.7, outcomeFilter } = options;
 
  const queryEmbedding = await embedder.embed(currentContext);
 
  const filter: Record<string, unknown> = { userId };
  if (outcomeFilter) {
    filter.outcome = outcomeFilter;
  }
 
  const results = await episodeDB.query({
    vector: queryEmbedding,
    filter,
    topK,
  });
 
  return results.filter((r) => r.similarity >= minSimilarity);
}

async function enrichPromptWithExperience(
  userRequest: string,
  userId: string,
  episodeDB: VectorDB,
  embedder: EmbeddingModel
): Promise<string> {
  // 성공한 유사 에피소드 검색
  const successEpisodes = await findSimilarEpisodes(
    userRequest, userId, episodeDB, embedder,
    { topK: 2, outcomeFilter: "success" }
  );
 
  // 실패한 유사 에피소드 검색
  const failureEpisodes = await findSimilarEpisodes(
    userRequest, userId, episodeDB, embedder,
    { topK: 1, outcomeFilter: "failure" }
  );
 
  let experienceContext = "";
 
  if (successEpisodes.length > 0) {
    experienceContext += "\n[과거 성공 경험]\n";
    for (const ep of successEpisodes) {
      experienceContext += `- ${ep.resolution}\n`;
      experienceContext += `  교훈: ${ep.lessonsLearned.join(", ")}\n`;
    }
  }
 
  if (failureEpisodes.length > 0) {
    experienceContext += "\n[과거 실패 경험 - 주의]\n";
    for (const ep of failureEpisodes) {
      experienceContext += `- ${ep.resolution}\n`;
      experienceContext += `  회피할 점: ${ep.lessonsLearned.join(", ")}\n`;
    }
  }
 
  return experienceContext;
}

[시스템 프롬프트에 주입되는 경험 컨텍스트]
 
과거 유사 경험:
- 3/18: Docker 빌드 실패 디버깅 시, 멀티스테이지 빌드로 전환하여 해결.
  교훈: 의존성 캐싱 레이어를 분리하면 빌드 속도도 개선됨.
 
주의할 과거 실패:
- 3/10: 동일한 유형의 빌드 오류에서 캐시 삭제만 반복하여
  30분을 소비. 근본 원인(베이스 이미지 버전)을 먼저 확인할 것.

interface Pattern {
  id: string;
  description: string;
  confidence: number;     // 패턴의 신뢰도 (발생 빈도 기반)
  episodeIds: string[];   // 근거가 되는 에피소드들
  domain: string;
  actionRecommendation: string;
}
 
async function extractPatterns(
  episodes: Episode[],
  llm: LLMClient
): Promise<Pattern[]> {
  // 동일 도메인의 에피소드를 그룹화
  const domainGroups = groupBy(episodes, (e) => e.domain);
 
  const patterns: Pattern[] = [];
 
  for (const [domain, domainEpisodes] of Object.entries(domainGroups)) {
    if (domainEpisodes.length < 3) continue; // 최소 3개 에피소드 필요
 
    const summaries = domainEpisodes.map((e) => ({
      outcome: e.outcome,
      resolution: e.resolution,
      lessons: e.lessonsLearned,
    }));
 
    const response = await llm.complete({
      messages: [{
        role: "system",
        content: `다음 에피소드들에서 반복되는 패턴을 찾으세요.
          각 패턴에 대해: 설명, 발생 빈도, 권장 행동을 제시하세요.
          최소 3개 에피소드에서 나타나는 패턴만 포함하세요.`,
      }, {
        role: "user",
        content: JSON.stringify(summaries),
      }],
    });
 
    // 파싱 후 patterns 배열에 추가
    const extracted = parsePatterns(response.content, domain, domainEpisodes);
    patterns.push(...extracted);
  }
 
  return patterns;
}

[학습된 행동 패턴]
 
1. 빌드 오류 (신뢰도: 높음, 근거: 5개 에피소드)
   - 캐시 삭제 전 반드시 의존성 버전 충돌을 먼저 확인
   - 에러 메시지의 첫 줄보다 마지막 줄이 근본 원인에 가까움
 
2. API 설계 논의 (신뢰도: 중간, 근거: 3개 에피소드)
   - 사용자는 REST보다 GraphQL을 선호하는 경향
   - 엔드포인트 설계 시 항상 페이지네이션을 먼저 제안

async function detectSimilarSituation(
  currentMessages: Message[],
  userId: string,
  episodeDB: VectorDB,
  embedder: EmbeddingModel
): Promise<{
  isSimilar: boolean;
  relevantEpisodes: Episode[];
  suggestion: string | null;
}> {
  // 현재 대화의 최근 3개 메시지로 맥락 구성
  const recentContext = currentMessages
    .slice(-3)
    .map((m) => m.content)
    .join(" ");
 
  const similar = await findSimilarEpisodes(
    recentContext, userId, episodeDB, embedder,
    { topK: 3, minSimilarity: 0.75 }
  );
 
  if (similar.length === 0) {
    return { isSimilar: false, relevantEpisodes: [], suggestion: null };
  }
 
  // 가장 유사한 에피소드에서 제안 생성
  const topEpisode = similar[0];
  const suggestion = topEpisode.outcome === "failure"
    ? `이전에 유사한 상황에서 문제가 발생했습니다: ${topEpisode.lessonsLearned[0]}`
    : `이전에 유사한 상황을 성공적으로 처리한 경험이 있습니다: ${topEpisode.resolution}`;
 
  return {
    isSimilar: true,
    relevantEpisodes: similar,
    suggestion,
  };
}