원리 (이론)

• ✅ 벡터 DB 의 정의와 필요성 — 임베딩 저장 + ANN 검색 전용 저장소
• ✅ ANN/인덱스 구조 — HNSW · IVF 가 근사 최근접을 빠르게 해결하는 원리
• ✅ FAISS 가 brute-force 보다 1만 배 빠른 근거 — ANN 알고리즘
• ✅ 인덱스 3종 — Flat · IVF · HNSW 의 정확도/속도/메모리 트레이드오프
• ✅ 청킹의 의의와 sweet spot (chunk_size · overlap)

💡 임베딩(텍스트→벡터·코사인 유사도)은 Day 1(s2·s7)에서 다뤘다. 이번 회차의 주제는 그 벡터를 저장·검색하는 DB 구조다.

실습 (코드)

• ✅ OpenAI Embedding API 직접 호출 + numpy 유사도 계산
• ✅ FAISS 첫 인덱스 — 1만 문서 색인 + 검색 (1ms 이하)
• ✅ LangChain FAISS.from_documents() 단일 호출 추상화
• ✅ 청킹 4종 — Character / Recursive / Token-aware / Semantic
• ✅ 미니 RAG — 문서 → 임베딩 → 검색 → LLM 답변

❌ 키워드 매칭의 한계 4가지

본질

• 키워드 검색은 문자열 일치만 판별
• 의미·맥락·동의어를 인식하지 못함
• 사용자는 동일 의미를 다양한 표현으로 질의

✅ 의미 기반 검색의 동작

사용자 질의: "심장마비 응급처치"
                     ↓
                     ↓ 임베딩
                     ↓
          [0.21, -0.83, 0.15, ..., 0.07]
                     ↓
            벡터 공간에서 가까운 문서 찾기
                     ↓
검색됨: "Cardiac arrest first aid" (영문)
검색됨: "심근경색 응급조치 매뉴얼" (동의어)
검색됨: "Heart attack emergency response"

이를 가능하게 하는 핵심 원리

"의미가 유사한 텍스트는 벡터 공간에서 가깝게 위치한다"

복습 (Day 1 s2·s7) — 요약

"강아지" → [0.21, -0.83, 0.15, ...]
"개"     → [0.20, -0.81, 0.16, ...]   ← 가까움
"자동차" → [-0.55, 0.32, -0.78, ...]  ← 멀리

• 임베딩 = 의미를 N차원 좌표로 표현 (1536d / 3072d)
• 의미가 유사할수록 코사인 유사도가 높다
• 이 원리는 Day 1 에서 다뤘다 → 재설명 생략

핵심 질문 — 그 벡터를 어디에 두나

청크 수천~수백만 개 → 벡터 수천~수백만 개
질문도 벡터 1개

검색 = 질문 벡터와 가장 가까운 문서 벡터 탐색

• 직접 구현하면: 매 질문마다 전체 벡터와 전수 계산 → 수백만 개 규모에서는 비현실적
• 그래서 벡터 DB 가 필요하다 — 다음 슬라이드

🔗 임베딩 모델·차원·코사인 수식·Contrastive 학습은 Day 1 의 범위다. 이번 회차는 "그 벡터를 저장·검색하는 구조"를 다룬다.

두 가지 핵심 역할

1. 저장 — 벡터 + 원본 텍스트 + 메타데이터를 함께 보관
2. 검색 — "가장 가까운 N개"를 효율적으로 찾는 색인(index) 제공

관계형 DB : 행 + B-tree 인덱스 → 정확 일치 빠르게
벡터  DB  : 벡터 + ANN 색인     → 의미 근접 빠르게

전용 저장소가 필요한 이유

• 의미 검색은 "정확히 같은 값"이 아니라 "가장 가까운 값"을 찾는 문제
• B-tree·해시 인덱스로는 해결 불가 → ANN 색인이 필요

ANN — 근사 최근접 이웃 (Approximate NN)

• 완전 탐색(brute-force): 모든 벡터와 거리 계산 → 데이터 증가 시 속도 저하
• ANN: 정확도를 소폭 양보하는 대신 검색 공간을 효율적으로 축소해 수백만 벡터에서도 밀리초 단위로 "거의 최근접" 이웃을 탐색

