Данные и governance

Ingestion: от PDF до чанка с метаданными

Ingestion (загрузка и подготовка данных) — всё, что происходит с документом до попадания его чанков в индекс. Многие «галлюцинации RAG» из модуля 5 начинаются здесь: таблица превратилась в кашу из чисел, скан стал пустой страницей, футер «Конфиденциально, стр. 3 из 40» попал в каждый чанк, старая версия политики лежит рядом с новой. Модель честно отвечает по тому, что ей дали.

Пайплайн: сбор (коннекторы к Confluence, Drive, S3, тикетам) → парсинг (текстовый слой, OCR или VLM) → нормализация в структуру (markdown или JSON с заголовками, таблицами, списками и порядком чтения) → очистка → PII-редакция → дедупликация → чанкинг по структуре → метаданные и ACL → эмбеддинги и индекс (модуль 5) → отчёт о качестве. Каждый шаг идемпотентен: повторный запуск на тех же байтах ничего не меняет.

Почему PDF — худший формат для RAG

PDF описывает страницу, а не документ: это глифы по координатам, без абзацев, порядка чтения и таблиц. Типовые поломки:

• Порядок чтения: две колонки читаются построчно поперёк, сноски вклиниваются в абзац.
• Таблицы: ячейки склеиваются в строку «План Срок Комиссия Месяц 3 дня 0%», связь «значение ↔ колонка» теряется, и вопрос «какая комиссия на годовом плане» уже не решается никаким промптом.
• Сканы: текстового слоя нет, парсер возвращает пустую строку, документ молча выпадает из индекса.
• Битые шрифты: без корректной таблицы ToUnicode извлекается мусор вроде «Ïîëèòèêà», хотя визуально PDF идеален.
• Колонтитулы и переносы: «стр. 3 из 40» в каждом чанке, «воз-\nврат» вместо «возврат» ломает и BM25, и эмбеддинги.

Подходы: качество, стоимость, скорость

Рабочая схема для большого корпуса — маршрутизация по страницам. Страница с нормальным текстовым слоем идёт в layout-парсер. Страница без текста или с мусором (мало букв, много символов вне алфавита) — в OCR. Сложная таблица или график, где важны цифры, — в VLM со сверкой по текстовому слою, если он есть. Когда VLM-парсинг лучше OCR-пайплайна — модуль 16 (факультатив).

Инструменты (по состоянию на октябрь 2026)

Таблицы в индексе

Маленькую таблицу кладите целиком одним чанком в markdown. Большую — группами строк с шапкой в каждом чанке или построчно в виде «План: Год; Срок на возврат: 14 дней; Комиссия: 0%». Справочник с точными значениями (прайс, коды ошибок) лучше положить в SQL и дать модели инструмент поиска (модуль 6): точный ответ не должен зависеть от удачи retrieval.

Парсинг на Python: Docling

Парсеры живут в Python, поэтому это обычно отдельный воркер: GoJava-сервис кладёт файл в очередь, Python-воркер возвращает markdown и отчёт. Скрипт генерирует тестовый PDF с заголовками, списком и таблицей, разбирает его и проверяет, что структура пережила парсинг.

"""PDF → markdown + таблицы + отчёт о парсинге через Docling (модуль 11, урок «Ingestion»).

Запуск без аргументов генерирует тестовый sample.pdf (заголовки, список, таблица) и разбирает его:
    uv run --with docling==2.135.0 --with pymupdf==1.28.2 python pdf_to_md.py
Свой файл:
    uv run --with docling==2.135.0 python pdf_to_md.py path/to/file.pdf

Первый запуск ставит torch и скачивает модели layout и TableFormer с Hugging Face (сотни МБ, минуты).
PyMuPDF нужен только для генерации тестового PDF; его лицензия AGPL-3.0 — см. урок, прежде чем брать его в продукт.
"""
import hashlib
import json
import sys
import time
from pathlib import Path

# SAMPLE_HTML и make_sample() — генерация тестового PDF через PyMuPDF, см. файл в examples/m11-data


def parse(path: Path) -> tuple[str, dict]:
    from docling.document_converter import DocumentConverter

    t0 = time.perf_counter()
    res = DocumentConverter().convert(path)  # OCR растровых областей включён по умолчанию
    doc = res.document
    md = doc.export_to_markdown()
    pages = doc.num_pages()
    report = {
        "file": path.name,
        "sha256": hashlib.sha256(path.read_bytes()).hexdigest()[:16],  # версия источника
        "status": str(res.status),
        "pages": pages,
        "chars_per_page": round(len(md) / max(pages, 1)),
        "headings": [t.text for t in doc.texts if t.label == "section_header"],
        "tables": [t.export_to_dataframe(doc=doc).to_dict(orient="records") for t in doc.tables],
        "seconds": round(time.perf_counter() - t0, 1),
    }
    # Дешёвые проверки качества: пустой текст почти всегда значит скан без OCR или битые шрифты.
    report["warnings"] = [w for w, bad in [
        ("мало текста на страницу: скан или битый ToUnicode", report["chars_per_page"] < 200),
        ("нет заголовков: структура потеряна, чанкинг по секциям не сработает", not report["headings"]),
    ] if bad]
    return md, report


if __name__ == "__main__":
    src = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(__file__).with_name("sample.pdf")
    if len(sys.argv) == 1:
        make_sample(src)
    md, report = parse(src)
    print(md)
    print(json.dumps(report, ensure_ascii=False, indent=2))
    if len(sys.argv) == 1:  # самопроверка на тестовом PDF
        assert "Политика возвратов" in report["headings"], report["headings"]
        assert len(report["tables"]) == 1 and len(report["tables"][0]) == 2, report["tables"]
        assert "| Год" in md, "таблица должна остаться таблицей в markdown"
        print("OK: заголовки и таблица сохранены")

Чанкинг по структуре

Стратегии чанкинга и подбор размера по recall@k — в модуле 5, там же ChunkSection для прозы. Здесь недостающий кусок для проекта A: нарезать markdown после парсера по заголовкам так, чтобы путь заголовков ехал с каждым чанком, а код-блоки и таблицы не резались. Только стандартная библиотека.

/** Markdown-сплиттер модуля 11: секции по заголовкам, блоки не режутся. */
public final class MdSplit {
    private MdSplit() {}

    /**
     * Кусок markdown с путём заголовков. Эмбеддим heading + "\n\n" + text:
     * путь заголовков даёт чанку контекст, которого нет в самом тексте.
     */
    public record Chunk(String heading, String text) {}

    /**
     * Режет markdown по ATX-заголовкам (# … ######), затем пакует блоки секции (абзацы,
     * списки, таблицы, код) в чанки до maxChars символов. Блок не режется никогда:
     * код-блок и таблица уходят целиком, даже если длиннее maxChars.
     * ponytail: блок длиннее maxChars остаётся одним чанком; прозу дорезайте chunkSection из модуля 5.
     */
    public static List<Chunk> splitMarkdown(String md, int maxChars) {
        return new Splitter(maxChars).run(md);
    }

    private static final class Splitter {
        final int max;
        final List<Chunk> out = new ArrayList<>();
        final List<String> path = new ArrayList<>();   // текущий путь заголовков по уровням
        final List<String> blocks = new ArrayList<>(); // блоки текущей секции
        final List<String> cur = new ArrayList<>();    // строки текущего блока
        String fence = "";                             // открытый ``` или ~~~

