에이전트·RAG

AGENT / 16번째 글

RAG 청킹 전략 완전 정복: 문서를 어떻게 나눠야 하는가

RAG 성능을 결정짓는 핵심 요소인 청킹 전략을 완전히 이해한다. 고정 크기, 재귀적, 시맨틱, 문장 단위 청킹의 차이와 청크 크기·오버랩 설정 방법, 문서 유형별 최적 전략을 한국어로 완전 해설한다.

PALDYN Team34 MIN READ

지난 글에서 RAG의 구조를 Naive·Advanced·Modular 세 세대로 훑고, 인덱싱과 쿼리 두 파이프라인이 검색 품질을 어디서 나눠 갖는지까지 봤다. 그 글은 마지막에 숙제를 하나 남겼다. 40만 자짜리 문서에서 프롬프트에 들어가는 2,000자를 골라내는 것이 RAG의 일이라면, 고를 대상인 조각 자체는 어떻게 만드는가다. 재작성도 하이브리드 검색도 재순위도 이미 만들어진 조각 중에서 고르는 방법일 뿐이라, 조각이 잘못 만들어져 있으면 그 위에서 아무리 잘 골라도 소용이 없다.

문서를 검색 단위로 자르는 이 일을 청킹(chunking)이라 하고, 잘린 조각 하나를 청크라 부른다. 청크는 RAG에서 세 번 쓰인다. 색인할 때 임베딩 모델이 청크 하나를 벡터 하나로 바꾸고, 검색할 때 질문의 벡터와 겨루는 것도 청크의 벡터이며, 마지막에 LLM이 읽는 근거도 청크의 글자다. 그러니 청크를 어떻게 자르느냐는 임베딩 모델이 무엇을 요약하는지, 검색이 무엇을 찾아오는지, 모델이 무엇을 읽는지를 한꺼번에 정한다. 「RAG 품질의 절반은 청킹에서 정해진다」는 말이 현장에서 자주 도는 것도 그래서다.

이 글은 조각의 크기와 겹침부터 정하고, 자르는 방법 넷(고정 크기·재귀 분할·의미 기반·구조 기반)을 차례로 본 뒤, 찾는 단위와 넘기는 단위를 가르는 부모-자식 청킹으로 가서, 고른 전략을 무엇으로 재는지로 끝난다.

조각 크기

두 힘의 줄다리기

LLM에게 문서 전체를 한 번에 넣으면 되지 않느냐는 의문이 먼저 든다. 막는 것이 둘이고, 둘이 크기를 서로 반대 방향으로 민다.

하나는 컨텍스트 창, 곧 모델이 한 번에 읽을 수 있는 토큰 수의 한계다. 128K 토큰 창을 가진 모델이면 한국어로 대략 10만 자 안팎을 넣을 수 있다. 문서 한 권은 들어가도 수만 건짜리 사내 지식베이스는 안 들어가고, 들어가는 만큼이라도 길게 넣으면 비용과 응답 시간이 길이에 비례해 는다. 이 힘은 청크를 작게, 그리고 적게 넣으라고 민다.

다른 하나는 임베딩 정밀도다. 임베딩 모델은 청크의 글자가 몇이든 고정된 길이의 벡터 하나를 돌려준다. 긴 글을 벡터 하나로 줄이면 그 안의 여러 주제가 평균처럼 섞여, 어느 한 세부를 묻는 질문과도 또렷하게 가까워지지 않는다. 그렇다고 너무 작게 자르면 반대 문제가 생긴다 — 「15일」이라는 숫자만 든 조각은 그것이 무엇의 15일인지를 벡터에도 글자에도 담지 못한다. 작은 청크는 정밀하지만 맥락이 없고, 큰 청크는 맥락이 있지만 흐리다. 크기를 정한다는 것은 이 두 힘이 만나는 자리를 고르는 일이다.

400~600 토큰

실무에서 출발점으로 가장 많이 쓰는 값은 청크당 400600 토큰이다. 이 값은 법칙이 아니라 경험칙이고, 근거는 두 가지 관찰이 겹치는 데 있다. 많은 검색용 임베딩 모델이 문단 몇 개 길이의 짧은 글을 질문과 짝지어 학습했기 때문에, 그보다 훨씬 긴 입력을 넣으면 받을 수는 있어도 학습 때 보던 모양과 멀어진다. 그리고 400600 토큰은 한국어로 문단 두셋, 사람이 「이 대목」이라고 가리킬 만한 덩어리라서 질문 하나에 답 하나가 대개 그 안에 들어간다.