🎯 정확도 ↔ 속도는 맞교환 관계다. 대규모에서는 ANN 이 사실상 필수이며, 구조는 PART C 에서 상세히 다룬다.

호출 코드

from openai import OpenAI

client = OpenAI()

# 1개 문장
resp = client.embeddings.create(
    model="text-embedding-3-small",
    input="강아지가 공원에서 뛰논다",
)
vec = resp.data[0].embedding
print(f"차원: {len(vec)}")        # 1536
print(f"앞 5개: {vec[:5]}")        # [0.012, -0.045, ...]
print(f"norm: {sum(x*x for x in vec)**0.5:.4f}")
# → 1.0000 (이미 unit-norm)

# 여러 문장 배치 (8192 토큰 한도까지)
resp = client.embeddings.create(
    model="text-embedding-3-small",
    input=["강아지", "고양이", "자동차", "비행기"],
)
vectors = [d.embedding for d in resp.data]

가격 (2026 기준)

💡 dimensions 파라미터: dimensions=512 로 Matryoshka 잘라 쓰기 — 정확도 ~5% 손실로 저장 1/3, 검색 3배 빠름.

두 함수 — embed + cosine_sim

import numpy as np
from openai import OpenAI

client = OpenAI()

def embed(texts: list[str]) -> np.ndarray:
    """문장 리스트를 (N, 1536) 행렬로."""
    resp = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts,
    )
    return np.array(
        [d.embedding for d in resp.data])
    # shape (N, 1536)

def cosine_sim(a, b) -> float:
    """단위 벡터끼리는 dot product = cosine."""
    return float(
        np.dot(a, b) /
        (np.linalg.norm(a) * np.linalg.norm(b)))

실험 + 결과

texts = [
    "강아지가 공원에서 뛰논다",
    "개가 산책 중이다",            # 의미 매우 가까움
    "Dog playing in the park",   # 영문 같은 의미
    "주식 시장이 폭락했다",         # 무관
    "강아지는 정말 정말 정말 귀엽다",# 같은 주제
]
M = embed(texts)
q = M[0]
for i, t in enumerate(texts):
    print(f"{cosine_sim(q, M[i]):.3f}  {t}")

1.000  강아지가 공원에서 뛰논다
0.842  개가 산책 중이다
0.781  Dog playing in the park
0.123  주식 시장이 폭락했다
0.512  강아지는 정말 정말 정말 귀엽다

🎯 관찰 포인트: ① 다국어 → 의미 ② 동의어 ③ 무관한 주제 = 낮은 점수

Brute-force 확장성

복잡도

• 검색: O(N · D) — 모든 벡터와 q 의 내적
• 메모리: O(N · D · 4 bytes) (float32)

ANN (Approximate Nearest Neighbor)

트레이드오프

"정확도를 소폭 양보하고 속도·메모리 1000배를 확보한다."

• 1억 벡터 → brute 50초, FAISS 1~10ms
• 메모리도 PQ 압축으로 1/16
• 운영 환경에서는 사실상 필수

핵심 아이디어

• 모든 벡터를 그래프 노드로 구성
• 인접 벡터끼리 엣지로 연결
• 검색은 그래프를 greedy traversal — 더 가까운 이웃으로 이동

다층 구조 (Hierarchical)

• Layer N (상위): 희소 연결, 장거리 이동 (지하철 노선)
• Layer 0 (하위): 조밀 연결, 미세 탐색 (마을 골목)
• 검색은 상위 계층에서 시작해 점차 하위 계층으로 진행

시간 복잡도

• 색인: O(N · log N · M) — M = 노드당 엣지 수
• 검색: O(log N · ef_search) — ef_search = 후보 풀 크기

튜닝 파라미터

1~2. 데이터 준비 + 색인

import faiss, numpy as np
from openai import OpenAI

client = OpenAI()

# 1. 데이터 준비
docs = [
    "강아지가 공원에서 뛰논다",
    "Dog playing in the park",
    "주식 시장이 폭락했다",
    "Stock market crashed today",
    "강아지는 귀엽다",
]
emb = client.embeddings.create(
    model="text-embedding-3-small", input=docs)