        Splitter(int max) { this.max = max; }

        void endBlock() {
            String t = String.join("\n", cur).strip();
            if (!t.isEmpty()) blocks.add(t);
            cur.clear();
        }

        void endSection() {
            endBlock();
            String heading = String.join(" › ", path.stream().filter(s -> !s.isEmpty()).toList());
            List<String> buf = new ArrayList<>();
            int size = 0;
            for (String b : blocks) {
                int n = b.codePointCount(0, b.length());
                if (size > 0 && size + n > max) {
                    out.add(new Chunk(heading, String.join("\n\n", buf)));
                    buf.clear();
                    size = 0;
                }
                buf.add(b);
                size += n;
            }
            if (!buf.isEmpty()) out.add(new Chunk(heading, String.join("\n\n", buf)));
            blocks.clear();
        }

        List<Chunk> run(String md) {
            for (String line : md.split("\n", -1)) {
                String trim = line.strip();
                int lvl;
                if (!fence.isEmpty()) { // внутри код-блока: ни заголовков, ни разрывов
                    cur.add(line);
                    if (trim.startsWith(fence)) {
                        fence = "";
                        endBlock();
                    }
                } else if (trim.startsWith("```") || trim.startsWith("~~~")) {
                    endBlock();
                    fence = trim.substring(0, 3);
                    cur.add(line);
                } else if ((lvl = headingLevel(trim)) > 0) {
                    endSection();
                    while (path.size() < lvl) path.add("");
                    path.subList(lvl - 1, path.size()).clear();
                    path.add(trim.substring(lvl).strip());
                } else if (trim.isEmpty()) {
                    endBlock();
                } else {
                    cur.add(line);
                }
            }
            endSection();
            return out;
        }
    }

    /** "## Title" → 2; "#hashtag" и "####### x" — не заголовки. */
    static int headingLevel(String s) {
        int n = 0;
        while (n < s.length() && s.charAt(n) == '#') n++;
        if (n == 0 || n > 6 || (n < s.length() && s.charAt(n) != ' ')) return 0;
        return n;
    }
}

// Chunk — кусок markdown с путём заголовков. Эмбеддим Heading + "\n\n" + Text:
// путь заголовков даёт чанку контекст, которого нет в самом тексте.
type Chunk struct {
	Heading string // "Тарифы › Возвраты › Сроки"
	Text    string
}

// SplitMarkdown режет markdown по ATX-заголовкам (# … ######), затем пакует блоки
// секции (абзацы, списки, таблицы, код) в чанки до maxRunes. Блок не режется никогда:
// код-блок и таблица уходят целиком, даже если длиннее maxRunes.
// ponytail: блок длиннее maxRunes остаётся одним чанком; прозу дорезайте ChunkSection из модуля 5.
func SplitMarkdown(md string, maxRunes int) []Chunk {
	var (
		out    []Chunk
		path   []string // текущий путь заголовков по уровням
		blocks []string // блоки текущей секции
		cur    []string // строки текущего блока
		fence  string   // открытый ``` или ~~~
	)
	endBlock := func() {
		if t := strings.TrimSpace(strings.Join(cur, "\n")); t != "" {
			blocks = append(blocks, t)
		}
		cur = nil
	}
	endSection := func() {
		endBlock()
		heading := strings.Join(nonEmpty(path), " › ")
		var buf []string
		size := 0
		for _, b := range blocks {
			n := utf8.RuneCountInString(b)
			if size > 0 && size+n > maxRunes {
				out = append(out, Chunk{heading, strings.Join(buf, "\n\n")})
				buf, size = nil, 0
			}
			buf = append(buf, b)
			size += n
		}
		if len(buf) > 0 {
			out = append(out, Chunk{heading, strings.Join(buf, "\n\n")})
		}
		blocks = nil
	}
	for _, line := range strings.Split(md, "\n") {
		trim := strings.TrimSpace(line)
		switch {
		case fence != "": // внутри код-блока: ни заголовков, ни разрывов
			cur = append(cur, line)
			if strings.HasPrefix(trim, fence) {
				fence = ""
				endBlock()
			}
		case strings.HasPrefix(trim, "```") || strings.HasPrefix(trim, "~~~"):
			endBlock()
			fence = trim[:3]
			cur = append(cur, line)
		case headingLevel(trim) > 0:
			endSection()
			lvl := headingLevel(trim)
			for len(path) < lvl {
				path = append(path, "")
			}
			path = append(path[:lvl-1], strings.TrimSpace(trim[lvl:]))
		case trim == "":
			endBlock()
		default:
			cur = append(cur, line)
		}
	}
	endSection()
	return out
}

// headingLevel: "## Title" → 2; "#hashtag" и "####### x" — не заголовки.
func headingLevel(s string) int {
	n := 0
	for n < len(s) && s[n] == '#' {
		n++
	}
	if n == 0 || n > 6 || (n < len(s) && s[n] != ' ') {
		return 0
	}
	return n
}

func nonEmpty(ss []string) []string {
	var out []string
	for _, s := range ss {
		if s != "" {
			out = append(out, s)
		}
	}
	return out
}

Метаданные и ACL

Чанк без метаданных нельзя отфильтровать, обновить, удалить по запросу и процитировать. Минимум поверх таблицы chunks из модуля 5 (там уже есть tenant_id, acl, embed_model):

ALTER TABLE chunks
    ADD COLUMN source_uri   text    NOT NULL DEFAULT '',  -- откуда: для цитаты и удаления
    ADD COLUMN doc_version  text    NOT NULL DEFAULT '',  -- etag или ревизия источника
    ADD COLUMN content_hash text    NOT NULL DEFAULT '',  -- sha256 нормализованного текста: дедуп и «не эмбеддить повторно»
    ADD COLUMN pages        int4range,                     -- страницы PDF для цитаты «стр. 12–13»
    ADD COLUMN lang         text    NOT NULL DEFAULT 'ru',
    ADD COLUMN parser       text    NOT NULL DEFAULT '',  -- "docling 2.135.0": сменили парсер — пересобрали индекс
    ADD COLUMN is_current   boolean NOT NULL DEFAULT true, -- старые версии документа не ищутся
    ADD COLUMN data_class   text    NOT NULL DEFAULT 'internal'; -- public / internal / confidential

-- ACL проверяется в запросе retrieval, а не в промпте.
-- $1 — эмбеддинг запроса, $2 — tenant, $3 — группы пользователя из IdP.
SELECT id, heading, content, source_uri
FROM chunks
WHERE tenant_id = $2 AND acl && $3 AND is_current
ORDER BY embedding <=> $1
LIMIT 20;

• ACL копируется из источника (группы пространства Confluence или папки Drive). Права меняются чаще текста, поэтому их синхронизация — отдельная, более частая задача.
• Deny by default: документ, права которого не прочитались, не индексируется. Проблемы фильтрованного ANN (post-filtering, iterative scan, партиции) — в модуле 5.

Качество данных и дедупликация

