Поиск по смыслу работает не с целым файлом, а с небольшими фрагментами. Если нарезать плохо, система найдёт соседний абзац или размажет смысл на полглавы. Здесь разберём, почему целый документ мешает, какой размер куска и зачем запас на стыке, где резать по структуре, что сохранить рядом с текстом и как проверить нарезку на своих файлах до того, как жаловаться на модель.
Все дорожки — /put. Прошлая — когда хватит подсказки и поиска, а когда нужно дообучение.
Зачем это в работе. Когда говорят «подключите базу знаний», часто имеют в виду: положить PDF целиком в индекс или целиком в окно запроса. На короткой инструкции это ещё терпимо. На методичке в десятки страниц поиск начинает возвращать «почти тот файл», а модель тонет в лишнем тексте. Нарезка на куски (chunking) — не украшение, а способ дать поиску и модели узкую опору.
Поиск по смыслу обычно сравнивает короткие векторы. Вектор (embedding) — это набор чисел, который описывает смысл фрагмента; подробнее — на дорожке про эмбеддинги. Если в один вектор засунуть всю главу, числа усреднят тему: и про отпуск, и про больничный, и про штрафы. Запрос «можно ли перенести отпуск» окажется «рядом» с огромным клубом смысла, а не с нужным абзацем. Кусок размером с один-два смысловых блока даёт более честный вектор.
Второй удар — окно контекста. Окно контекста — это сколько текста модель может увидеть за один запрос; про это есть дорожка про окно контекста. Если вы каждый раз кладёте весь файл, место съедают повторы и чужие главы. Модель может ответить красиво, но опереться не на тот абзац или смешать два правила. Узкий кусок плюс ссылка на источник проще проверить глазами.
Третий удар — обновление. Правьте один абзац в длинном файле — и при цельном индексе часто приходится пересчитывать вектор всей простыни. При нарезке обновляют только затронутые куски. Соседнее отличие от обычного чата без поиска: в чате вы сами выбираете, что вставить; в RAG (retrieval-augmented generation — ответ с опорой на найденные куски) программа выбирает фрагменты за вас, и от качества нарезки зависит, что она вообще сможет выбрать. Базовый разбор схемы — на дорожке поиска по заметкам.
Ограничение честное: иногда документ короткий — одна страница правил. Тогда «один кусок = весь файл» допустим. Ломается схема, когда файл длинный, внутри несколько тем или когда один запрос должен попасть в узкий параграф, а не «в правильный PDF». Не путайте нарезку с дообучением: куски не меняют веса модели, они только меняют, какой текст попадёт в запрос; про выбор рычага — на дорожке про дообучение.
Подробный пример. Файл «Кадровый регламент.docx» на 40 страниц. Сотрудник спрашивает: «За сколько дней писать заявление на перенос отпуска?» Если индекс хранит один вектор на весь файл, поиск может вернуть «регламент целиком» или соседний раздел про больничные — в векторе всё перемешано. Если файл нарезан по подзаголовкам, в топ попадёт кусок «Перенос отпуска» с нужным сроком. Дальше в запрос кладут этот кусок (и один-два соседних), а не сорок страниц. Проверка: откройте найденный текст и убедитесь, что в нём есть слова про срок заявления; если их нет — чинят нарезку или поиск, а не «тон» модели.
from dataclasses import dataclass
@dataclass
class Hit:
source: str
text: str
def too_coarse(hit: Hit, question: str) -> bool:
"""Учебная проверка: кусок слишком общий, если вопрос узкий, а текст — целая глава."""
q = question.lower()
t = hit.text.lower()
if "отпуск" in q and "больнич" in t and "перенос" not in t:
return True
if len(hit.text) > 8000 and hit.source.endswith(".docx"):
return True # похоже, в индекс попал почти весь файл
return False
demo = Hit("reglament.docx", "Больничный лист оформляют через кадры. ...")
print(too_coarse(demo, "За сколько дней писать заявление на перенос отпуска?"))
Где обычно ошибаются.
Кусок (chunk). небольшой фрагмент документа, который отдельно индексируют и ищут.
Нарезка (chunking). правило, как резать длинный текст на куски перед поиском.
Вектор (embedding). числа, которыми описывают смысл куска для поиска по близости.
Индекс. хранилище кусков (и часто их векторов), по которому ищут.
Окно контекста. лимит текста, который модель видит за один запрос.
RAG. схема «сначала найти куски, потом ответить по ним».
Опора. найденный текст, на который ответ имеет право ссылаться.
Усреднение смысла. когда один вектор описывает сразу много тем и теряет узкий абзац.
Зачем это в работе. Слишком мелкий кусок теряет условие («можно, если…»). Слишком крупный снова усредняет темы. Между ними выбирают размер и делают запас на стыке — перекрытие (overlap), чтобы мысль, разрезанная пополам, не пропала из обоих кусков.
Размер куска удобно мерить в символах или в токенах. Токен — это кусочек текста, которым оперирует модель (часто часть слова); для учебной оценки можно думать «примерно несколько символов на токен», без претензии на точную формулу. На практике для поиска по смыслу часто берут куски порядка нескольких абзацев: достаточно контекста, чтобы правило было целым, и достаточно узко, чтобы вектор не размазался. Жёсткой «волшебной цифры для всех документов» нет: инструкция на полстраницы и художественный текст режутся по-разному.
Перекрытие — это повтор хвоста предыдущего куска в начале следующего. Зачем: граница реза почти всегда где-то «не идеальна». Предложение «Срок — 14 дней.» может оказаться в конце куска A, а условие «если есть заявление» — в начале куска B. Без перекрытия поиск может вернуть только A или только B. С небольшим запасом нужная связка чаще попадает хотя бы в один кусок целиком.
Как устроено ограничение. Большое перекрытие раздувает индекс: одни и те же фразы хранятся дважды, поиск чаще возвращает почти одинаковые соседи. Маленькое или нулевое перекрытие экономит место, но режет мысли на стыках. Рабочий компромисс — небольшой хвост относительно размера куска, а не «половина куска дважды». Соседнее отличие от окна контекста: размер куска влияет на то, что лежит в индексе; окно контекста влияет на то, сколько найденных кусков вы потом реально вставите в запрос.
Ещё один слой — сколько кусков забирать в ответ (top-k). Даже идеальная нарезка бесполезна, если вы всегда берёте один кусок, а правило размазано на два соседних. Тогда либо увеличивают top-k, либо чуть укрупняют кусок, либо усиливают перекрытие. Не путайте это с «просто дать модели весь файл»: top-k — это несколько узких опор, а не одна простыня.
Подробный пример. Учебный резак: окно 500 символов, шаг 80. Текст режется с шагом 420 (500 минус 80), чтобы хвост прошлого окна стал началом следующего. На коротком абзаце про отпуск кусок 1 захватит начало правила, кусок 2 — конец с условием; благодаря перекрытию фраза про срок может встретиться в обоих. В коде ниже нет «измеренных процентов качества» — только явная схема, которую можно прогнать на своём файле и глазами посмотреть стыки.
def chunk_with_overlap(text: str, size: int = 500, overlap: int = 80) -> list[str]:
"""Учебный резак по символам: размер окна и запас на стыке."""
if size <= 0:
raise ValueError("size должен быть > 0")
if overlap < 0 or overlap >= size:
raise ValueError("overlap должен быть >= 0 и меньше size")
step = size - overlap
chunks: list[str] = []
start = 0
while start < len(text):
end = min(start + size, len(text))
chunks.append(text[start:end])
if end == len(text):
break
start += step
return chunks
sample = (
"Перенос отпуска оформляют заявлением. "
"Срок подачи — не позже чем за 14 дней. "
"Без заявления кадры перенос не фиксируют."
)
parts = chunk_with_overlap(sample, size=90, overlap=25)
for i, p in enumerate(parts, 1):
print(f"--- кусок {i} ({len(p)} симв.) ---")
print(p)
Где обычно ошибаются.
Размер куска. сколько текста попадает в один фрагмент (символы или токены).
Перекрытие (overlap). повтор хвоста прошлого куска в начале следующего.
Шаг нарезки. на сколько сдвигают окно: обычно размер минус перекрытие.
Токен. единица текста для модели; размер окна контекста часто считают в токенах.
Top-k. сколько ближайших кусков забирают из индекса в запрос.
Стык. граница между двумя кусками, где мысль чаще всего рвётся.
Раздувание индекса. рост хранилища из-за сильного перекрытия и дублей.
Узкая опора. короткий найденный фрагмент, который можно сверить с ответом.
Зачем это в работе. Резать «каждые N символов» просто, но граница часто падает внутрь предложения или таблицы. Лучше опираться на структуру документа: абзацы, заголовки, списки. Когда структуры нет или она врёт, снова нужен запас и ручная проверка стыков.
Резание по абзацам. Абзац — естественный блок смысла в прозе и в методичках. Алгоритм склеивает соседние абзацы, пока не наберёт целевой размер, затем начинает новый кусок (часто с перекрытием последнего абзаца). Плюс: реже рвёте предложение посередине. Минус: один «абзац» в HTML или Markdown может быть гигантским, если автор не ставил пустых строк.
Резание по заголовкам. Заголовок H2/H3 задаёт тему раздела. Кусок «от этого заголовка до следующего» хорошо работает в регламентах и справочниках: название раздела само становится подсказкой для поиска и для человека. Ломается там, где заголовков мало, они декоративные («Введение», «Разное») или один раздел тянется на много страниц — тогда внутри раздела всё равно нужен второй уровень нарезки по абзацам.
Резание «по смыслу» звучит привлекательно: попросить модель найти границы тем. На практике это дороже, медленнее и менее предсказуемо, чем эвристики по структуре. Имеет смысл как уточнение для очень кривых текстов, а не как первый шаг. Соседнее отличие от поиска по словам: ключевые слова ищут совпадения букв; нарезка решает, какой фрагмент вообще попадёт в индекс и сможет быть найден по смыслу через эмбеддинги.
Где схема ломается чаще всего. (1) Таблицы: строка «14 дней | заявление» разрезана пополам — условие уехало от числа. (2) Списки и нумерация: пункт 3 ссылается на пункт 1, который остался в прошлом куске. (3) Код и формулы: разрыв посередине блока ломает чтение. (4) Сканы и PDF без нормальных абзацев: «абзацы» склеены переносами строк. В таких местах либо режут по ячейкам/блокам кода целиком, либо оставляют чуть больший кусок. Связка с дорожкой про выдумки: если опора обрезана, модель охотнее «достраивает» правило из общих знаний.
Подробный пример. Markdown-методичка с заголовками. Сначала режем по ##, внутри длинного раздела склеиваем абзацы до лимита. Заголовок раздела дописываем в начало каждого куска («Перенос отпуска: …»), чтобы вектор и человек видели тему даже у хвоста раздела. Для таблицы «срок | условие» целиком кладём одну строку или всю маленькую таблицу в один кусок, не режем по символу посреди строки.
import re
def split_by_h2(md: str) -> list[tuple[str, str]]:
"""Учебно: режем Markdown по заголовкам ##. Возвращаем (заголовок, тело)."""
parts = re.split(r"(?m)^(## .+)$", md)
sections: list[tuple[str, str]] = []
# parts: [преамбула, заголовок, тело, заголовок, тело, ...]
preamble = parts[0].strip()
if preamble:
sections.append(("(без заголовка)", preamble))
for i in range(1, len(parts), 2):
title = parts[i].lstrip("# ").strip()
body = parts[i + 1].strip() if i + 1 < len(parts) else ""
sections.append((title, body))
return sections
def pack_paragraphs(body: str, limit: int = 600) -> list[str]:
paras = [p.strip() for p in re.split(r"\n\s*\n", body) if p.strip()]
chunks: list[str] = []
buf: list[str] = []
size = 0
for p in paras:
if buf and size + len(p) + 2 > limit:
chunks.append("\n\n".join(buf))
buf, size = [p], len(p)
else:
buf.append(p)
size += len(p) + (2 if size else 0)
if buf:
chunks.append("\n\n".join(buf))
return chunks
doc = """## Перенос отпуска
Заявление пишут заранее.
Срок — не позже чем за 14 дней.
## Больничный
Больничный согласуют с кадром.
"""
for title, body in split_by_h2(doc):
for piece in pack_paragraphs(body, limit=80):
print(f"[{title}] {piece}")
Где обычно ошибаются.
Структурная нарезка. рез по абзацам, заголовкам, спискам, а не только по счётчику символов.
Секция. часть документа от одного заголовка до следующего.
Преамбула. текст до первого заголовка; её тоже нужно куда-то положить.
Склейка абзацев. объединение соседних коротких абзацев до целевого размера куска.
Заголовок в куске. повтор названия раздела внутри фрагмента, чтобы не терять тему.
Блок кода. фрагмент, который лучше не резать посередине.
Ложный абзац. «абзац» из PDF/скана, склеенный переносами и колонками.
Эвристика. простое правило нарезки по структуре без отдельной модели.
Зачем это в работе. Голый текст куска недостаточен. Без метаданных — служебных полей рядом с текстом — вы не покажете человеку, откуда ответ, не отфильтруете устаревший приказ и не поймёте, какой файл переиндексировать после правки.
Минимальный набор. (1) Источник: путь или имя файла, иногда URL. (2) Заголовок раздела, если он есть. (3) Номер куска внутри документа (chunk_id или порядковый индекс), чтобы открыть соседей. (4) По возможности — смещение в символах или страница PDF, чтобы прыгнуть в оригинал. Эти поля не обязаны лежать внутри вектора; они хранятся рядом и возвращаются вместе с найденным текстом.
Зачем это поиску и ответу. Фильтр «только действующие документы» работает по статусу и дате в метаданных, а не по красоте формулировки. Ссылка в ответе («методичка, раздел Перенос отпуска, кусок 3») позволяет сверить факт — это главный щит от уверенных выдумок, о которых на дорожке про выдумки. При обновлении файла вы удаляете из индекса все куски со старым source и версией, затем кладёте новые — без ручного поиска «где этот абзац жил».
Как устроено на практике. В записи индекса обычно два слоя: вектор для поиска по смыслу и полезная нагрузка (payload) — текст куска плюс метаданные. Можно дополнительно вшить короткое «название раздела» в сам текст куска, чтобы смысл заголовка участвовал в векторе, а полные поля всё равно держать отдельно для фильтров и ссылок. Соседнее отличие от «просто положить текст в чат»: в чате источник часто теряется в истории; в индексе источник — обязательное поле записи.
Ограничение: метаданные врут, если вы их не обновляете. Статус «действует» при отменённом приказе хуже, чем отсутствие статуса: фильтр будет уверенно отдавать мёртвый текст. Дата файла с диска не всегда равна дате вступления правила в силу — для кадровых документов лучше явное поле «действует с». Не путайте номер куска с номером страницы PDF: после новой нарезки нумерация кусков может сдвинуться, а страница в исходнике стабильнее для человека.
Подробный пример. Запись для одного куска регламента: source, title, chunk_index, text, status, updated. Поиск возвращает не только text, но и поля для ссылки. Перед ответом отбрасываете status != "active". В учебном коде ниже нет настоящей базы — только структура, которую потом кладут в любое хранилище векторов.
from dataclasses import dataclass
@dataclass
class ChunkRecord:
source: str
title: str
chunk_index: int
text: str
status: str # active | archived
updated: str # дата вида YYYY-MM-DD, как в вашем учёте
def cite(rec: ChunkRecord) -> str:
return f"{rec.source} · {rec.title} · кусок {rec.chunk_index}"
def filter_active(rows: list[ChunkRecord]) -> list[ChunkRecord]:
return [r for r in rows if r.status == "active"]
rows = [
ChunkRecord(
"reglament.docx",
"Перенос отпуска",
2,
"Срок подачи заявления — не позже чем за 14 дней.",
"active",
"2026-10-01",
),
ChunkRecord(
"reglament-old.docx",
"Перенос отпуска",
2,
"Срок подачи — 30 дней.",
"archived",
"2024-05-01",
),
]
alive = filter_active(rows)
print(cite(alive[0]))
print(alive[0].text)
Где обычно ошибаются.
Метаданные. поля рядом с текстом куска: источник, заголовок, номер, дата, статус.
Источник (source). файл, URL или идентификатор документа, из которого взят кусок.
Номер куска. порядковый индекс фрагмента внутри документа после нарезки.
Полезная нагрузка (payload). текст и метаданные, которые возвращает поиск вместе с близостью.
Ссылка на абзац. понятная человеку отсылка к источнику и месту в нём.
Фильтр по метаданным. отбор кусков по статусу, дате, типу до сравнения смыслов или после.
Версия документа. метка, по которой можно выкинуть старые куски при переиндексации.
Переиндексация. удаление старых кусков источника и запись новых после правки файла.
Зачем это в работе. Пока вы не посмотрели куски глазами и не прогнали десяток реальных вопросов, споры «модель тупит» бессмысленны. Нарезка проверяется отдельно от тона ответа: сначала «нашёлся ли правильный фрагмент», потом «правильно ли модель по нему ответила».
Мини-стенд. Возьмите 3–5 типичных документов и 15–20 вопросов, на которые вы заранее знаете эталонный абзац (можно выделить его маркером в исходнике). Нарежьте файлы выбранным правилом. Для каждого вопроса посмотрите top-k кусков до вызова модели: есть ли эталон среди них? Если нет — чините размер, перекрытие, рез по заголовкам, метаданные. Если да, а ответ всё равно плохой — это уже подсказка, формат или дисциплина «отвечай только по опоре», а не нарезка.
Что смотреть руками в самих кусках. (1) Обрыв посередине правила: начало в одном куске, условие в другом без перекрытия. (2) Склейка двух разных тем в одном куске из-за слишком большого размера. (3) Пустые или почти пустые куски из колонтитулов и оглавления. (4) Таблица или список, разрезанный пополам. (5) Заголовок секции потерян — кусок «ни о чём» для человека. Заведите короткий чек-лист и пройдитесь по случайной выборке кусков, не только по любимым примерам.
Типичные симптомы в поиске. Вопрос узкий, а в топе — целая глава: куски слишком крупные. В топе два почти одинаковых фрагмента: слишком большое перекрытие или не почистили старую версию. Эталон есть в файле, но никогда не в top-k: рез не там, заголовок не попал в текст, или эмбеддинги/запрос на другом языке и стиле. Здесь полезны дорожки про поиск и про эмбеддинги: сначала добейтесь, чтобы эталонный кусок был в индексе и находился, потом спорьте о модели.
Ограничение проверки: набор из трёх «удобных» вопросов врёт. Добавьте краевые случаи — короткие вопросы без терминов из заголовка, вопросы про числа из таблиц, вопросы «чего нет в документе» (система должна честно не находить опору, а не подтягивать соседнюю тему). Журналируйте для каждого теста: вопрос, id найденных кусков, попал ли эталон, что ответила модель. Без журнала вы снова будете крутить размер куска наугад.
Подробный пример. Учебный прогон: эталон задан подстрокой, которая обязана встретиться в одном из top-k текстов. Функция не измеряет «качество модели в процентах», а только отвечает: нарезка+поиск доставили нужный фрагмент или нет. Если hit_rate низкий — меняют chunking. Если высокий, а люди всё равно ругают ответы — смотрят промпт и запрет выдумывать.
from dataclasses import dataclass
@dataclass
class Case:
question: str
must_include: str # кусок эталона, который обязан найтись
@dataclass
class Retrieved:
chunk_id: str
text: str
def etalon_in_topk(cases: list[Case], retrieve) -> float:
"""retrieve(question) -> list[Retrieved]. Доля вопросов, где эталон встретился в top-k."""
ok = 0
for c in cases:
hits = retrieve(c.question)
if any(c.must_include in h.text for h in hits):
ok += 1
return ok / max(1, len(cases))
def demo_retrieve(question: str) -> list[Retrieved]:
# Заглушка вместо настоящего индекса: в бою здесь вызов поиска.
catalog = [
Retrieved("reglament#2", "Срок подачи заявления — не позже чем за 14 дней."),
Retrieved("reglament#5", "Больничный согласуют с кадром в день выхода."),
]
if "отпуск" in question.lower():
return catalog[:1]
return catalog[1:]
cases = [
Case("За сколько дней писать заявление на перенос отпуска?", "14 дней"),
Case("Кому согласовать больничный?", "Больничный согласуют"),
]
print("доля попадания эталона:", etalon_in_topk(cases, demo_retrieve))
Где обычно ошибаются.
Эталонный абзац. фрагмент исходника, который должен находиться по данному вопросу.
Попадание в top-k. факт, что эталон оказался среди кусков, отданных поиском.
Мини-стенд нарезки. набор файлов и вопросов для проверки кусков отдельно от тона ответа.
Краевой случай. неудобный вопрос: таблица, короткое имя, отсутствие факта в базе.
Журнал поиска. запись вопроса, id кусков и факта попадания эталона.
Пустой кусок. фрагмент без полезного текста (мусор вёрстки, оглавление без содержания).
Склейка тем. один кусок смешивает разные разделы из-за слишком крупного окна.
Обрыв правила. условие и следствие попали в разные куски без достаточного перекрытия.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.