모델이 받을 수 있는 최대 입력 길이와 잘 다루는 길이는 다르다는 점을 같이 기억해 둔다. 8K 토큰까지 받는 임베딩 모델이 있어도, 8K짜리 청크의 벡터가 그만큼 정확하다는 뜻은 아니다. 그래서 크기는 모델의 한계가 아니라 질문의 모양에서 거꾸로 정하는 편이 낫다. 답이 한두 문장인 FAQ면 작게, 여러 문단을 엮어야 하는 분석 질문이면 크게 간다.

청크 크기 성격 맞는 질문
128~256 토큰 매우 정밀하고 맥락이 모자람 FAQ, 단답형
256~512 토큰 균형 대부분의 범용 RAG
512~1,024 토큰 맥락이 넉넉하고 정밀도가 낮음 장문 분석, 요약
1,024 토큰 이상 절 단위로 거시적 문서 분류, 개요 검색

세 크기로 따라가기

사내 취업규칙의 연차 조항을 예로 같은 질문을 세 크기에 던져 본다. 조항은 「입사 1년 뒤 15일을 준다」로 시작해 「3년 이상 근속하면 2년마다 1일을 더한다」로 이어지고, 그 아래에 미사용 연차의 보상, 이어서 병가와 경조사 휴가가 온다. 질문은 「3년 근속하면 연차가 며칠인가」다.

128 토큰으로 자르면 기본 15일 문장과 가산 문장이 서로 다른 청크로 갈라지기 쉽다. 검색은 「근속」이라는 낱말이 겹치는 가산 문장 쪽을 잘 찾지만, 그 청크에는 기본값이 없어서 모델이 15일을 모른 채 답하거나 엉뚱한 숫자를 지어낸다. 512 토큰이면 연차 조항 전체가 한 청크에 들어가고, 이 청크의 벡터는 「연차」라는 주제 하나로 또렷하다. 질문과 가장 가까운 청크로 올라오고 모델도 두 문장을 함께 읽는다. 1,024 토큰이면 연차와 병가와 경조사가 한 청크에 섞인다. 답은 그 안에 있지만 벡터가 「휴가 전반」으로 흐려져, 경조사만 다룬 다른 청크에 순위를 밀리는 일이 생긴다. 올라오더라도 모델은 무관한 문단 둘을 함께 읽어야 한다.

실제로 어느 쪽이 이기는지는 문서와 임베딩 모델마다 다르다. 다만 작게 자르면 답이 둘로 쪼개지고 크게 자르면 답이 남의 글에 묻힌다는 방향은 어디서나 같고, 그 방향을 알고 있어야 뒤에서 잴 때 무엇을 볼지 안다.

오버랩

경계에서 잘린 문장

어떤 방법으로 자르든 정할 값이 둘 있다. chunk_size는 청크 하나의 최대 크기이고, chunk_overlap은 이웃한 두 청크가 함께 갖는 길이다. 겹침이 필요한 이유는 경계 때문이다.

「미사용 연차는 다음 해 3월까지 사용하지 않으면 통상임금으로 보상한다」라는 문장이 정확히 청크 경계에 걸렸다고 하자. 앞 청크는 「미사용 연차는 다음 해 3월까지」로 끝나고 뒤 청크는 「사용하지 않으면 통상임금으로 보상한다」로 시작한다. 앞 청크만 읽으면 기한은 있는데 결과가 없고, 뒤 청크만 읽으면 무엇을 보상하는지가 없다. 두 청크 어디에도 문장이 온전히 없으니, 「연차 보상」을 묻는 질문에 어느 쪽이 올라와도 답이 반쪽이다. 오버랩은 경계 앞쪽 일부를 다음 청크 머리에 한 번 더 넣어, 경계에 걸린 문장이 적어도 한쪽에는 통째로 남게 하는 장치다.

청크 오버랩 시각화

권장값과 색인 크기