Дубли в RAG-индексе занимают места в top-k (пять копий абзаца вытесняют четыре полезных чанка), смещают ответ к версии, у которой больше копий (часто к старой), и стоят денег на эмбеддинги. В датасетах для evals и обучения дубли дают утечку теста в трейн — это и групповое разбиение разобраны в модуле 10. Здесь фокус на корпусе для RAG.

SimHash (Charikar, 2002): каждый шингл хэшируется в 64 бита, по каждому биту голосуют все шинглы (+1 за единицу, −1 за ноль), знак суммы даёт бит отпечатка. У похожих текстов почти все шинглы общие, и голосование почти совпадает. Чтобы не сравнивать документ со всем корпусом, Manku и соавторы (Google, 2007) режут отпечаток на блоки: при расстоянии ≤ 3 хотя бы один из четырёх 16-битных блоков совпадает целиком, поэтому сравниваем только с кандидатами из тех же корзин. В их работе на 8 млрд веб-страниц разумными оказались 64 бита и k = 3.

/**
 * Ищет точные (sha256 нормализованного текста) и почти-дубли (SimHash ≤ maxDist бит).
 * Индекс — 4 таблицы по 16-битным блокам отпечатка: при расстоянии ≤ 3 хотя бы один блок
 * совпадает целиком (принцип Дирихле), поэтому сравниваем только с кандидатами из корзин,
 * а не со всем корпусом (Manku et al., 2007).
 */
public final class Dedup {
    /** Найденный дубль: id и расстояние Хэмминга (0 — точная копия). */
    public record Match(String dupOf, int dist) {}

    private record Entry(String id, long hash) {}

    private final int maxDist; // 3 для 64 бит — значение из статьи Manku et al.; подбирайте на своей разметке
    private final Map<String, String> exact = new HashMap<>();
    @SuppressWarnings("unchecked")
    private final Map<Integer, List<Entry>>[] bands = new Map[4];

    public Dedup(int maxDist) {
        this.maxDist = maxDist;
        for (int i = 0; i < bands.length; i++) bands[i] = new HashMap<>();
    }

    /**
     * Общий шаг для точных и нечётких дублей: нижний регистр, только буквы и цифры,
     * пробелы схлопнуты. Даты, id и подписи вырезайте до этого.
     */
    public static List<String> normalize(String s) {
        List<String> out = new ArrayList<>();
        StringBuilder w = new StringBuilder();
        s.toLowerCase(Locale.ROOT).codePoints().forEach(cp -> {
            if (Character.isLetter(cp) || Character.isDigit(cp)) {
                w.appendCodePoint(cp);
            } else if (!w.isEmpty()) {
                out.add(w.toString());
                w.setLength(0);
            }
        });
        if (!w.isEmpty()) out.add(w.toString());
        return out;
    }

    /** 64-битный отпечаток по шинглам из 3 слов (Charikar, 2002). */
    public static long simHash(List<String> words) {
        final int k = 3;
        int[] acc = new int[64];
        List<String> shingles = new ArrayList<>();
        if (words.size() < k) shingles.add(String.join(" ", words));
        for (int i = 0; i + k <= words.size(); i++) shingles.add(String.join(" ", words.subList(i, i + k)));
        for (String sh : shingles) {
            long x = fnv64a(sh.getBytes(StandardCharsets.UTF_8));
            for (int i = 0; i < 64; i++) acc[i] += ((x >>> i) & 1) != 0 ? 1 : -1;
        }
        long out = 0;
        for (int i = 0; i < 64; i++) if (acc[i] > 0) out |= 1L << i;
        return out;
    }

    public static int hamming(long a, long b) { return Long.bitCount(a ^ b); }

    /**
     * Возвращает найденный дубль или null; если дубля нет, документ добавляется в индекс.
     * ponytail: корректно только для maxDist ≤ 3 (4 блока); для большего порога — больше таблиц с перестановками битов.
     */
    public Match add(String id, String text) {
        List<String> words = normalize(text);
        String key = sha256Hex(String.join(" ", words));
        String prev = exact.get(key);
        if (prev != null) return new Match(prev, 0);
        long h = simHash(words);
        for (int i = 0; i < bands.length; i++) {
            for (Entry e : bands[i].getOrDefault(band(h, i), List.of())) {
                int dist = hamming(h, e.hash());
                if (dist <= maxDist) return new Match(e.id(), dist);
            }
        }
        exact.put(key, id);
        for (int i = 0; i < bands.length; i++) {
            bands[i].computeIfAbsent(band(h, i), b -> new ArrayList<>()).add(new Entry(id, h));
        }
        return null;
    }

    private static int band(long h, int i) { return (int) ((h >>> (16 * i)) & 0xFFFF); }

    private static long fnv64a(byte[] data) {
        long h = 0xcbf29ce484222325L;
        for (byte b : data) {
            h ^= b & 0xff;
            h *= 0x100000001b3L;
        }
        return h;
    }

    private static String sha256Hex(String s) {
        try {
            return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(s.getBytes(StandardCharsets.UTF_8)));
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException(e);
        }
    }
}

// Normalize — общий шаг для точных и нечётких дублей: нижний регистр,
// только буквы и цифры, пробелы схлопнуты. Даты, id и подписи вырезайте до этого.
func Normalize(s string) []string {
	return strings.FieldsFunc(strings.ToLower(s), func(r rune) bool {
		return !unicode.IsLetter(r) && !unicode.IsDigit(r)
	})
}

// SimHash — 64-битный отпечаток по шинглам из 3 слов (Charikar, 2002).
// Похожие тексты дают отпечатки с малым расстоянием Хэмминга.
func SimHash(words []string) uint64 {
	const k = 3
	var acc [64]int
	add := func(shingle string) {
		h := fnv.New64a()
		h.Write([]byte(shingle))
		x := h.Sum64()
		for i := 0; i < 64; i++ {
			if x&(1<<i) != 0 {
				acc[i]++
			} else {
				acc[i]--
			}
		}
	}
	if len(words) < k {
		add(strings.Join(words, " "))
	}
	for i := 0; i+k <= len(words); i++ {
		add(strings.Join(words[i:i+k], " "))
	}
	var out uint64
	for i, v := range acc {
		if v > 0 {
			out |= 1 << i
		}
	}
	return out
}

func Hamming(a, b uint64) int { return bits.OnesCount64(a ^ b) }

// Dedup ищет точные (sha256 нормализованного текста) и почти-дубли (SimHash ≤ MaxDist бит).
// Индекс — 4 таблицы по 16-битным блокам отпечатка: при расстоянии ≤ 3 хотя бы один блок
// совпадает целиком (принцип Дирихле), поэтому сравниваем только с кандидатами из корзин,
// а не со всем корпусом (Manku et al., 2007).
type Dedup struct {
	MaxDist int // 3 для 64 бит — значение из статьи Manku et al.; подбирайте на своей разметке
	exact   map[[32]byte]string
	bands   [4]map[uint16][]entry
}

type entry struct {
	id   string
	hash uint64
}

func NewDedup(maxDist int) *Dedup {
	d := &Dedup{MaxDist: maxDist, exact: map[[32]byte]string{}}
	for i := range d.bands {
		d.bands[i] = map[uint16][]entry{}
	}
	return d
}

