[Build Your Own X] 나만의 검색 엔진을 직접 만들어보자 — 4단계 실전 튜토리얼

서론: 검색은 모든 AI 서비스의 기반이다

"좋은 AI는 좋은 답변을 만드는 것이 아니라, 좋은 질문에 맞는 정보를 찾는 것에서 시작한다." — Dani (Agent8 기획 파트너)

ChatGPT에게 "우리 회사 내규에서 연차 정책이 뭐야?"라고 물으면 일반적인 답변만 돌아옵니다. 당신의 회사 문서를 검색해서 정확한 답을 찾아주는 것 — 이것이 RAG(Retrieval-Augmented Generation)이고, 그 핵심에 검색 엔진이 있습니다.

이 글은 Build Your Own Chatbot에 이어지는 시리즈 3편입니다.

Step 1: 역인덱스 — 검색의 가장 오래된 비밀

Google이든 Elasticsearch든, 모든 검색 엔진의 기초는 역인덱스(Inverted Index)입니다. "어떤 문서에 어떤 단어가 있는가"를 뒤집어서 "어떤 단어가 어떤 문서에 있는가"로 저장하는 자료구조입니다.

// step1-inverted-index.ts

interface InvertedIndex {
  [term: string]: Set<number>; // 단어 → 문서 ID 집합
}

function tokenize(text: string): string[] {
  return text
    .toLowerCase()
    .replace(/[^a-z0-9가-힣\s]/g, "")
    .split(/\s+/)
    .filter((t) => t.length > 1);
}

function buildIndex(documents: string[]): InvertedIndex {
  const index: InvertedIndex = {};
  documents.forEach((doc, docId) => {
    const tokens = tokenize(doc);
    tokens.forEach((token) => {
      if (!index[token]) index[token] = new Set();
      index[token].add(docId);
    });
  });
  return index;
}

function search(index: InvertedIndex, query: string): number[] {
  const tokens = tokenize(query);
  if (tokens.length === 0) return [];

  // AND 검색: 모든 토큰을 포함하는 문서만 반환
  let result: Set<number> | null = null;
  for (const token of tokens) {
    const docs = index[token] ?? new Set();
    result = result
      ? new Set([...result].filter((id) => docs.has(id)))
      : new Set(docs);
  }
  return [...(result ?? [])];
}

// 사용 예시
const docs = [
  "AI 에이전트는 자율적으로 학습합니다",
  "검색 엔진의 핵심은 역인덱스입니다",
  "AI 검색은 벡터 임베딩을 사용합니다",
];
const index = buildIndex(docs);
log.info(search(index, "AI 검색")); // [0, 2]

30줄도 안 되는 코드로 기본 검색 엔진이 만들어졌습니다. 하지만 이 상태에서는 모든 결과가 동일한 중요도로 반환됩니다.

Step 2: TF-IDF 랭킹 — 중요한 결과를 먼저

검색 결과에 순위를 매기려면 "이 단어가 이 문서에서 얼마나 중요한가"를 계산해야 합니다. TF-IDF(Term Frequency × Inverse Document Frequency)가 바로 이 공식입니다.

// step2-tfidf.ts

function tf(term: string, doc: string[]): number {
  const count = doc.filter((t) => t === term).length;
  return count / doc.length; // 문서 내 출현 빈도
}

function idf(term: string, allDocs: string[][]): number {
  const docsWithTerm = allDocs.filter((doc) => doc.includes(term)).length;
  if (docsWithTerm === 0) return 0;
  return Math.log(allDocs.length / docsWithTerm); // 희소할수록 높은 값
}

function tfidf(term: string, doc: string[], allDocs: string[][]): number {
  return tf(term, doc) * idf(term, allDocs);
}

function rankedSearch(
  query: string,
  documents: string[]
): { docId: number; score: number }[] {
  const tokenizedDocs = documents.map(tokenize);
  const queryTokens = tokenize(query);

  return documents
    .map((_, docId) => {
      const score = queryTokens.reduce(
        (sum, term) => sum + tfidf(term, tokenizedDocs[docId], tokenizedDocs),
        0
      );
      return { docId, score };
    })
    .filter((r) => r.score > 0)
    .sort((a, b) => b.score - a.score);
}

🔧 Kai (개발 파트너) 코멘터리: "TF-IDF는 1970년대에 만들어진 알고리즘이지만, 여전히 Elasticsearch의 기본 랭킹에 사용됩니다. '오래된 것 = 나쁜 것'이 아닙니다. 원리를 이해하면 최신 벡터 검색이 왜 등장했는지도 자연스럽게 이해됩니다."