흔히 쓰는 값은 청크 크기의 1020%다. 500자 청크라면 50100자를 겹친다. 이 값이 공짜가 아니라는 것은 간단히 셈해 보면 보인다. 겹침이 있으면 청크가 다음 청크로 넘어갈 때 실제로 나아가는 거리가 chunk_size - chunk_overlap이 된다. 40만 자 문서를 500자로 겹침 없이 자르면 청크가 800개다. 50자를 겹치면 한 번에 450자씩 나아가 약 889개, 100자를 겹치면 400자씩 나아가 1,000개가 된다. 겹침 20%가 색인을 25% 키우는 셈이고, 임베딩 호출 수와 벡터 저장 공간과 재색인 시간이 함께 그만큼 는다.

겹침이 너무 크면 또 다른 문제가 생긴다. 이웃 청크가 내용의 상당 부분을 공유하므로, 검색 상위 다섯 자리를 거의 같은 글자를 가진 청크 둘셋이 나눠 먹는다. 다섯 개를 가져왔는데 실제로 다른 정보는 셋뿐인 셈이다.

오버랩이 못 고치는 것

겹침은 경계 바로 옆의 문제만 고친다. 문서 첫머리에 적힌 「이 규정은 2026년 1월부터 정규직에게만 적용한다」라는 문장은 수천 자 뒤의 연차 조항 청크에 어떤 겹침으로도 닿지 않는다. 표지의 문서 제목, 목차, 절 앞머리의 전제처럼 멀리 떨어진 맥락이 필요한 청크가 생각보다 많다. 이 문제는 크기나 겹침이 아니라 다른 장치가 맡는다 — 뒤에서 볼 구조 기반 분할이 헤딩을 메타데이터로 남기고, 부모-자식 청킹이 넘기는 단위를 키운다. 청크마다 출처 문장을 붙여 두는 방법도 있는데, 그건 이웃 글들이 따로 다룬다.

고정 크기와 재귀 분할

청킹 전략 비교

고정 크기 청킹

가장 단순한 방법은 정한 글자 수나 토큰 수마다 기계적으로 자르는 것이다. LangChain의 CharacterTextSplitter는 구분자 하나로 글을 먼저 나눈 뒤, 그 조각들을 크기 한도까지 이어 붙여 청크를 만든다.

from langchain_text_splitters import CharacterTextSplitter

splitter = CharacterTextSplitter(
    separator="\n",        # 이 구분자 기준으로 분할
    chunk_size=500,        # 최대 500자
    chunk_overlap=50,      # 50자 오버랩
    length_function=len,   # 문자 수 기준
)

chunks = splitter.split_text(text)

이 방식은 문단과 문장을 모른다. 구분자가 줄바꿈 하나뿐이면 줄바꿈 없이 길게 이어진 문단은 통째로 한도를 넘는 덩어리가 되고, 반대로 짧은 줄이 많은 글은 줄 중간이 아니라 줄 단위로 이어 붙다가 한도 근처에서 문단 한가운데를 끊는다. 로그 파일이나 한 줄이 한 기록인 데이터처럼 모든 줄이 같은 무게인 글에는 이 단순함이 오히려 장점이지만, 사람이 쓴 문서에는 반쪽 문장이 남는다.

재귀 분할

그 문제를 줄인 것이 재귀 분할이고, RecursiveCharacterTextSplitter가 그 구현이다. 실무에서 가장 많이 쓰는 기본값이기도 하다. 구분자를 하나가 아니라 우선순위 목록으로 받는다. 먼저 가장 큰 단위인 빈 줄(\n\n, 곧 문단 경계)로 나눠 보고, 그렇게 나눈 조각 중 아직 한도보다 큰 것만 다음 구분자인 줄바꿈으로 다시 나누고, 그래도 크면 그다음 구분자로 내려간다. 「재귀」라는 이름이 이 되풀이에서 왔다. 결과는 한도를 넘지 않는 범위에서 가능한 한 큰 단위를 지킨 청크다.

라이브러리의 기본 목록은 ["\n\n", "\n", " ", ""]로 문단 → 줄 → 공백 → 글자 순이다. 문장 끝 마침표는 기본 목록에 없으므로, 문장 경계를 살리고 싶으면 아래처럼 직접 넣어야 한다.

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    separators=["\n\n", "\n", ". ", ", ", " ", ""],
    chunk_size=500,
    chunk_overlap=50,
    length_function=len,
)

크기를 글자가 아니라 토큰으로 재고 싶으면 length_function에 토크나이저로 토큰 수를 세는 함수를 넘기면 된다. 임베딩 모델의 입력 한도는 토큰으로 적혀 있으므로, 한도에 바짝 붙여 쓸 때는 토큰으로 재는 편이 안전하다.