// Add возвращает id найденного дубля и расстояние (0 — точная копия).
// Если дубля нет, документ добавляется в индекс и возвращается "".
// ponytail: корректно только для MaxDist ≤ 3 (4 блока); для большего порога — больше таблиц с перестановками битов.
func (d *Dedup) Add(id, text string) (dupOf string, dist int) {
	words := Normalize(text)
	key := sha256.Sum256([]byte(strings.Join(words, " ")))
	if prev, ok := d.exact[key]; ok {
		return prev, 0
	}
	h := SimHash(words)
	for i := range d.bands {
		for _, e := range d.bands[i][uint16(h>>(16*i))] {
			if dist := Hamming(h, e.hash); dist <= d.MaxDist {
				return e.id, dist
			}
		}
	}
	d.exact[key] = id
	for i := range d.bands {
		b := uint16(h >> (16 * i))
		d.bands[i][b] = append(d.bands[i][b], entry{id, h})
	}
	return "", 0
}

В тесте examples/m11-dataexamples/java/m11-data замена одного слова в абзаце из ~60 слов дала расстояние ровно 3, то есть на самом пороге. Порог подбирают на своей разметке (100–200 пар «дубль / не дубль»), а не берут из статьи. Для Python есть MinHash LSH в библиотеке datasketch.

Шум, языки, устаревшие версии

• Boilerplate (колонтитулы, меню и cookie-баннеры из HTML, подписи писем) лучше всего находится по частоте: строка, которая встречается на 30% страниц документа или в 1000 писем, — шаблон. Удаляйте до чанкинга. Мусорные чанки (слишком короткие, без букв, mojibake) отсекаются простыми эвристиками.
• Язык чанка (fastText lid.176, lingua) пишите в метаданные вместе с уверенностью: от него зависят конфигурация полнотекстового поиска ('russian' или 'english'), выбор эмбеддинг-модели и фильтр по языку пользователя.
• Устаревшие версии — главный источник ответов «по прошлогодней политике». Новая ревизия документа ставит старой is_current = false в той же транзакции; удалённый в источнике документ удаляется из индекса (tombstone), иначе данные, удалённые по требованию, продолжают жить в индексе; дата обновления едет в <source> промпта (модуль 3). Почти-дубли с разными id («копия политики в чужом пространстве») показывайте владельцу корпуса, а не удаляйте автоматически.

PII-редакция

PII (personally identifiable information, персональные данные) приходит в LLM-продукт тремя путями: в документах корпуса (HR-политики, договоры, тикеты), в сообщениях пользователей (в чат вставляют всё: номер карты, паспорт, переписку) и в ответах модели, которая пересказывает контекст. Редактировать нужно там, где данные пересекают границу: индекс, логи, внешний провайдер, разметчики, обучающий датасет.

• Прямые идентификаторы: ФИО, телефон, email, карта, паспорт, СНИЛС, ИНН, адрес.
• Косвенные: дата рождения, город, должность, «дочь учится в 5 «Б» школы № 1234». По отдельности безобидны, вместе указывают на человека: по работе Суини (2000), почтовый индекс, пол и дата рождения уникально определяют 87% жителей США.
• Особые категории (здоровье, биометрия, убеждения) — по GDPR и 152-ФЗ под более жёсткими правилами.

Детекторы

Presidio: presidio-analyzer находит сущности (регэкспы с контекстными словами, валидаторы, NER через spaCy, Stanza или transformers), presidio-anonymizer применяет операторы replace, redact, mask, hash, encrypt; обратим только encrypt (через decrypt). Лицензия MIT. Проект перешёл от Microsoft к независимому сообществу (GitHub-организация data-privacy-stack), API не изменился. Из коробки Presidio настроен на английский: встроенных распознавателей российских документов нет. Для русского нужны NER-модель (spaCy, Stanza или transformers через NlpEngineProvider), свои распознаватели ИНН и СНИЛС и русские контекстные слова. Для русского NER есть и отдельные библиотеки, например Natasha.

Код: детекторы, контрольные суммы, псевдонимы

Пересечения решаются приоритетом: сначала то, что подтверждено контрольной суммой, потом форматные детекторы. Так СНИЛС без дефисов не станет «телефоном». Это развитие MaskPII из модуля 9, где регэксп карты маскирует любые 13–19 цифр подряд, включая номера заказов.

/** Найденный фрагмент PII: границы (индексы char) в исходном тексте. */
public record Finding(String kind, int start, int end, String value) {}

/** valid == null — проверки нет, только формат. */
private record Detector(String kind, Pattern re, Predicate<String> valid) {}

// Порядок = приоритет при пересечениях: сначала то, что подтверждено контрольной суммой.
private static final List<Detector> DETECTORS = List.of(
        new Detector("CARD", Pattern.compile("\\b(?:\\d{4}[ -]){3}\\d{4}\\b|\\b\\d{13,19}\\b"), Pii::luhn),
        new Detector("SNILS", Pattern.compile("\\b\\d{3}-?\\d{3}-?\\d{3}[ -]?\\d{2}\\b"), Pii::snils),
        new Detector("INN", Pattern.compile("\\b\\d{12}\\b|\\b\\d{10}\\b"), Pii::inn),
        new Detector("EMAIL", Pattern.compile("[\\w.+-]+@[\\w-]+(?:\\.[\\w-]+)+"), null),
        new Detector("PHONE", Pattern.compile("(?:\\+7|\\b8)[ (-]*\\d{3}[ )-]*\\d{3}[ -]?\\d{2}[ -]?\\d{2}\\b"), null),
        // Паспорт РФ: 4 цифры серии + 6 цифр номера. Контрольной суммы нет — без пробела
        // перед номером не ловим, иначе каждое 10-значное число станет «паспортом».
        new Detector("PASSPORT", Pattern.compile("\\b\\d{2} ?\\d{2} \\d{6}\\b"), null));

/** Непересекающиеся находки, отсортированные по позиции. */
public static List<Finding> find(String text) {
    List<Finding> all = new ArrayList<>();
    for (Detector d : DETECTORS) {
        Matcher m = d.re().matcher(text);
        while (m.find()) {
            String v = m.group();
            if (d.valid() != null && !d.valid().test(digitsOnly(v))) continue;
            all.add(new Finding(d.kind(), m.start(), m.end(), v));
        }
    }
    // all уже упорядочен по приоритету детектора; берём находку, если она не пересекается с принятыми.
    // ponytail: O(n²) по числу находок — для сообщений и документов хватает, для гигабайтных дампов нужен interval tree.
    List<Finding> out = new ArrayList<>();
    for (Finding f : all) {
        if (out.stream().noneMatch(o -> f.start() < o.end() && o.start() < f.end())) out.add(f);
    }
    out.sort(Comparator.comparingInt(Finding::start));
    return out;
}

// Finding — найденный фрагмент PII: байтовые границы в исходном тексте.
type Finding struct {
	Kind       string // EMAIL, PHONE, CARD, INN, SNILS, PASSPORT
	Start, End int
	Value      string
}

type detector struct {
	kind  string
	re    *regexp.Regexp
	valid func(digits string) bool // nil — проверки нет, только формат
}

