pgvector 하이브리드 검색과 RRF 기반 AI 캐릭터 장기 기억 시스템

// memory.service.ts — 메모리 생성 트리거 판단
async shouldGenerateMemory(sessionId: string): Promise<boolean> {
  const lastMemory = await this.prisma.sessionMemory.findFirst({
    where: { sessionId },
    orderBy: { createdAt: 'desc' },
  });

  const since = lastMemory?.messageRangeEnd ?? new Date(0);

  const userMsgCount = await this.prisma.chatMessage.count({
    where: {
      sessionId,
      senderType: 'user',
      createdAt: { gt: since },
    },
  });

  return userMsgCount >= 5;
}

// memory.service.ts — Redis NX 락으로 동시 생성 방지
async generateMemory(sessionId: string, ...): Promise<MemoryGenerationResult> {
  const lockKey = `memory:gen:${sessionId}`;
  const acquired = await this.redis.set(lockKey, '1', { ex: 30, nx: true });
  if (!acquired) return { created: false };

  try {
    // ... 메모리 생성 로직
  } finally {
    await this.redis.del(lockKey); // 완료 후 락 해제
  }
}

// memory.service.ts — Voyage AI 임베딩 생성
private async generateEmbedding(text: string): Promise<number[] | null> {
  try {
    const response = await fetch('https://api.voyageai.com/v1/embeddings', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${this.voyageApiKey}`,
      },
      body: JSON.stringify({
        input: [text],
        model: this.voyageModel, // 'voyage-3-lite'
      }),
    });

    if (!response.ok) {
      this.logger.warn(`Voyage API error: ${response.status}`);
      return null; // 실패 시 null 반환 → 최신순 폴백
    }

    const data = (await response.json()) as {
      data: { embedding: number[] }[];
    };
    return data.data[0].embedding;
  } catch (error) {
    this.logger.warn(`Embedding generation failed: ${error}`);
    return null;
  }
}

// schema.prisma — SessionMemory 모델 (검색 컬럼)
model SessionMemory {
  id                 String   @id @default(uuid())
  sessionId          String   @map("session_id")
  type               String   @default("short_term")
  summary            String   @db.Text
  involvedCharacters String[] @map("involved_characters")
  keyDetails         Json?    @map("key_details") @db.JsonB
  embedding          Unsupported("vector(512)")?    // pgvector 시맨틱 검색
  searchVector       Unsupported("tsvector")?        // 키워드 검색
  // ...
}

// memory.service.ts — 메모리 저장 후 벡터 + tsvector 업데이트
if (this.voyageApiKey) {
  const embedding = await this.generateEmbedding(parsed.summary);
  if (embedding) {
    const vectorStr = `[${embedding.join(',')}]`;
    await this.prisma.$executeRawUnsafe(
      `UPDATE session_memories SET embedding = $1::vector WHERE id = $2`,
      vectorStr,
      memory.id,
    );
  }
}

// 키워드 검색용 tsvector (항상 저장)
await this.prisma.$executeRawUnsafe(
  `UPDATE session_memories SET search_vector = to_tsvector('simple', $1) WHERE id = $2`,
  parsed.summary,
  memory.id,
);

// memory-retrieval.service.ts — 임베딩 불가 시 최신순 폴백
if (!this.voyageApiKey) {
  return this.getRecentMemories(sessionIds, effectiveLimit, characterName);
}

const queryEmbedding = await this.generateEmbedding(query);
if (!queryEmbedding) {
  return this.getRecentMemories(sessionIds, effectiveLimit, characterName);
}

-- 시간 감쇠 가중 코사인 유사도 (반감기 1일)
(1 - (embedding <=> $2::vector))
  * EXP(-0.693 * EXTRACT(EPOCH FROM (NOW() - created_at)) / 86400.0)

// memory-retrieval.service.ts — pgvector 검색
private async getVectorResults(
  sessionIds: string[], vectorStr: string, limit: number, characterName?: string,
): Promise<MemoryResult[]> {
  const scoreSql = `(1 - (embedding <=> $2::vector)) * EXP(-0.693 * EXTRACT(EPOCH FROM (NOW() - created_at)) / 86400.0)`;

  const rows: MemoryResult[] = await this.prisma.$queryRawUnsafe(
    `SELECT id, summary, involved_characters AS "involvedCharacters",
            key_details AS "keyDetails", created_at AS "createdAt"
     FROM session_memories
     WHERE session_id = ANY($1::text[])
     ORDER BY ${scoreSql} DESC
     LIMIT $3`,
    sessionIds, vectorStr, limit,
  );
  return this.decryptMemoryResults(rows);
}

// memory-retrieval.service.ts — tsvector 키워드 검색
private async getTextSearchResults(
  sessionIds: string[], query: string, limit: number, characterName?: string,
): Promise<MemoryResult[]> {
  const tsquery = MemoryRetrievalService.buildPrefixTsquery(query);
  if (!tsquery) return [];

  const rows: MemoryResult[] = await this.prisma.$queryRawUnsafe(
    `SELECT id, summary, involved_characters AS "involvedCharacters",
            key_details AS "keyDetails", created_at AS "createdAt"
     FROM session_memories
     WHERE session_id = ANY($1::text[])
       AND search_vector @@ to_tsquery('simple', $2)
     ORDER BY ts_rank(search_vector, to_tsquery('simple', $2)) DESC
     LIMIT $3`,
    sessionIds, tsquery, limit,
  );
  return this.decryptMemoryResults(rows);
}

// memory-retrieval.service.ts — 한국어 접두사 매칭 tsquery 생성
// "한시우 위스키" → "한시우:* & 위스키:*"
private static buildPrefixTsquery(query: string): string {
  return query
    .trim()
    .replace(/[()&|!<>:*\\."']/g, ' ')
    .split(/\s+/)
    .filter((w) => w.length > 0)
    .map((w) => `${w}:*`)
    .join(' & ');
}

// memory-retrieval.service.ts — RRF 병합
static mergeByRRF(
  vectorResults: MemoryResult[],
  textResults: MemoryResult[],
  limit: number,
  k = 60, // RRF 상수
): MemoryResult[] {
  const scoreMap = new Map<string, { score: number; item: MemoryResult }>();

  // 벡터 검색 결과에 RRF 점수 부여
  for (let i = 0; i < vectorResults.length; i++) {
    const r = vectorResults[i];
    scoreMap.set(r.id, { score: 1 / (k + i), item: r });
  }

  // 키워드 검색 결과의 RRF 점수를 누적 (중복 시 합산 → 양쪽 모두 상위면 점수 ↑)
  for (let i = 0; i < textResults.length; i++) {
    const r = textResults[i];
    const existing = scoreMap.get(r.id);
    if (existing) {
      existing.score += 1 / (k + i); // 이미 있으면 합산
    } else {
      scoreMap.set(r.id, { score: 1 / (k + i), item: r });
    }
  }

  return Array.from(scoreMap.values())
    .sort((a, b) => b.score - a.score)
    .slice(0, limit)
    .map((e) => e.item);
}

// memory-retrieval.service.ts — 토크 모드 크로스 세션 검색
async getRelevantMemories(
  sessionId: string, query: string, limit = 8,
  characterName?: string, isTalk?: boolean, userId?: string, talkRoomId?: string,
): Promise<MemoryResult[]> {
  const effectiveLimit = isTalk ? 12 : limit;

  // Talk 모드: 같은 유저+방의 모든 세션에서 메모리 검색
  const sessionIds =
    isTalk && userId && talkRoomId
      ? await this.getTalkSessionIds(userId, talkRoomId)
      : [sessionId];

  // ... 이후 하이브리드 검색 로직은 동일
}

// prompt-builder.ts — 기억을 프롬프트에 주입
private buildMemoriesSection(): void {
  if (!this.input.memories || this.input.memories.length === 0) return;
  const memoryLines = this.input.memories.map((m) => {
    const relTime = PromptBuilder.relativeTime(m.createdAt); // "2시간 전", "3일 전"
    const involved =
      m.involvedCharacters.length > 0
        ? ` [관련자: 플레이어, ${m.involvedCharacters.join(', ')}]`
        : '';
    let line = `- ${relTime}: ${m.summary}${involved}`;
    if (m.keyDetails && m.keyDetails.length > 0) {
      const details = m.keyDetails.map((d) => {
        if (d.type === 'quote') {
          return `  - 💬 ${d.speaker}: "${d.text}" (${d.context})`;
        }
        return `  - 🎬 ${d.actor}: ${d.text} (${d.context})`;
      });
      line += `\n${details.join('\n')}`;
    }
    return line;
  });
  // ...
}

// memory.service.ts — 장기 메모리 압축 (트랜잭션)
const [longTermMemory] = await this.prisma.$transaction([
  this.prisma.sessionMemory.create({
    data: {
      sessionId,
      type: 'long_term',
      summary: this.encryption.encrypt(parsed.summary),
      involvedCharacters: parsed.involvedCharacters,
      affinitySnapshot: latestSnapshot ?? undefined,
      messageRangeStart: oldest[0].messageRangeStart,
      messageRangeEnd: oldest[oldest.length - 1].messageRangeEnd,
    },
  }),
  this.prisma.sessionMemory.deleteMany({
    where: { id: { in: oldestIds } },
  }),
]);