한국어 구분자

영문 기본값을 한국어 문서에 그대로 쓰면 어긋나는 자리가 있다. 한국어 문장은 대개 「다.」·「요.」로 끝나고 그 뒤에 공백이 오므로 ". " 하나로도 상당 부분 잡히지만, 문장 끝에 물음표나 느낌표가 오는 글, 「」나 따옴표로 문장이 닫히는 글, 줄바꿈 없이 문장을 이어 쓴 PDF 추출본에서는 문장 경계가 마침표 목록에 안 걸린다. 그러면 분할기가 곧장 공백 단계로 내려가 어절 사이를 끊고, 그 결과 문장 중간에서 잘린 청크가 다시 생긴다.

고치는 방법은 구분자 목록에 그 문서가 실제로 쓰는 문장 끝 표지("? "·"! "·"다. " 같은 것)를 공백보다 앞에 넣는 것이다. 정규식으로 문장 끝을 찾아 먼저 문장 단위로 나눈 뒤 이어 붙이는 방법도 있다. 어느 쪽이든 목록을 바꾼 뒤에는 청크 몇십 개를 직접 열어 끝이 어디서 끊겼는지 보는 것이 가장 빠른 확인이다.

의미 기반 분할

경계를 찾는 절차

글자 수가 아니라 내용이 바뀌는 자리에서 자르자는 것이 의미 기반 분할(semantic chunking)이다. 절차는 이렇다. 글을 문장 단위로 나누고, 문장마다 임베딩을 만든다. 그다음 이웃한 두 문장의 벡터가 얼마나 가까운지를 코사인 유사도로 잰다. 같은 주제를 이어 말하는 문장끼리는 유사도가 높고, 주제가 바뀌는 자리에서는 뚝 떨어진다. 그 떨어지는 지점들을 청크 경계로 삼는다.

from langchain_experimental.text_splitter import SemanticChunker
from langchain_openai import OpenAIEmbeddings

semantic_splitter = SemanticChunker(
    embeddings=OpenAIEmbeddings(model="text-embedding-3-small"),
    breakpoint_threshold_type="percentile",
    breakpoint_threshold_amount=95,
)
semantic_chunks = semantic_splitter.split_text(text)

SemanticChunker는 실험 기능을 모은 langchain_experimental 패키지에 있다. 구현에 따라 문장 하나가 아니라 앞뒤 문장 몇 개를 묶어 임베딩해 흔들림을 줄이기도 한다.

임계값

얼마나 떨어져야 경계로 볼지가 임계값이다. 절대값으로 잡는 방법(「유사도가 0.7 아래면 자른다」)은 단순하지만, 임베딩 모델마다 유사도가 퍼지는 범위가 달라서 같은 0.7이 어떤 모델에서는 거의 모든 자리를, 다른 모델에서는 거의 아무 자리도 가리키지 않는다. 그래서 흔히 쓰는 쪽은 상대값이다. 위 코드의 percentile은 그 문서에서 나온 이웃 간 거리 가운데 상위 5%에 드는 큰 낙차에서만 자르라는 뜻이다. 표준편차나 사분위 범위를 기준으로 삼는 방식도 같은 생각이다.

상대값에도 대가가 있다. 문서 안에서의 상대 순위로 정하므로, 주제가 하나뿐인 짧은 문서도 상위 5%만큼은 억지로 잘리고, 주제가 스무 번 바뀌는 긴 문서도 같은 비율만큼만 잘린다. 문서 길이와 성격이 크게 다른 저장소라면 문서 종류마다 임계값을 따로 두는 편이 낫다.

길이 후처리와 비용

의미로 자르면 청크 길이가 들쭉날쭉해진다. 주제가 길게 이어지는 대목은 수천 토큰짜리 청크가 되어 임베딩 모델의 입력 한도를 넘거나 앞 절에서 본 흐린 벡터가 되고, 짧은 전환이 잦은 대목은 한두 문장짜리 조각이 된다. 그래서 의미 기반 분할 뒤에는 거의 언제나 후처리가 붙는다 — 한도를 넘는 청크는 재귀 분할로 다시 자르고, 너무 짧은 청크는 이웃에 붙인다. 결국 크기 규칙을 버린 것이 아니라 경계를 고르는 첫 단계만 바꾼 셈이다.