// Порядок = приоритет при пересечениях: сначала то, что подтверждено контрольной суммой.
var detectors = []detector{
	{"CARD", regexp.MustCompile(`\b(?:\d{4}[ -]){3}\d{4}\b|\b\d{13,19}\b`), luhn},
	{"SNILS", regexp.MustCompile(`\b\d{3}-?\d{3}-?\d{3}[ -]?\d{2}\b`), snils},
	{"INN", regexp.MustCompile(`\b\d{12}\b|\b\d{10}\b`), inn},
	{"EMAIL", regexp.MustCompile(`[\w.+-]+@[\w-]+(?:\.[\w-]+)+`), nil},
	{"PHONE", regexp.MustCompile(`(?:\+7|\b8)[ (-]*\d{3}[ )-]*\d{3}[ -]?\d{2}[ -]?\d{2}\b`), nil},
	// Паспорт РФ: 4 цифры серии + 6 цифр номера. Контрольной суммы нет — без пробела
	// перед номером не ловим, иначе каждое 10-значное число станет «паспортом».
	{"PASSPORT", regexp.MustCompile(`\b\d{2} ?\d{2} \d{6}\b`), nil},
}

// Find возвращает непересекающиеся находки, отсортированные по позиции.
func Find(text string) []Finding {
	var all []Finding
	for _, d := range detectors {
		for _, m := range d.re.FindAllStringIndex(text, -1) {
			v := text[m[0]:m[1]]
			if d.valid != nil && !d.valid(digitsOnly(v)) {
				continue
			}
			all = append(all, Finding{Kind: d.kind, Start: m[0], End: m[1], Value: v})
		}
	}
	// all уже упорядочен по приоритету детектора; берём находку, если она не пересекается с принятыми.
	// ponytail: O(n²) по числу находок — для сообщений и документов хватает, для гигабайтных дампов нужен interval tree.
	var out []Finding
	for _, f := range all {
		overlap := false
		for _, o := range out {
			if f.Start < o.End && o.Start < f.End {
				overlap = true
				break
			}
		}
		if !overlap {
			out = append(out, f)
		}
	}
	sort.Slice(out, func(i, j int) bool { return out[i].Start < out[j].Start })
	return out
}

static String digitsOnly(String s) {
    StringBuilder b = new StringBuilder();
    for (char c : s.toCharArray()) if (c >= '0' && c <= '9') b.append(c);
    return b.toString();
}

/** Контрольная сумма номеров карт (ISO/IEC 7812). */
static boolean luhn(String d) {
    int sum = 0;
    for (int i = d.length() - 1; i >= 0; i--) {
        int n = d.charAt(i) - '0';
        if ((d.length() - 1 - i) % 2 == 1) {
            n *= 2;
            if (n > 9) n -= 9;
        }
        sum += n;
    }
    return sum % 10 == 0;
}

/** Контрольные цифры ИНН: 10 знаков (организация) или 12 (физлицо, ИП). */
static boolean inn(String d) {
    return switch (d.length()) {
        case 10 -> innCheck(d, 2, 4, 10, 3, 5, 9, 4, 6, 8) == d.charAt(9) - '0';
        case 12 -> innCheck(d, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8) == d.charAt(10) - '0'
                && innCheck(d, 3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8) == d.charAt(11) - '0';
        default -> false;
    };
}

private static int innCheck(String d, int... w) {
    int s = 0;
    for (int i = 0; i < w.length; i++) s += w[i] * (d.charAt(i) - '0');
    return s % 11 % 10;
}

/**
 * Контрольное число СНИЛС: веса 9…1 по первым 9 цифрам, затем mod 101 (100 и 101 → 00).
 * Номера не больше 001-001-998 не проверяются — для детектора считаем их невалидными.
 */
static boolean snils(String d) {
    if (d.length() != 11 || d.substring(0, 9).compareTo("001001998") <= 0) return false;
    int s = 0;
    for (int i = 0; i < 9; i++) s += (d.charAt(i) - '0') * (9 - i);
    s %= 101;
    if (s == 100) s = 0;
    return s == (d.charAt(9) - '0') * 10 + (d.charAt(10) - '0');
}

func digitsOnly(s string) string {
	return strings.Map(func(r rune) rune {
		if r >= '0' && r <= '9' {
			return r
		}
		return -1
	}, s)
}

// luhn — контрольная сумма номеров карт (ISO/IEC 7812).
func luhn(d string) bool {
	sum := 0
	for i := len(d) - 1; i >= 0; i-- {
		n := int(d[i] - '0')
		if (len(d)-1-i)%2 == 1 {
			n *= 2
			if n > 9 {
				n -= 9
			}
		}
		sum += n
	}
	return sum%10 == 0
}

// inn — контрольные цифры ИНН: 10 знаков (организация) или 12 (физлицо, ИП).
func inn(d string) bool {
	check := func(w []int) int {
		s := 0
		for i, k := range w {
			s += k * int(d[i]-'0')
		}
		return s % 11 % 10
	}
	switch len(d) {
	case 10:
		return check([]int{2, 4, 10, 3, 5, 9, 4, 6, 8}) == int(d[9]-'0')
	case 12:
		return check([]int{7, 2, 4, 10, 3, 5, 9, 4, 6, 8}) == int(d[10]-'0') &&
			check([]int{3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8}) == int(d[11]-'0')
	}
	return false
}

// snils — контрольное число СНИЛС: веса 9…1 по первым 9 цифрам, затем mod 101 (100 и 101 → 00).
// Номера не больше 001-001-998 не проверяются — для детектора считаем их невалидными.
func snils(d string) bool {
	if len(d) != 11 || d[:9] <= "001001998" {
		return false
	}
	s := 0
	for i := 0; i < 9; i++ {
		s += int(d[i]-'0') * (9 - i)
	}
	s %= 101
	if s == 100 {
		s = 0
	}
	return s == int(d[9]-'0')*10+int(d[10]-'0')
}

/** Текст без PII и словарь токен → исходное значение. */
public record Redacted(String text, Map<String, String> vault) {}

/**
 * Заменяет PII. key == null — маскирование ([CARD]); иначе — псевдонимизация:
 * [CARD:3f9a1c2b] = HMAC(key, тип+нормализованное значение). Одно и то же значение даёт
 * один и тот же токен во всех документах — можно считать, джойнить и искать по нему, не видя PII.
 * Словарь (vault) нужен только для обратной подстановки: храните его отдельно,
 * с отдельными правами и сроком жизни, или не храните вовсе, если восстановление не нужно.
 */
public record Redactor(byte[] key) {
    public Redacted redact(String text) {
        StringBuilder b = new StringBuilder();
        Map<String, String> vault = new HashMap<>();
        int last = 0;
        for (Finding f : find(text)) {
            b.append(text, last, f.start());
            String tok = "[" + f.kind() + "]";
            if (key != null) {
                tok = "[" + f.kind() + ":" + pseudonym(f) + "]";
                vault.put(tok, f.value());
            }
            b.append(tok);
            last = f.end();
        }
        b.append(text.substring(last));
        return new Redacted(b.toString(), vault);
    }

    private String pseudonym(Finding f) {
        String norm = f.value().toLowerCase(Locale.ROOT);
        if (!f.kind().equals("EMAIL")) {
            norm = digitsOnly(f.value());
            if (f.kind().equals("PHONE") && norm.startsWith("8")) {
                norm = "7" + norm.substring(1); // 8 912… и +7 912… — один и тот же номер
            }
        }
        try {
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(key, "HmacSHA256"));
            byte[] sum = mac.doFinal((f.kind() + ":" + norm).getBytes(StandardCharsets.UTF_8));
            return HexFormat.of().formatHex(sum, 0, 4); // 32 бита: читаемо; для больших баз берите 8+ байт
        } catch (GeneralSecurityException e) {
            throw new IllegalStateException(e);
        }
    }
}