Step 3: 벡터 검색 — 의미로 찾기

TF-IDF는 단어가 일치해야만 검색됩니다. "강아지"를 검색하면 "개"가 포함된 문서는 못 찾습니다. 벡터 검색은 의미적 유사도로 검색합니다.

// step3-vector-search.ts
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

interface VectorDocument {
  id: string;
  content: string;
  embedding: number[];
}

// 텍스트를 벡터로 변환
async function embed(text: string): Promise<number[]> {
  const response = await ai.models.embedContent({
    model: "text-embedding-004",
    contents: text,
  });
  return response.embeddings?.[0]?.values ?? [];
}

// 코사인 유사도 계산
function cosineSimilarity(a: number[], b: number[]): number {
  let dot = 0, magA = 0, magB = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i];
    magA += a[i] * a[i];
    magB += b[i] * b[i];
  }
  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
}

// 시맨틱 검색
async function semanticSearch(
  query: string,
  documents: VectorDocument[],
  topK = 3
) {
  const queryEmbed = await embed(query);
  return documents
    .map((doc) => ({
      ...doc,
      score: cosineSimilarity(queryEmbed, doc.embedding),
    }))
    .sort((a, b) => b.score - a.score)
    .slice(0, topK);
}

이제 "연차 규정"을 검색하면 "휴가 정책", "유급 휴일"이 포함된 문서도 찾아냅니다. 의미를 이해하는 검색이 완성되었습니다.

Step 4: RAG 통합 — 검색 + AI = 지식 에이전트

마지막 단계입니다. 벡터 검색으로 찾은 문서를 LLM의 컨텍스트에 주입하면, 당신의 데이터 기반으로 정확하게 답변하는 AI가 완성됩니다.

// step4-rag-integration.ts

async function ragAnswer(
  question: string,
  knowledgeBase: VectorDocument[]
) {
  // 1. 관련 문서 검색
  const relevant = await semanticSearch(question, knowledgeBase, 3);

  // 2. 검색 결과가 없으면 일반 답변
  if (relevant.length === 0 || relevant[0].score < 0.5) {
    return ask(question); // fallback to general LLM
  }

  // 3. 검색 결과를 컨텍스트로 주입
  const context = relevant
    .map((d, i) => `[문서 ${i + 1}] (관련도: ${(d.score * 100).toFixed(1)}%)\n${d.content}`)
    .join("\n\n");

  const prompt = `
다음 문서를 기반으로 질문에 정확하게 답변하세요.
문서에 없는 내용은 "문서에서 확인할 수 없습니다"라고 답하세요.

[참고 문서]
${context}

[질문] ${question}
`;

  return ask(prompt);
}

// 사용 예시
const answer = await ragAnswer(
  "우리 회사 연차 정책은?",
  companyDocuments // 사전에 임베딩된 회사 문서들
);

🔒 Rex (감사 파트너) 코멘터리: "RAG에서 가장 중요한 보안 원칙은 접근 권한 검증입니다. 검색 결과에 사용자가 볼 수 없는 기밀 문서가 포함되면 안 됩니다. 문서 임베딩 시점에 접근 권한 메타데이터를 함께 저장하고, 검색 시 필터링하는 것이 필수입니다."

📋 Hana (비서 파트너) 코멘터리: "실무에서 RAG의 가장 큰 장점은 환각(Hallucination) 감소입니다. LLM이 없는 정보를 만들어내는 문제가 RAG로 검증 가능한 문서 기반 답변을 제공하면서 크게 줄어듭니다."

결론: 검색을 이해하면 AI를 이해한다

4단계를 거치며 우리는 검색의 진화를 직접 경험했습니다:

1. 역인덱스 — 단어 매칭의 기초 (1970s)
2. TF-IDF — 중요도 기반 랭킹 (1970s~)
3. 벡터 검색 — 의미 기반 시맨틱 검색 (2020s)
4. RAG 통합 — 검색 + 생성 AI의 결합

Agent8의 지식팩 기능은 바로 이 RAG 파이프라인 위에 구축되어 있습니다. 업종별·스킬별 전문 문서를 벡터화하여, 8파트너가 당신의 비즈니스 맥락에 맞는 정확한 답변을 제공합니다.

다음 편: "나만의 Discord 봇 만들기" — 외부 플랫폼과 AI를 연결하는 방법을 다룹니다.