비용도 따진다. 문장마다 임베딩을 만들어야 하므로, 색인 때 청크 수가 아니라 문장 수만큼 임베딩 호출이 붙는다. 청크 하나에 문장이 스무 개 든다면 대략 스무 배의 호출이다. 그리고 그 결과는 색인이 끝나면 버려진다. 법률·의학 문서처럼 주제 전환이 또렷하고 경계 하나가 답을 가르는 곳에서는 값을 할 수 있지만, 일반 사내 문서에서는 재귀 분할과 비교해 재 본 뒤에 고르는 것이 순서다.

구조 기반 분할

헤더 분할과 메타데이터

마크다운·HTML·코드처럼 글쓴이가 이미 구조를 표시해 둔 문서는 그 구조를 따라 자르면 된다. 마크다운이라면 #·##·### 헤더가 절의 경계다.

from langchain_text_splitters import MarkdownHeaderTextSplitter

md_splitter = MarkdownHeaderTextSplitter(
    headers_to_split_on=[("#", "H1"), ("##", "H2"), ("###", "H3")],
    strip_headers=False,
)
md_chunks = md_splitter.split_text(markdown_doc)
# chunk.metadata → {'H1': 'RAG 가이드', 'H2': '구현 방법', 'H3': '인덱싱'}

이 방식의 가장 큰 값은 잘린 자리보다 남는 것에 있다. 청크마다 자기가 속한 헤딩들이 메타데이터로 붙는다. 그러면 검색할 때 「3장 안에서만 찾아라」 같은 필터를 걸 수 있고, 답변에는 「RAG 가이드 > 구현 방법 > 인덱싱」처럼 구체적인 출처를 적을 수 있다. 앞에서 오버랩으로 못 고친다고 한 먼 맥락 — 이 청크가 어느 문서의 어느 절인가 — 이 여기서 해결된다.

절 길이의 편차

헤딩으로만 자르면 절의 길이가 곧 청크의 길이가 된다. 사람이 쓴 문서의 절은 한 문장짜리부터 3,000자짜리까지 제각각이라, 한 저장소 안에 그 모든 길이가 섞인다. 한 문장짜리 청크는 맥락이 없고 3,000자짜리는 벡터가 흐리니, 첫 절에서 피하려던 두 극단이 같이 돌아온다.

그래서 헤더 분할은 대개 재귀 분할과 짝을 이룬다. 먼저 헤딩으로 절을 가르고, 크기 한도를 넘는 절만 재귀 분할로 다시 나누며, 너무 짧은 절은 위 절이나 이웃 절에 붙인다. 다시 나눈 조각들도 원래 절의 헤딩 메타데이터를 그대로 물려받으므로 출처는 잃지 않는다.

코드와 PDF

소스 코드는 함수와 클래스의 경계로 자르는 것이 자연스럽다. 함수 한가운데서 자른 조각은 시그니처 없는 몸통이나 몸통 없는 시그니처가 되어 쓸모가 없다. RecursiveCharacterTextSplitter는 언어별 구분자 목록을 미리 갖고 있어서, 파이썬이라면 class·def 같은 정의 앞을 먼저 경계로 시도한다.

PDF는 사정이 다르다. 파일에 남은 것은 글자를 어느 좌표에 그릴지의 목록이고 헤딩이라는 표시가 없어서, 텍스트만 뽑으면 구조 기반 분할이 기댈 것이 통째로 사라진다. 헤딩을 되살려 내는 일 자체와 그 값어치는 PDF 파싱을 다룬 글이 맡으므로 여기서는 「PDF는 파싱 단계에서 구조를 살려야 이 전략을 쓸 수 있다」는 조건만 적어 둔다.

부모-자식 청킹

두 크기의 구조

지금까지는 청크 하나가 두 가지 일, 곧 벡터가 되어 질문과 겨루는 일과 모델에게 읽히는 일을 다 했다. 첫 절의 줄다리기는 결국 한 크기로 두 일을 다 하려니 생긴 것이다. 부모-자식 청킹은 그 두 일을 가른다. 문서를 먼저 큰 덩어리인 부모로 자르고, 부모마다 다시 작은 자식으로 자른다. 벡터 DB에는 자식만 넣고, 부모는 별도 문서 저장소에 id로 둔다. 검색은 작은 자식으로 정밀하게 하고, 걸린 자식의 부모를 찾아 그 큰 덩어리를 모델에게 넘긴다.