/** Обратная подстановка, например в ответе модели перед показом пользователю. */
public static String restore(String text, Map<String, String> vault) {
    for (var e : vault.entrySet()) text = text.replace(e.getKey(), e.getValue());
    return text;
}

// Redactor заменяет PII. Key == nil — маскирование ([CARD]); иначе — псевдонимизация:
// [CARD:3f9a1c2b] = HMAC(key, тип+нормализованное значение). Одно и то же значение даёт
// один и тот же токен во всех документах — можно считать, джойнить и искать по нему, не видя PII.
type Redactor struct {
	Key []byte
}

// Redact возвращает текст без PII и словарь токен → исходное значение.
// Словарь (vault) нужен только для обратной подстановки: храните его отдельно,
// с отдельными правами и сроком жизни, или не храните вовсе, если восстановление не нужно.
func (r Redactor) Redact(text string) (string, map[string]string) {
	var b strings.Builder
	vault := map[string]string{}
	last := 0
	for _, f := range Find(text) {
		b.WriteString(text[last:f.Start])
		tok := "[" + f.Kind + "]"
		if r.Key != nil {
			tok = "[" + f.Kind + ":" + r.pseudonym(f) + "]"
			vault[tok] = f.Value
		}
		b.WriteString(tok)
		last = f.End
	}
	b.WriteString(text[last:])
	return b.String(), vault
}

func (r Redactor) pseudonym(f Finding) string {
	norm := strings.ToLower(f.Value)
	if f.Kind != "EMAIL" {
		norm = digitsOnly(f.Value)
		if f.Kind == "PHONE" && strings.HasPrefix(norm, "8") {
			norm = "7" + norm[1:] // 8 912… и +7 912… — один и тот же номер
		}
	}
	m := hmac.New(sha256.New, r.Key)
	m.Write([]byte(f.Kind + ":" + norm))
	return hex.EncodeToString(m.Sum(nil)[:4]) // 32 бита: читаемо; для больших баз берите 8+ байт
}

// Restore — обратная подстановка, например в ответе модели перед показом пользователю.
func Restore(text string, vault map[string]string) string {
	pairs := make([]string, 0, 2*len(vault))
	for tok, v := range vault {
		pairs = append(pairs, tok, v)
	}
	return strings.NewReplacer(pairs...).Replace(text)
}

Маскирование или псевдонимизация

• Псевдонимизированные данные остаются персональными (GDPR, recital 26): это мера безопасности (ст. 32), а не выход из-под закона. Анонимизация для свободного текста почти недостижима. Как это устроено в 152-ФЗ — в уроке про логи.
• Ключ HMAC — секрет в KMS с ротацией; ротация рвёт связность, планируйте её как миграцию. Короткий токен на десятках миллионов значений даёт коллизии: для джойнов берите 8+ байт.
• Модель портит токены: перефразирует «[NAME:1a2b]» в «клиент 1a2b». Проверяйте, что все токены ответа восстановлены и неизвестных нет.

Где редактировать

Версии датасетов и разметка

Чтобы ответить, почему вчера recall@5 был 0.82, а сегодня 0.77, нужно знать, что изменилось. Кроме кода, промпта и модели это корпус, парсер, эмбеддинг-модель и golden set. Версионировать нужно всё, от чего зависит метрика: сырой корпус (ревизии и хэши источников), результат парсинга (версия парсера — часть версии данных: обновили Docling — прогоняйте evals), индекс (корпус × чанкер × эмбеддинг-модель), golden set, обучающие наборы и гайдлайн разметки. Отчёт прогона evals хранит версии всех частей (модуль 8), а цепочка «ответ → индекс → парсер → ревизия документа» восстанавливается по трейсу.

# datasets/golden/manifest.yaml — коммитится вместе с кодом evals
name: docrag-golden
version: 2026-10-01.3
guideline: docs/labeling/golden-v4.md      # по какой версии гайдлайна размечено
files:
  - path: golden.jsonl
    sha256: 9f2c…e41a
    rows: 186
    slices: {table_questions: 31, no_answer: 24, en: 18}
source:
  corpus_snapshot: s3://docrag-corpus/snapshots/2026-09-28/
  parser: docling 2.135.0
changes: "+12 кейсов из прод-фидбека, 3 эталона обновлены после смены политики возвратов"

Разметка: гайдлайн важнее инструмента