M = np.array([d.embedding for d in emb.data]
            ).astype('float32')
print(M.shape)   # (5, 1536)

# 2. FAISS 인덱스 생성 (내적 = 코사인)
index = faiss.IndexFlatIP(1536)
index.add(M)                          # 1줄로 색인
print(f"색인된 벡터 수: {index.ntotal}")  # 5

인덱스 종류

• IndexFlatIP: 내적 (정규화된 벡터)
• IndexFlatL2: 유클리드 거리 (비정규화)
• 그 외: HNSW, IVF, PQ — 다음 슬라이드

3. 검색 코드

# 3. 검색
query = client.embeddings.create(
    model="text-embedding-3-small",
    input=["강아지 산책"])
q = np.array([query.data[0].embedding]
            ).astype('float32')

D, I = index.search(q, k=3)           # top-3
for rank, (score, idx) in enumerate(zip(D[0], I[0])):
    print(f"#{rank+1}  score={score:.3f}  {docs[idx]}")

출력

#1  score=0.832  강아지가 공원에서 뛰논다
#2  score=0.741  Dog playing in the park
#3  score=0.523  강아지는 귀엽다

D 와 I

Flat vs HNSW 벤치마크 코드

import faiss, numpy as np, time

N, D = 10_000, 1536
np.random.seed(42)
data = np.random.randn(N, D).astype('float32')
faiss.normalize_L2(data)         # 단위 벡터로

# === Flat (정답 기준) ===
flat = faiss.IndexFlatIP(D)
t = time.time(); flat.add(data)
add_flat = time.time() - t
q = data[:1]
t = time.time()
D_flat, I_flat = flat.search(q, 10)
s_flat = time.time() - t

# === HNSW ===
hnsw = faiss.IndexHNSWFlat(D, 32)   # M=32
hnsw.hnsw.efConstruction = 200
hnsw.hnsw.efSearch = 50
t = time.time(); hnsw.add(data)
add_hnsw = time.time() - t
t = time.time()
D_h, I_h = hnsw.search(q, 10)
s_hnsw = time.time() - t

# === Recall@10 ===
recall = len(set(I_flat[0]) & set(I_h[0])) / 10

측정 결과 + 트레이드오프

Flat  add=22ms     search=2.34ms
HNSW  add=1820ms   search=0.18ms
Recall@10 = 0.90

트레이드오프 한 줄

• 색인은 80배 느림 (한 번만)
• 검색은 13배 빠름 (매번)
• 정확도 90%

운영 가이드

색인 + 검색 (3줄)

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_core.documents import Document

# 1. Document 객체 (metadata 포함)
docs = [
    Document(page_content="강아지가 공원에서 뛰논다",
             metadata={"src": "doc1.txt"}),
    Document(page_content="Dog playing in the park",
             metadata={"src": "doc2.txt"}),
    Document(page_content="주식 시장이 폭락했다",
             metadata={"src": "doc3.txt"}),
]

# 2. 임베딩 + FAISS 색인 — 한 줄!
vectorstore = FAISS.from_documents(
    docs,
    OpenAIEmbeddings(model="text-embedding-3-small"))

# 3. 검색 (metadata 함께 반환)
results = vectorstore.similarity_search_with_score(
    "강아지 산책", k=3)
for doc, score in results:
    print(f"score={score:.3f}  "
          f"src={doc.metadata['src']}")

저장·로드 (영속화)

# 디스크 저장
vectorstore.save_local("./faiss_index")

# 다음번에 로드
vectorstore = FAISS.load_local(
    "./faiss_index",
    OpenAIEmbeddings(),
    allow_dangerous_deserialization=True,
    # FAISS 는 pickle 사용
)

LangChain vs raw FAISS

FAISS 로 수행한 작업

• 임베딩 벡터를 인메모리 색인에 적재하고 ANN 검색을 직접 실행 (IndexFlatIP → IndexHNSWFlat)
• 인덱스 타입·ef_search·Recall 트레이드오프를 직접 측정

FAISS 가 직접 처리해야 하는 것