부모-자식 청킹: 찾는 단위와 넘기는 단위

from langchain_classic.retrievers import ParentDocumentRetriever
from langchain_core.stores import InMemoryStore
from langchain_text_splitters import RecursiveCharacterTextSplitter

parent_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=200)
child_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=30)

retriever = ParentDocumentRetriever(
    vectorstore=vectorstore,      # 자식 벡터
    docstore=InMemoryStore(),     # 부모 원문
    child_splitter=child_splitter,
    parent_splitter=parent_splitter,
)
retriever.add_documents(documents)
results = retriever.invoke("연차 휴가 정책")  # 자식으로 찾고 부모를 돌려준다

LangChain 1.0 이후 이 검색기는 본 패키지가 아니라 langchain_classic에 있다.

크기 짝짓기

위 예제는 자식 300자, 부모 2,000자로 비율이 대략 1 대 7이다. 자식 크기는 앞에서 본 「질문 하나에 답 하나」의 단위, 곧 정밀하게 겨룰 수 있는 크기로 정하고, 부모 크기는 그 답을 이해하는 데 필요한 맥락의 범위로 정한다. 연차 예라면 자식은 가산 규칙 한 문장 언저리, 부모는 연차 조항 전체다.

비율이 커질수록 둘의 성격이 갈린다. 자식을 더 작게 하면 검색은 더 날카로워지지만 한 부모에 자식이 수십 개 달려, 같은 부모의 자식 여럿이 검색 상위를 함께 차지한다. 그러면 상위 다섯 개가 사실상 부모 하나로 모여 다른 문서가 들어설 자리가 없다. 부모를 더 크게 하면 맥락은 넉넉해지지만 부모 안의 대부분이 질문과 무관한 글이 된다. 부모를 아예 문서 전체로 두는 설정도 가능한데, 그건 문서가 짧을 때만 맞는다.

문맥 예산

부모를 통째로 넘기면 모델이 읽는 양이 크게 는다는 점을 셈해 둔다. 자식 300자를 다섯 개 넘기면 1,500자다. 같은 다섯 개의 부모를 넘기면 최대 2,000 × 5 = 10,000자, 거의 일곱 배다. 실제로는 걸린 자식 둘이 같은 부모를 가리키는 일이 잦아 부모를 중복 없이 모으면 그보다 줄지만, 넘기는 개수를 자식 기준으로 정해 둔 채 부모로 바꾸면 프롬프트가 갑자기 몇 배가 되는 것은 흔한 사고다.

그래서 부모-자식 청킹을 쓸 때는 「몇 개를 넘기는가」를 다시 정한다. 부모 기준으로 두세 개면 충분한 경우가 많고, 컨텍스트 예산을 글자 수로 정해 두고 그 안에 들어갈 때까지만 부모를 채우는 방식도 있다. 정밀도와 맥락을 둘 다 얻는 대신, 그 값을 토큰으로 치른다는 사실을 잊지 않으면 된다.

청킹 품질 측정

세 길이 지표

전략을 골랐으면 결과를 재 본다. 가장 먼저 볼 것은 청크 길이의 분포다.

import statistics

def evaluate_chunks(chunks: list[str]) -> dict:
    lengths = [len(c) for c in chunks]
    return {
        "total_chunks": len(chunks),
        "avg_length": statistics.mean(lengths),
        "std_length": statistics.stdev(lengths),
        "short_chunk_ratio": sum(l < 100 for l in lengths) / len(lengths),
        "long_chunk_ratio": sum(l > 1000 for l in lengths) / len(lengths),
    }

세 값이 각각 다른 것을 보여 준다. short_chunk_ratio는 100자 미만 청크의 비율로, 맥락 없는 조각이 얼마나 생겼는지를 말한다. 헤딩만 남은 조각, 표의 한 행, 목록의 한 줄이 대개 여기 걸린다. long_chunk_ratio는 1,000자 초과 청크의 비율로, 흐린 벡터가 될 덩어리가 얼마나 남았는지다. 이 두 비율은 5% 이하를 목표로 잡는 것이 흔하다. std_length(길이의 표준편차)에는 그런 절대 기준이 없다. 고정 크기 분할이라면 당연히 작고 의미 기반 분할이라면 당연히 크므로, 같은 저장소에서 설정을 바꿔 가며 비교하는 값으로 읽는다 — 설정을 바꿨더니 표준편차가 두 배가 됐다면 어디선가 길이가 무너졌다는 신호다.