Согласие разметчиков (Cohen's κ) и error analysis разобраны в модуле 8. Низкое согласие почти всегда означает плохой гайдлайн, а не плохих разметчиков. В гайдлайне должны быть: задача и что будет с меткой дальше; метки с определениями и примерами «да» и «нет»; дерево решений для пограничных случаев («ответ верный, но без цитаты → FAIL»; «по устаревшей версии документа → FAIL, тег stale»); выход «не могу оценить»; версия и changelog — изменили определение, перечитайте затронутые метки.

• Контроль качества: контрольные задания с известным ответом вперемешку с обычными, перекрёстная разметка 10–20% и арбитраж эксперта.
• Инструменты (по состоянию на октябрь 2026): Label Studio (Apache-2.0) активно развивается; Argilla (Apache-2.0) после перехода в Hugging Face в 2024 году находится в режиме поддержки: только исправления ошибок, без новых функций; doccano (MIT) развивается медленно. Для старта хватает внутренней страницы с трассой целиком и горячими клавишами PASS/FAIL.
• PII и доступ: редакция до разметки, роли, договор с подрядчиком, запрет выгрузки.

Active learning: что размечать первым

Active learning — выбирать для разметки примеры, которые сильнее всего улучшат систему. Для LLM-продукта это неуверенные случаи (низкий скор retrieval, judge и эвристики разошлись, разные прогоны дали разные ответы), новые кластеры запросов, которых нет в golden set, высокая цена ошибки (деньги, право, безопасность) и сигналы из прода. Активная выборка смещена к трудным случаям, поэтому для честной оценки держите отдельную случайную выборку.

Фидбек и data flywheel

Data flywheel (маховик данных) — замкнутый цикл: прод поставляет примеры ошибок, из них получаются кейсы для evals и данные для улучшений, улучшения через eval-гейт возвращаются в прод. Без маховика golden set застывает на дне запуска, а прод уходит вперёд.

• Явный фидбек (👍/👎, комментарий, исправление оператором) точный, но редкий (обычно меньше процента ответов) и смещённый: его чаще оставляют недовольные.
• Неявный (регенерация, переформулирование, эскалация, копирование, правка черновика) — подробно в модуле 8.
• Привязка к трассе: фидбек без trace_id бесполезен — нужны запрос, найденные чанки и версии.

CREATE TABLE feedback (
    id          bigserial   PRIMARY KEY,
    trace_id    text        NOT NULL,              -- запрос, чанки, версии
    user_hmac   text        NOT NULL,              -- HMAC(user_id), не сам id (модуль 9)
    kind        text        NOT NULL CHECK (kind IN ('thumb', 'regenerate', 'copy', 'escalate', 'edit')),
    value       smallint,                          -- +1 / -1 для thumb
    comment     text,                              -- PII редактируется до записи
    prompt_ver  text        NOT NULL,
    index_ver   text        NOT NULL,
    created_at  timestamptz NOT NULL DEFAULT now(),
    triaged_at  timestamptz,                       -- когда разобрали: скорость маховика
    outcome     text                               -- golden_case / doc_fix / prompt_fix / not_a_bug
);
CREATE INDEX feedback_untriaged ON feedback (created_at) WHERE triaged_at IS NULL;

Путь сигнала: отбор (все 👎 и эскалации, случайная выборка 0.5–2% трафика, активная выборка) → PII-редакция → разбор (error analysis: сломались retrieval, документ, промпт, модель или ожидания) → исход (кейс в golden set, задача владельцу документа, правка промпта, пример для обучения в модуле 10, «не баг») → релиз через eval-гейт, где новый кейс сначала падает, потом проходит. Брать логи пользователей для evals и обучения можно не всегда: нужны правовое основание и совместимость с целью сбора (следующий урок), а также условия договора с провайдером.

Метрики маховика: время цикла от 👎 до кейса в CI (медиана в днях — самая честная метрика того, учится ли система); доля разобранных сигналов и бэклог; прирост golden set и покрытие прод-кластеров; доля повторяющихся ошибок (высокая — фиксы не доезжают или кейс не ловит регрессию); тренд качества по релизам на фиксированном срезе; стоимость размеченного кейса.

Логи диалогов: что хранить, сколько и кому показывать

Логи диалогов нужны для отладки, evals, маховика данных и расследования инцидентов. Это же самое опасное хранилище PII в системе: тексты, которые пользователи писали, не думая, где они окажутся. Задача — хранить достаточно для качества и аудита и не больше. Ниже — инженерные следствия GDPR и 152-ФЗ. Применимость к вашей системе и правовые основания определяет юрист.

• Срок реализуется механизмом: TTL в ClickHouse, lifecycle-правила S3, партиции по дням с DROP PARTITION. Срок, который соблюдают «вручную раз в квартал», не соблюдается.
• Анонимизация логов: HMAC вместо user_id, редакция до записи, тексты в отдельном хранилище, в трейсах только ссылки (модуль 9), доступ к сырым данным по заявке с аудитом.
• Логи провайдера: у внешнего API свои сроки хранения. Zero data retention, регион обработки и договор — часть архитектуры.

Удаление по запросу

Нужен реестр мест хранения с ключом поиска по пользователю: прод-БД, логи, трейсы и фидбек (по HMAC); векторный индекс, если индексируется пользовательский контент (по owner_id чанка); golden set, очереди разметки и выгрузки подрядчикам (по ссылке на трассу); кэши ответов; бэкапы — через crypto-shredding (данные пользователя шифруются его ключом, удаление ключа делает недоступными и копии); провайдер — по договору. Дообученную модель «разучить» человека нельзя, поэтому сырые персональные данные в обучение не берут. Удаление — скрипт с тестом на синтетическом пользователе и отчётом о выполнении, а не инструкция в wiki.

GDPR: что следует для инженера

Псевдонимизированные данные по общему правилу персональные (recital 26). Суд ЕС в деле C-413/23 P (EDPS v SRB, 4 сентября 2025; дело по Регламенту 2018/1725 для органов ЕС, понятие персональных данных в нём то же, что в GDPR) уточнил, что для получателя, который не может вернуть личность, они могут не быть персональными; для вас, у кого ключ, — персональные. Поправки к определению персональных данных в Digital Omnibus по GDPR (COM(2025) 837) на октябрь 2026 года не приняты.

152-ФЗ: что следует для инженера (по состоянию на октябрь 2026)

Ответственность с 30 мая 2025 (420-ФЗ): штрафы для юрлиц за утечку зависят от объёма — до 15 млн ₽, за биометрию до 20 млн ₽; за повторную утечку — 1–3% выручки, но не меньше 20–25 млн и не больше 500 млн ₽. За нарушение локализации — 1–6 млн ₽, повторно 6–18 млн ₽. С 11 декабря 2024 действует ст. 272.1 УК о незаконном использовании и передаче персональных данных, полученных незаконно. Отдельно: 26 июля 2026 подписан Федеральный закон № 243-ФЗ «О поддержке развития технологий искусственного интеллекта в Российской Федерации» (в силе с 1 сентября 2026, часть норм — с 1 марта 2027). 152-ФЗ он не меняет, но вводит требования к «суверенным» и «национальным» большим фундаментальным моделям (от 1 млрд параметров) и с 1 марта 2027 позволяет правительству определить случаи, где допускаются только они; для систем, работающих на этот день, — переходный период до 1 сентября 2032 при обработке и хранении данных в России. Если ваш продукт может оказаться в такой сфере, это ограничение на выбор модели.

EU AI Act

EU AI Act (Regulation (EU) 2024/1689) регулирует ИИ по уровням риска и действует экстерриториально: на всех, кто выводит AI-системы на рынок ЕС, и на провайдеров и эксплуатантов из третьих стран, если результат работы системы используется в ЕС (ст. 2). Российская компания с клиентами в ЕС может под него попасть. Ниже — что закон требует и как это меняет архитектуру. Применимость к конкретной системе определяет юрист, урок не является юридической консультацией.

• Провайдер GPAI-модели (general-purpose AI) — Anthropic, OpenAI, Mistral. Глава V: техническая документация, информация для интеграторов, политика по авторскому праву, публичное описание обучающих данных, для моделей с системным риском — оценка и снижение рисков. Вы становитесь провайдером GPAI, только если выпускаете свою модель общего назначения или значительно модифицируете чужую; по руководству Еврокомиссии обычный LoRA-тюнинг под узкую задачу к этому, как правило, не относится.
• Провайдер AI-системы (provider) разрабатывает систему и выводит её на рынок под своим именем: чат-бот поддержки на Claude, который вы даёте клиентам, — ваша AI-система.
• Эксплуатант (deployer) применяет систему под своей ответственностью: банк, внедривший чужой скоринг, или ваша компания со внутренним инструментом.

Даты (по состоянию на октябрь 2026)

Сроки для high-risk систем перенёс Digital Omnibus on AI. Его предложили 19 ноября 2025 года (COM(2025) 836), политическое соглашение достигнуто 7 мая 2026 года. Итоговый текст — Regulation (EU) 2026/1744 от 8 июля 2026 года, опубликован в Official Journal 24 июля 2026 года, вступил в силу 27 июля 2026 года. В предложении начало high-risk требований зависело от готовности стандартов и имело крайние даты. В принятом тексте даты фиксированные: 2 декабря 2027 года для приложения III и 2 августа 2028 года для приложения I.

Ещё в Omnibus: обязанность по AI literacy (ст. 4) смягчена до «принимать меры для поддержки» грамотности персонала без гарантии уровня; новая ст. 4a разрешает обрабатывать особые категории данных для поиска смещений только при строгой необходимости; упрощения распространены на small mid-caps. Отдельный пакет поправок к GDPR (COM(2025) 837) на октябрь 2026 года не принят.

Категории риска

Категории совмещаются: high-risk система, которая общается с людьми, выполняет и ст. 50. Для приложения III есть исключение ст. 6(3): система не high-risk, если не создаёт значительного риска и выполняет узкую процедурную или подготовительную задачу, улучшает результат уже завершённой работы человека или ищет отклонения от прежних решений, не заменяя оценку человека. Исключение не работает при профилировании людей. Провайдер, который на него опирается, документирует оценку (ст. 6(4)) и регистрирует систему.

Как определить категорию своей фичи

1. Сфера: есть ли пользователи или результаты работы системы в ЕС?
2. Роль: провайдер системы, эксплуатант или провайдер GPAI-модели?
3. Ст. 5: нет ли запрещённой практики в назначении или в разумно предсказуемом злоупотреблении?
4. High-risk: относится ли назначение (intended purpose) к пункту приложения III или к приложению I? Если да — работает ли ст. 6(3), нет ли профилирования?
5. Ст. 50: общение с людьми, генерация контента, эмоции, дипфейки?
6. Запишите вывод со ссылками на статьи и отдайте юристу. Пересматривайте при смене назначения: «добавим скоринг кандидатов» делает HR-чат-бот high-risk.

Что меняется в архитектуре

Документация системы

Документация AI-системы отвечает на вопросы аудитора, юриста, дежурного и enterprise-клиента: что система делает и чего не делает, на каких данных и моделях работает, как её проверяли и с каким результатом, кто и как может её остановить. Если ответы собирают по Slack, документации нет.

Техническая документация high-risk системы по AI Act (ст. 11, приложение IV) — по сути подробная system card с журналом изменений; реестр обработки (ст. 30 GDPR) и DPIA ссылаются на datasheet; анкеты безопасности enterprise-клиентов спрашивают то же самое.

Docs as code

• В репозитории, ревью в одном PR с изменением поведения.
• Генерируемые поля не пишутся руками: версии — из реестра, метрики — из прогона evals; CI падает, если system card расходится с конфигурацией деплоя.
• Ограничения — конкретные: не «модель может ошибаться», а «на вопросах по таблицам тарифов accuracy 81% против 93% в среднем; ответы без цитаты помечаются в UI».

# docs/system-card.yaml — система из проекта A; поля с пометкой generated заполняет CI
system: docrag-ask
version: 2026.10.2
owner: team-support-ai (on-call: #support-ai-oncall)
purpose: ответы на вопросы сотрудников поддержки по внутренней базе знаний, с цитатами
users: сотрудники поддержки (≈ 300), не клиенты; ответ — подсказка, решение принимает оператор
out_of_scope: юридические и медицинские консультации, решения о возвратах, ответы клиентам без проверки
ai_act:                      # оценка команды, утверждена юристом 2026-09-20
  category: transparency     # ст. 50(1): UI сообщает, что отвечает ИИ
  annex_iii: none            # не HR, не кредит, не доступ к услугам
  rationale: docs/compliance/ai-act-assessment.md
models:                      # generated: из реестра
  answer: {model: claude-sonnet-5, prompt: answer@v7+3f9a1c2b, effort: low}
  rerank: {model: claude-haiku-4-5, prompt: rerank@v2+9e01d4aa}
data:
  corpus: confluence:SUPPORT, confluence:BILLING; snapshot 2026-09-28; parser docling 2.135.0
  pii: редакция до индексации и логов (examples/m11-data); vault не используется
  datasheet: docs/datasheets/corpus.md
evals:                       # generated: последний прогон CI
  golden: docrag-golden@2026-10-01.3 (n=186)
  recall_at_5: 0.86
  faithfulness: 0.94
  answer_accuracy: {overall: 0.91, table_questions: 0.81, no_answer: 0.88}
  red_team: 42 атаки, успешных 1 (ASR 2.4%), модуль 7
limitations:
  - вопросы по таблицам тарифов: accuracy 0.81, в UI пометка «проверьте по источнику»
  - документы старше 2024 года не проиндексированы
oversight: оператор видит источники и может пометить ответ; kill switch — флаг docrag.enabled
monitoring: дашборд качества (judge на 2% трафика), 👎-очередь, SLO из модуля 9
logs: метаданные 13 мес., тексты 30 дней (маскированные), удаление по запросу — runbook docs/dsar.md
changelog: docs/changelog.md

Практика

Задания продолжают сквозные проекты: A — RAG по документации, B — eval-набор и CI. Вы улучшаете свою систему, а не решаете отдельные задачки.

Самопроверка

Вопросы с собеседований

Источники

• EUR-Lex — Regulation (EU) 2024/1689 (AI Act) (ст. 2–6, 9–15, 19, 26, 27, 49, 50, 72, 73, 99, 101, 113, приложения I, III, IV)
• EUR-Lex — Regulation (EU) 2026/1744 (Digital Omnibus on AI) (новые даты high-risk, запреты с 2 декабря 2026, ст. 4 и 4a) и новость Еврокомиссии о вступлении в силу
• AI Act Service Desk — timeline of implementation (сводный календарь с поправками Omnibus) и страница Еврокомиссии об AI Act
• European Commission — General-Purpose AI Code of Practice и руководство для провайдеров GPAI
• European Commission — Code of Practice on marking and labelling of AI-generated content и руководство по ст. 50
• EUR-Lex — Regulation (EU) 2016/679 (GDPR) (ст. 4(5), 5, 6, 15–22, 25, 28, 30, 32, 33, 35, 44–49, recital 26)
• Суд ЕС — C-413/23 P EDPS v SRB, пресс-релиз 107/25 (псевдонимизированные данные с точки зрения получателя)
• КонсультантПлюс — Федеральный закон от 27.07.2006 № 152-ФЗ «О персональных данных» (ст. 3, 6, 9, 12, 14, 16, 18, 20–22, актуальная редакция) и ст. 13.11 КоАП РФ (штрафы)
• Федеральный закон от 28.02.2025 № 23-ФЗ (локализация), от 26.07.2026 № 265-ФЗ (трансграничная передача) и от 26.07.2026 № 243-ФЗ (технологии ИИ) — официальное опубликование
• Docling и Docling Technical Report; IBM — granite-docling-258M
• Unstructured — open source, pymupdf4llm, Marker, MinerU, Tesseract (лицензии и версии — в README и LICENSE)
• Presidio и документация (анализатор, операторы анонимизации, поддержка языков); Natasha (NER для русского)
• Sweeney, 2000 — Simple Demographics Often Identify People Uniquely (87% жителей США уникальны по индексу, полу и дате рождения)
• Charikar, 2002 — Similarity estimation techniques from rounding algorithms (SimHash); Manku, Jain, Das Sarma, 2007 — Detecting near-duplicates for web crawling (64 бита, k = 3, поиск по блокам); Broder, 1997 — On the resemblance and containment of documents (MinHash); datasketch
• DVC и DVC joins lakeFS; lakeFS — переход на BUSL; Git LFS; Hugging Face datasets — загрузка по ревизии
• Label Studio; Settles, 2009 — Active Learning Literature Survey
• Mitchell et al., 2019 — Model Cards for Model Reporting; Gebru et al. — Datasheets for Datasets; Anthropic — system cards (пример system card модели)
• Chip Huyen — AI Engineering (глава 8 «Dataset Engineering», глава 10 о пользовательском фидбеке)