• 영속화 — save_local 수동 직렬화 (pickle)
• 메타데이터 필터 — 래퍼가 후처리로만 지원 → AND/숫자 비교 부담
• 동시 쓰기·삭제 — 단일 프로세스 mutation

💡 4대 DB 성격 비교는 PART A 슬라이드 7 참고. 여기서는 "FAISS 로 구조를 체감한 뒤 Chroma 로 이행"하는 흐름이 핵심이다.

코드 + 실행

from langchain_text_splitters \
    import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
    separators=["\n\n", "\n", "。", ".",
                "?", "!", " ", ""],
    is_separator_regex=False,
)

text = """1장. 인공지능의 역사

인공지능(AI)은 1950년대에 시작되었다. 앨런 튜링은 ...

2장. 머신러닝

머신러닝은 데이터에서 패턴을 학습하는 ...
"""

chunks = splitter.split_text(text)
for i, c in enumerate(chunks):
    print(f"[chunk {i}, {len(c)}자]")
    print(c[:80].replace('\n', ' '), "...")

작동 원리 (재귀)

1. 텍스트를 \n\n 으로 분할 시도
2. 한 조각이 1000자 넘으면 다시 \n 으로 분할
3. 그래도 넘으면 . 으로
4. 결국 또는 글자 단위까지 내려감

파라미터 의미

🎯 chunk_overlap 200자가 핵심 — chunk 경계에 답이 걸쳐 있을 때 검색 정확도 ↑

1. 색인 (한 번만)

from dotenv import load_dotenv
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain_text_splitters \
    import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_community.document_loaders import TextLoader

load_dotenv()

loader = TextLoader("./my_notes.txt", encoding="utf-8")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=800, chunk_overlap=150)
chunks = splitter.split_documents(docs)
print(f"chunk 수: {len(chunks)}")

embeddings = OpenAIEmbeddings(
    model="text-embedding-3-small")
vectorstore = FAISS.from_documents(chunks, embeddings)
vectorstore.save_local("./faiss_idx")

2. 질의 + RAG 체인 (매번)

retriever = vectorstore.as_retriever(
    search_kwargs={"k": 4})

prompt = ChatPromptTemplate.from_messages([
    ("system",
     "다음 문서를 근거로만 답하세요. 모르면 '모릅니다'."),
    ("user", "문서:\n{context}\n\n질문: {question}"),
])

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

def format_docs(docs):
    return "\n\n".join(
        f"[chunk {i+1}] {d.page_content}"
        for i, d in enumerate(docs))

rag_chain = (
    {"context": retriever | format_docs,
     "question": RunnablePassthrough()}
    | prompt | llm | StrOutputParser()
)

# 3. 사용
answer = rag_chain.invoke("이 문서의 핵심 주장은?")
print(answer)

🎯 이 50줄이 Day 2 전체의 기반이다. Session 14~16 은 이를 개선·확장한다.

1단계 — 데이터 준비 (5분)

• 대상 도메인 텍스트/마크다운 1개 (3000자 이상)
• 예시: 학과 노트 / 회사 위키 / 책 챕터 / GitHub README

2단계 — 색인 + 첫 검색 (10분)

# 위 슬라이드의 30~40줄 그대로
chunks = splitter.split_documents(docs)
vectorstore = FAISS.from_documents(chunks, embeddings)

# 직접 retriever 만 호출 (LLM 생략)
results = vectorstore.similarity_search_with_score(
    "질문", k=4)
for d, s in results:
    print(f"score={s:.3f}")
    print(d.page_content[:200])

3단계 — RAG 전체 (LLM 답변까지, 5분)

• 위 슬라이드 코드 그대로
• 대상 도메인 질문 3개로 실험

4단계 — 비교 분석 (5분)

• 동일한 3개 질문을 RAG 없이(llm.invoke(질문))도 실행
• 비교 항목:
• RAG 가 답한 것 / 일반 LLM 이 답하지 못한 것
• RAG 가 출처 없이 부정확하게 답한 것

📤 보고

• chunk_size 를 500 → 1500 → 3000 으로 바꿔가며 검색 품질 변화 관찰
• RAG 의 가치가 가장 두드러진 질문은 무엇인가