검색 지표

세 값이 다 좋아도 검색은 나쁠 수 있다. 길이가 고르다는 것은 자른 모양이 반듯하다는 뜻일 뿐, 답이 한 청크 안에 온전히 들어갔다는 뜻은 아니기 때문이다. 앞의 연차 예에서 128 토큰 분할은 길이 지표로는 흠잡을 데가 없지만 답을 둘로 쪼갰다.

그래서 길이 지표와 함께 검색 지표를 본다. 질문과 「이 질문의 답이 든 청크」를 짝지은 평가 세트를 수십 개 만들어 두고, 검색 상위 N개 안에 그 청크가 들어 있는 비율인 recall@N을 잰다. 청킹을 바꾸면 정답 청크의 경계도 바뀌므로, 청크 id가 아니라 「답이 되는 원문 구간이 상위 N개 안에 온전히 들어왔는가」로 판정하는 편이 비교가 공정하다. 크기·겹침·구분자를 바꿀 때마다 이 값을 다시 재면, 감으로 고르던 일이 숫자로 고르는 일이 된다.

문서 종류별 측정

여러 종류의 문서가 한 저장소에 섞여 있으면 평균이 문제를 덮는다. 사내 위키 9할과 PDF 계약서 1할이 섞인 저장소에서 계약서만 파싱이 무너져 짧은 조각이 쏟아져도, 전체 short_chunk_ratio는 몇 퍼센트 오르는 데 그친다. 지표는 문서 종류마다 따로 내고, 평가 질문도 종류마다 몇 개씩 둔다. 종류마다 결과가 다르게 나오면 그것이 곧 종류마다 다른 전략을 써야 한다는 근거다.

문서 유형별 선택

재 보기 전의 출발점으로는 다음 짝이 무난하다.

  • 일반 텍스트·보고서: 재귀 분할, 500자 안팎, 겹침 10%
  • 마크다운·위키·사내 문서: 헤더 분할 뒤 긴 절만 재귀 분할
  • 법률·의료 전문 문서: 의미 기반 분할에 길이 후처리, 재귀 분할과 recall@N으로 비교한 뒤 채택
  • 소스 코드: 언어별 구분자로 함수·클래스 단위
  • 긴 문서에서 세밀한 검색이 필요할 때: 부모-자식 청킹, 넘기는 개수를 부모 기준으로 다시 정하기

어느 짝이든 출발점일 뿐이고, 정하는 것은 그 저장소에서 잰 recall@N이다.

청크를 다 잘랐으면 다음은 그 청크를 벡터로 바꾸는 임베딩 모델을 고르는 일이다. 다음 글에서는 모델마다 다른 차원과 그 저장 비용, 한국어에서 갈리는 토큰화와 접두사, 모델을 바꿀 때 치르는 재색인 비용까지 따라간다.


읽어주셔서 감사합니다. 😊

LATEST

에이전트·RAG의 최신 글

에이전트·RAG2026.08.23

에이전트는 어디서 어긋나기 시작하는가

에이전트가 이상한 답을 낼 때 증상은 마지막에 보이지만 어긋난 자리는 그보다 앞입니다. 한 걸음이 무너지는 여섯 자리를 나누고, 증상에서 원인을 거슬러 찾는 방법과 자리별 처방을 정리합니다.

29 MIN
에이전트·RAG2026.08.23

에이전트가 무엇을 했는지 나중에 알 수 있게 만들기

에이전트는 같은 입력에도 다른 경로로 갑니다. 그래서 로그 몇 줄로는 왜 그렇게 됐는지 복원이 안 됩니다. 트레이스를 어떻게 나누고 구간마다 무엇을 붙이며 어떤 지표를 볼지 정리합니다.

29 MIN
에이전트·RAG2026.08.23

에이전트 비용은 걸음 수보다 빨리 늘어난다

걸음이 두 배면 비용은 두 배가 아니라 서너 배입니다. 왜 그렇게 되는지, 어디서 새는지, 상한을 몇 겹으로 어떻게 거는지와 실제로 효과가 큰 순서대로의 대응을 정리합니다.

13 MIN