RAG 청킹 (Chunking, 문서 분할)
2026.10.03 · 20분
1. 청킹이란?
청킹(Chunking)은 RAG의 인덱싱 단계에서 긴 문서를 검색 단위가 되는 작은 조각(청크, chunk)으로 자르는 일입니다. 검색은 문서가 아닌 청크 단위로 일어나고, LLM에 전달되는 것도 청크입니다.
원본 문서 (40페이지 PDF)
┌──────────────────────────────────────────┐
│ 1. 개요 ... │
│ 2. 출장 규정 ... │
│ 2-1. 교통비 ... │
│ 2-2. 숙박비 ... │
│ 3. 경비 정산 ... │
└──────────────────────────────────────────┘
│ 청킹
▼
┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐
│청크 1│ │청크 2│ │청크 3│ │청크 4│ │ ... │ ← 각각 임베딩되어 저장
└──────┘ └──────┘ └──────┘ └──────┘ └──────┘도서관에 비유하면, 책 한 권을 통째로 꽂아 두면 "숙박비 상한"을 찾기 위해 책 전체를 뒤져야 합니다. 그렇다고 문장 하나하나를 카드로 만들면 "단, 서울은 예외"라는 카드만 보고는 무슨 이야기인지 알 수 없습니다. 청킹은 "찾기 좋은 크기"와 "읽고 이해할 수 있는 크기" 사이에서 균형을 잡는 일입니다.
2. 왜 중요할까?
2-1. 청크가 검색과 생성 양쪽의 단위다
| 단계 | 청크의 역할 | 청크가 나쁘면 |
|---|---|---|
| 임베딩 | 청크 하나 = 벡터 하나 | 여러 주제가 섞인 청크는 벡터가 "평균"이 되어 어느 질문과도 애매하게 가깝다 |
| 검색 | 청크 단위로 순위를 매긴다 | 정답 문장이 있어도 주변 잡음 때문에 순위가 밀린다 |
| 생성 | 검색된 청크만 LLM이 본다 | 청크에 앞뒤 문맥이 없으면 LLM이 잘못 해석한다 |
2-2. 같은 모델, 다른 청킹
질문: "서울 출장 숙박비 상한은?"
원문: "숙박비 상한은 1박 15만원이다. 단, 서울·제주 지역은 예외로 1박 20만원까지 인정한다."
[잘린 청킹]
청크 A: "...숙박비 상한은 1박 15만원이다. 단, 서울·제주 지역은"
청크 B: "예외로 1박 20만원까지 인정한다. 출장 중 식비는..."
→ 청크 A가 검색됨 → "15만원입니다" (오답)
[문단 단위 청킹]
청크: "숙박비 상한은 1박 15만원이다. 단, 서울·제주 지역은 예외로 1박 20만원까지 인정한다."
→ "서울은 예외로 20만원입니다" (정답)임베딩 모델, 벡터 DB, LLM은 그대로 두고 청킹만 바꿔도 정확도가 크게 달라지는 경우가 흔합니다. 그래서 RAG를 개선할 때 청킹부터 손대는 경우가 많습니다.
3. 청크 크기와 overlap
3-1. 크기의 트레이드오프
| 작은 청크 (예: 100~200 토큰) | 큰 청크 (예: 1000 토큰 이상) | |
|---|---|---|
| 검색 정밀도 | 높다. 벡터가 한 가지 의미를 선명하게 담는다 | 낮다. 여러 주제가 섞여 벡터가 흐려진다 |
| 문맥 | 부족하다. "이것", "위 조항" 같은 지시어가 끊긴다 | 충분하다 |
| LLM 입력 | 적은 토큰, 여러 개를 넣어야 한다 | 많은 토큰, 몇 개만 넣어도 꽉 찬다 |
| 잘 맞는 질문 | 사실 하나를 묻는 질문 ("상한이 얼마?") | 설명·요약 질문 ("절차를 설명해 줘") |
출발점으로는 흔히 수백 토큰(예: 256~512)을 쓰고, 평가 세트로 측정하며 조정합니다. 알맞은 크기는 문서와 질문 유형에 따라 다르므로 측정해서 정해야 합니다.
3-2. 임베딩 모델의 입력 한도
임베딩 모델마다 최대 입력 토큰 수가 정해져 있습니다. 이를 넘는 텍스트는 보통 뒷부분이 잘린(truncate) 채 임베딩됩니다. 그러면 청크 뒷부분이 검색에 전혀 반영되지 않는 조용한 버그가 생깁니다. 청크 크기는 사용하는 임베딩 모델의 한도 안으로 잡아야 합니다.
3-3. Overlap
Overlap은 인접한 청크가 앞뒤로 일부 내용을 겹치게 하는 것입니다.
overlap 없음:
[────── 청크 1 ──────][────── 청크 2 ──────][────── 청크 3 ──────]
↑ 여기서 문장이 끊기면 양쪽 모두 불완전
overlap 있음 (예: 10~20%):
[────── 청크 1 ──────]
[────── 청크 2 ──────]
[────── 청크 3 ──────]
└겹침┘ └겹침┘| 장점 | 단점 |
|---|---|
| 경계에 걸친 문장이 적어도 한 청크에는 온전히 들어간다 | 저장 공간과 임베딩 비용이 늘어난다 |
| 문맥 손실이 줄어든다 | 같은 내용이 여러 청크로 중복 검색되어 top-k 자리를 낭비한다 |
Overlap은 경계 문제를 덜어 주는 임시 처방입니다. 문장·문단·섹션 경계에서 자르면 overlap에 덜 기대도 됩니다.
4. 청킹 방법
4-1. 한눈에 보기
| 방법 | 자르는 기준 | 장점 | 단점 |
|---|---|---|---|
| 고정 길이 | 문자/토큰 수 | 구현이 가장 쉽고 예측 가능 | 문장, 단어 중간에서 잘린다 |
| 재귀 문자 분할 | 문단 → 줄 → 문장 → 단어 순으로 시도 | 자연스러운 경계를 최대한 지킨다 | 문서의 의미 구조는 모른다 |
| 문서 구조 기반 | 마크다운 헤더, HTML 태그, 조항 번호 | 섹션 단위로 의미가 온전하다 | 섹션 길이가 들쭉날쭉하다 |
| 시맨틱 청킹 | 문장 간 임베딩 유사도가 떨어지는 지점 | 주제 전환에서 자른다 | 임베딩 비용, 임계값 튜닝 필요 |
4-2. 고정 길이 (Fixed-size)
정해진 길이마다 기계적으로 자릅니다. 문자 수보다 토큰 수 기준이 임베딩 모델 한도와 맞추기 쉽습니다.
import tiktoken
enc = tiktoken.get_encoding("cl100k_base")
def fixed_chunks(text: str, size: int = 400, overlap: int = 50) -> list[str]:
tokens = enc.encode(text)
step = size - overlap
return [enc.decode(tokens[i:i + size]) for i in range(0, len(tokens), step)]토크나이저는 임베딩 모델의 것을 쓰는 것이 정확합니다. 위 예시는 길이를 대략 맞추기 위한 용도입니다.
로그, 채팅 기록처럼 구조가 없고 균질한 텍스트에는 이것만으로도 충분할 때가 있습니다.
4-3. 재귀 문자 분할 (Recursive Character Splitting)
큰 구분자부터 시도하고, 그래도 크면 더 작은 구분자로 내려가는 방식입니다. 가장 널리 쓰이는 기본값입니다.
구분자 우선순위: "\n\n" (문단) → "\n" (줄) → ". " (문장) → " " (단어) → "" (문자)
1. 문단으로 나눈다
2. 크기 이하인 문단은 이웃과 합쳐 청크를 채운다
3. 크기를 넘는 문단만 줄 단위로 다시 나눈다
4. 그래도 크면 문장, 단어 순으로 내려간다def recursive_split(text: str, size: int = 800,
seps=("\n\n", "\n", ". ", " ")) -> list[str]:
if len(text) <= size:
return [text]
if not seps:
return [text[i:i + size] for i in range(0, len(text), size)]
sep, rest = seps[0], seps[1:]
chunks, buf = [], ""
for part in text.split(sep):
if len(part) > size: # 이 조각 자체가 크면 더 작은 구분자로
if buf:
chunks.append(buf)
buf = ""
chunks.extend(recursive_split(part, size, rest))
elif not buf or len(buf) + len(sep) + len(part) <= size:
buf = f"{buf}{sep}{part}" if buf else part
else:
chunks.append(buf)
buf = part
if buf:
chunks.append(buf)
return chunks4-4. 문서 구조 기반 (Document Structure)
문서가 이미 가진 구조(제목, 섹션, 조항)를 경계로 씁니다. 작성자가 이미 의미 단위로 나눠 둔 것을 활용하는 셈입니다.
마크다운 헤더
# 출장 규정 ─┐
## 교통비 │ 청크 1: path = "출장 규정 > 교통비"
KTX 일반실 기준으로... ─┘
## 숙박비 ─┐ 청크 2: path = "출장 규정 > 숙박비"
1박 15만원, 단 서울은... ─┘import re
def split_markdown(md: str) -> list[dict]:
chunks, path, buf = [], [], []
def flush():
body = "\n".join(buf).strip()
if body:
chunks.append({"path": " > ".join(path), "text": body})
buf.clear()
for line in md.splitlines():
m = re.match(r"^(#{1,6})\s+(.*)", line)
if m:
flush()
level = len(m.group(1))
path[:] = path[:level - 1] + [m.group(2).strip()]
else:
buf.append(line)
flush()
return chunks헤더 경로를 메타데이터로 저장하고 임베딩할 때 본문 앞에 붙이면 "숙박비"라는 단어가 본문에 없어도 해당 청크가 검색됩니다.
임베딩 입력: "출장 규정 > 숙박비\n1박 15만원, 단 서울은..."HTML
| 태그 | 활용 |
|---|---|
<h1>~<h6> | 섹션 경계와 경로 |
<p>, <li> | 문단·항목 경계 |
<table> | 표는 별도 청크로 분리 (6장 참고) |
<pre>, <code> | 코드 블록은 자르지 않는다 |
<nav>, <footer>, 광고 영역 | 제거. 모든 페이지에 반복되어 검색을 오염시킨다 |
그 밖의 구조
- 법률·약관: "제3조", "①" 같은 조항 번호
- 코드: 함수·클래스 단위 (AST 파서 활용)
- 슬라이드: 슬라이드 1장 단위
- FAQ: 질문-답변 한 쌍 단위
섹션이 너무 길면 그 안에서 재귀 분할을, 너무 짧으면 이웃 섹션과 합치는 식으로 구조 기반 분할과 재귀 분할을 함께 쓰는 것이 일반적입니다.
4-5. 시맨틱 청킹 (Semantic Chunking)
문장마다 임베딩을 구하고, 인접 문장 사이 유사도가 크게 떨어지는 곳(주제가 바뀌는 곳)에서 자릅니다.
문장: s1 s2 s3 s4 s5 s6 s7
유사도: 0.82 0.79 0.31 0.85 0.80 0.28
↑ ↑
주제 전환 주제 전환
결과: [s1 s2 s3] [s4 s5 s6] [s7]import numpy as np
from sentence_transformers import SentenceTransformer
model = SentenceTransformer("BAAI/bge-m3")
def semantic_chunks(sentences: list[str], percentile: float = 10) -> list[str]:
emb = model.encode(sentences, normalize_embeddings=True)
sims = np.sum(emb[:-1] * emb[1:], axis=1) # 인접 문장 코사인 유사도
threshold = np.percentile(sims, percentile) # 하위 10% 지점을 경계로
chunks, start = [], 0
for i, s in enumerate(sims):
if s < threshold:
chunks.append(" ".join(sentences[start:i + 1]))
start = i + 1
chunks.append(" ".join(sentences[start:]))
return chunks| 장점 | 단점 |
|---|---|
| 구조가 없는 긴 글(회의록, 인터뷰)에서 주제 단위로 나뉜다 | 인덱싱 시 문장마다 임베딩 비용이 든다 |
| 임계값에 따라 결과가 크게 달라진다 | |
| 청크 길이가 들쭉날쭉해 최대 길이 제한을 따로 걸어야 한다 | |
| 문서 구조가 뚜렷한 경우 구조 기반보다 낫다는 보장이 없다 |
시맨틱 청킹이 가장 정교해 보이지만, 구조가 명확한 문서에서는 헤더 기반 분할이 더 싸고 결과도 나은 경우가 많습니다. 평가 세트로 비교한 뒤 선택해야 합니다.
5. 검색 단위와 전달 단위 분리하기
작은 청크는 검색이 정확하고, 큰 청크는 문맥이 풍부합니다. 둘 다 얻으려면 검색할 때와 LLM에 줄 때 다른 크기를 쓰면 됩니다.
5-1. Parent-Child (Small-to-Big)
부모 청크 (섹션, ~1500 토큰) ← LLM에 전달
┌─────────────────────────────────────────────┐
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 자식 1 │ │ 자식 2 │ │ 자식 3 │ ← 임베딩·검색 (~200 토큰)
│ └─────────┘ └─────────┘ └─────────┘ │
└─────────────────────────────────────────────┘
1. 자식 청크로 검색한다 (정밀)
2. 매칭된 자식의 부모 ID를 찾는다
3. 부모 청크를 LLM에 넘긴다 (문맥 풍부)parents = {} # parent_id -> 부모 텍스트
children = [] # {"text": ..., "parent_id": ...}
for pid, section in enumerate(split_markdown(md)):
parents[pid] = section["text"]
for child in recursive_split(section["text"], size=300):
children.append({"text": child, "parent_id": pid})
child_vecs = model.encode([c["text"] for c in children], normalize_embeddings=True)
def retrieve_parents(question: str, k: int = 5) -> list[str]:
q = model.encode([question], normalize_embeddings=True)[0]
top = np.argsort(-(child_vecs @ q))[:k]
seen, result = set(), []
for i in top: # 같은 부모는 한 번만
pid = children[i]["parent_id"]
if pid not in seen:
seen.add(pid)
result.append(parents[pid])
return result5-2. 변형들
| 기법 | 검색 단위 | 전달 단위 |
|---|---|---|
| Parent-Child | 작은 자식 청크 | 부모 섹션 전체 |
| Sentence Window | 문장 1개 | 앞뒤 N문장을 붙인 창 |
| 요약 인덱스 | 문서·섹션 요약문 | 원문 섹션 |
| 가상 질문 인덱스 | LLM이 청크마다 만든 "이 청크가 답할 수 있는 질문" | 원문 청크 |
모두 "찾기 좋은 표현"과 "읽기 좋은 표현"을 따로 저장한다는 원리를 씁니다.
6. 문맥 보강 (Contextual Retrieval)
6-1. 문제: 청크가 자기 문맥을 잃는다
원문: "ACME 주식회사 2024년 2분기 실적 보고서"
...
"매출은 전 분기 대비 3% 증가했다." ← 이 문장만 청크가 됨
질문: "ACME의 2024년 2분기 매출 성장률은?"
청크: "매출은 전 분기 대비 3% 증가했다."
→ 어느 회사? 어느 분기? 청크에 정보가 없어서 검색이 안 된다6-2. 해결: 청크마다 문서 맥락을 붙인다
Anthropic이 2024년 9월 공개한 글 Introducing Contextual Retrieval에서 제안한 방법입니다. 인덱싱할 때 LLM에게 문서 전체와 청크를 주고 이 청크가 문서에서 어떤 위치·맥락인지 짧게 설명하게 한 뒤, 그 설명을 청크 앞에 붙여서 임베딩과 BM25 색인을 모두 만듭니다.
[원래 청크]
"매출은 전 분기 대비 3% 증가했다."
[문맥 보강된 청크]
"이 청크는 ACME 주식회사의 2024년 2분기 실적 보고서 중 매출 실적 부분이다.
매출은 전 분기 대비 3% 증가했다."import anthropic
client = anthropic.Anthropic()
def situate(document: str, chunk: str) -> str:
resp = client.messages.create(
model="claude-haiku-4-5",
max_tokens=150,
messages=[{
"role": "user",
"content": [
{ # 같은 문서의 청크들이 문서 부분을 공유하므로 프롬프트 캐싱
"type": "text",
"text": f"<document>\n{document}\n</document>",
"cache_control": {"type": "ephemeral"},
},
{
"type": "text",
"text": f"<chunk>\n{chunk}\n</chunk>\n"
"이 청크가 위 문서 전체에서 어떤 맥락인지, 검색에 도움이 되도록 "
"한두 문장으로 짧게 설명하세요. 설명만 답하세요.",
},
],
}],
)
return resp.content[0].text.strip()
contextual_chunks = [f"{situate(doc, c)}\n{c}" for c in chunks]
# 이후 contextual_chunks로 임베딩과 BM25 색인을 만든다6-3. 효과와 비용
Anthropic의 글에서는 자체 실험에서 검색 실패율(top-20 기준)이 줄었다고 보고했습니다.
| 구성 | 보고된 검색 실패율 감소 |
|---|---|
| 문맥 보강 임베딩 | 약 35% |
| 문맥 보강 임베딩 + 문맥 보강 BM25 | 약 49% |
| 위 구성 + 리랭킹 | 약 67% |
이 수치는 해당 글의 실험 데이터셋 기준입니다. 우리 데이터에서의 효과는 직접 측정해야 합니다.
| 고려 사항 | 설명 |
|---|---|
| 인덱싱 비용 | 청크마다 LLM 호출이 1번씩 생긴다. 문서 부분을 프롬프트 캐싱하면 크게 줄어든다 |
| 재색인 | 문서가 바뀌면 그 문서의 모든 청크 맥락을 다시 만들어야 한다 |
| 긴 문서 | 문서가 LLM 컨텍스트보다 길면 섹션·요약을 대신 넣어야 한다 |
| 질의 시점 비용 | 없다. 인덱싱 때 한 번만 하면 된다 |
6-4. 더 가벼운 대안
LLM 호출이 부담스럽다면 규칙으로 맥락을 붙이는 것만으로도 상당한 효과가 있습니다.
"[문서: 2024년 2분기 실적 보고서 | 회사: ACME | 섹션: 매출 실적]
매출은 전 분기 대비 3% 증가했다."문서 제목, 헤더 경로, 작성일 같은 메타데이터를 청크 앞에 붙이는 방식입니다. 4-4의 헤더 경로 붙이기와 같은 원리입니다.
비슷한 문제를 다른 방향에서 푸는 Late Chunking(긴 문서를 통째로 임베딩 모델에 넣은 뒤 토큰 임베딩을 청크 구간별로 평균 내는 방식)도 있습니다. 긴 입력을 지원하는 임베딩 모델이 필요합니다.
7. 표와 코드 처리
7-1. 표
표를 단순 텍스트로 추출하면 행과 열의 관계가 사라집니다.
[원본 표]
| 직급 | 숙박비 상한 | 식비 상한 |
|------|-------------|-----------|
| L3 | 12만원 | 3만원 |
| L5 | 18만원 | 5만원 |
[텍스트 추출 결과]
"직급 숙박비 상한 식비 상한 L3 12만원 3만원 L5 18만원 5만원"
→ "L5 식비 상한은?" 에 답하기 어렵다| 방법 | 설명 | 적합한 경우 |
|---|---|---|
| 마크다운/HTML 표로 보존 | 표 구조를 그대로 유지해 하나의 청크로 둔다 | 작은 표 |
| 행 단위 직렬화 | 각 행을 "직급 L5의 숙박비 상한은 18만원, 식비 상한은 5만원이다"처럼 문장으로 | 행마다 독립적인 사실인 표 |
| 헤더 반복 | 큰 표를 나눌 때 각 청크에 열 머리글을 반복해 넣는다 | 행이 많은 표 |
| 표 요약 + 원본 | 요약문으로 검색하고, 원본 표를 LLM에 전달 | 복잡한 표 (5장의 분리 원리) |
| 정형 데이터로 분리 | 표를 DB에 넣고 SQL로 질의 | 숫자 집계가 필요한 표 |
최소한 표가 헤더 없이 중간에서 잘리지는 않게 해야 합니다. PDF에서는 표를 제대로 추출하는 것부터 어려우므로 파서 품질을 먼저 확인해야 합니다.
7-2. 코드
| 원칙 | 이유 |
|---|---|
| 함수·클래스 단위로 자른다 | 함수 중간에서 잘리면 의미가 없다. 언어별 파서(AST)를 쓴다 |
| 코드 블록은 쪼개지 않는다 | 문서 속 코드 펜스 블록을 하나의 단위로 다룬다 |
| 위치 정보를 붙인다 | 파일 경로, 클래스명, 함수 시그니처를 청크 앞에 붙인다 |
| 설명과 함께 둔다 | 코드 앞의 설명 문단을 같은 청크에 포함한다 |
| 키워드 검색을 병행한다 | 함수명, 에러 코드는 벡터 검색보다 키워드 검색이 정확하다 |
[코드 청크 예시]
파일: payments/token.py | 클래스: TokenService | 함수: refresh()
def refresh(self, token_id: str) -> Token:
...8. 청킹 전략 고르기
문서에 구조(헤더, 조항, 섹션)가 있는가?
├─ 예 → 구조 기반 분할 + 너무 긴 섹션은 재귀 분할
│ + 헤더 경로를 청크 앞에 붙인다
└─ 아니오 → 재귀 문자 분할로 시작
└─ 주제가 자주 바뀌는 긴 글이면 시맨틱 청킹을 비교해 본다
검색은 되는데 답에 문맥이 부족한가? → Parent-Child / Sentence Window
청크만 보고는 무슨 이야기인지 모르는가? → 문맥 보강 (메타데이터 → LLM 맥락)
표·코드가 많은가? → 7장의 전용 처리| 상황 | 추천 출발점 |
|---|---|
| 사내 위키, 마크다운 문서 | 헤더 기반 + 헤더 경로 붙이기 |
| 법률, 약관, 규정 | 조항 단위 |
| PDF 보고서 | 레이아웃 인식 파서 → 섹션 기반 + 표 별도 처리 |
| 회의록, 채팅 로그 | 재귀 분할 또는 시맨틱, 화자·날짜 메타데이터 |
| 소스 코드 | 함수·클래스 단위(AST) |
| FAQ | 질문-답변 쌍 하나가 하나의 청크 |
9. 장점과 단점, 흔한 실수
9-1. 방법별 비용과 효과
| 방법 | 구현 난이도 | 인덱싱 비용 | 기대 효과 |
|---|---|---|---|
| 고정 길이 | 매우 낮음 | 낮음 | 기준선 |
| 재귀 분할 | 낮음 | 낮음 | 경계 문제 완화 |
| 구조 기반 | 중간 (파서 필요) | 낮음 | 구조가 있는 문서에서 큰 개선 |
| 시맨틱 | 중간 | 중간 (문장 임베딩) | 데이터에 따라 다름 |
| Parent-Child | 중간 | 중간 (저장 2배) | 정밀도와 문맥 동시 확보 |
| 문맥 보강 (LLM) | 중간 | 높음 (청크당 LLM 호출) | 문맥 손실이 큰 문서에서 큰 개선 |
9-2. 흔한 실수
| 실수 | 결과 |
|---|---|
| 임베딩 모델 한도보다 큰 청크 | 뒷부분이 잘려 검색에 반영되지 않는다 |
| 메타데이터 없이 텍스트만 저장 | 출처 표시, 날짜·권한 필터링 불가 |
| 머리말·꼬리말·목차를 그대로 색인 | 모든 청크에 같은 문구가 섞여 검색을 오염시킨다 |
| 평가 없이 청크 크기 결정 | "느낌상 괜찮은" 설정이 실제로는 나쁠 수 있다 |
| 청킹 방식 변경 후 일부만 재색인 | 서로 다른 방식의 청크가 섞여 품질이 불안정하다 |
10. 핵심 정리
청킹은 문서를 검색 단위로 자르는 일이며, 청크는 임베딩·검색·생성 모두의 단위라서 RAG 품질에 직접 영향을 준다. 작은 청크는 검색이 정밀하지만 문맥이 부족하고, 큰 청크는 문맥은 풍부하지만 벡터가 흐려진다. 고정 길이 → 재귀 문자 분할 → 문서 구조 기반 → 시맨틱 순으로 정교해지지만, 구조가 있는 문서라면 헤더·조항 기반 분할이 가장 싸고 효과적인 경우가 많다. Parent-Child처럼 검색 단위와 전달 단위를 분리하면 정밀도와 문맥을 함께 얻을 수 있고, Contextual Retrieval처럼 청크에 문서 맥락을 붙이면 "이 청크가 무엇에 대한 이야기인지" 모르는 문제를 줄일 수 있다. 표와 코드는 구조를 보존하는 전용 처리가 필요하며, 어떤 전략이든 평가 세트로 측정해서 골라야 한다.