Free-LLMs

Онтологии и графы знаний для LLM: когда они нужны и как их подключить

Когда граф окупается, как подключить его к модели и как проверять извлечённые факты.

Graphs
Онтологии и графы
🤖
Мониторинг бесплатных моделей в Telegram Бот @freellms_bot присылает новые бесплатные модели и AI-акции.
→

Онтология и граф знаний нужны LLM, когда ответ строится на связях между объектами, а не на поиске похожего абзаца: «какие сервисы пострадают, если упадёт эта база», «кто отвечает за всё, от чего зависит этот продукт», «какие товары совместимы с этой моделью». Онтология задаёт словарь (классы объектов, допустимые отношения, ограничения), граф знаний хранит сами факты в виде троек «объект, отношение, объект». Для вопросов вида «найди в документах, что сказано про возврат» хватает обычного RAG. Ниже: что это такое, когда граф окупается, три способа подключить его к модели и рабочий пример с проверкой фактов по схеме.

Что такое онтология и граф знаний

Базовая модель данных называется RDF. В руководстве по RDF 1.1 данные описаны как набор утверждений, каждое из которых связывает один ресурс с другим или со значением; ресурсы идентифицируются IRI, поэтому по одному идентификатору можно получить дополнительные данные из других источников. Язык онтологий OWL 2 служит для записи и обмена знаниями о предметной области и рассуждения над ними; его базовые понятия это аксиомы (утверждения онтологии), сущности (объекты, категории и отношения) и выражения, из которых строятся сложные описания. Для проверки данных по схеме есть SHACL: проверка берёт граф данных и граф форм (shapes graph) и выдаёт отчёт о нарушениях.

На практике не обязательно использовать весь стек семантического веба. Те же идеи реализуют в графовой базе (Neo4j), в обычной реляционной таблице рёбер или просто в коде. Главное разделение такое:

  • Схема (онтология): какие типы объектов бывают (Сервис, Команда, Инцидент), какие отношения допустимы и между какими типами («Сервис зависит от Сервиса», «Инцидент затрагивает Сервис»).
  • Данные (граф знаний): конкретные объекты и их связи, соответствующие схеме.
  • Правила: ограничения («у сервиса ровно одна команда-владелец», «зависимости не образуют цикл»).

Когда граф нужен, а когда достаточно поиска

Тип вопросаЧто работает лучше
«Что написано в инструкции про X»Векторный или гибридный поиск по документам
«Сколько заказов за неделю»SQL по базе, не граф
«Что зависит от X» (цепочки в несколько шагов)Граф: обход связей
«Кто отвечает за всё, что затронул инцидент»Граф: путь от инцидента к командам
«О чём в целом весь корпус документов»GraphRAG с сообществами и сводками
Нужна проверяемость: каждый факт со ссылкой на узел и источникГраф с указанием происхождения тройки
Нужны жёсткие ограничения («сервис не может зависеть от самого себя»)Онтология и проверка схемой

Признаки, что граф стоит строить: в данных много типизированных объектов с устойчивыми связями; вопросы требуют обхода нескольких шагов или агрегации по связям; ошибки по связям обходятся дорого; одни и те же сущности называются в документах по-разному и их нужно свести к одному идентификатору. Если же данные это в основном тексты с вопросами по смыслу, затраты на разметку и поддержку графа не окупятся. Метод всегда нужно сравнить с обычным RAG на своём наборе вопросов, как описано в статье как улучшить RAG.

Три способа подключить граф к LLM

1. Граф как источник фактов

Вы берёте вопрос, находите в нём сущности, достаёте из графа окрестность (соседей на один-два шага, нужные пути) и кладёте найденные тройки в промпт. Модель формулирует ответ только по ним. Это самый простой вариант: граф даёт точные факты, модель даёт язык. Обзор «Unifying Large Language Models and Knowledge Graphs: A Roadmap» описывает как раз такое сочетание: графы знаний хранят явные факты и дают интерпретируемость, тогда как LLM остаются «чёрным ящиком» с проблемами с фактами; в то же время графы сложно строить и они постоянно меняются.

2. Модель пишет запрос к графу

Модель превращает вопрос в запрос на языке графовой базы (Cypher, SPARQL), запрос выполняется, результат идёт в ответ. Подход точнее для агрегаций и обхода, но рискованнее: модель может написать неверный или тяжёлый запрос. Меры защиты: доступ только на чтение, лимит времени и числа строк, передача модели схемы графа в промпте, проверка запроса по списку разрешённых типов и отношений до выполнения. Метод Think-on-Graph идёт дальше: модель итеративно исследует граф, шаг за шагом выбирая релевантные связи; авторы описывают метод как не требующий дополнительного обучения и сообщают, что с малыми моделями он в ряде сценариев превосходит GPT-4. Проверяйте такое на своих данных, но направление интересно: небольшая модель плюс граф вместо большой модели без него.

3. GraphRAG: граф строится из текстов

Когда структурированных данных нет, граф извлекают из текстов самой LLM. Подход GraphRAG из Microsoft Research строит индекс в два этапа: сначала модель выделяет из документов граф сущностей, затем заранее создаются сводки по сообществам тесно связанных сущностей. На вопрос каждая сводка даёт частичный ответ, а затем они объединяются. Авторы показывают преимущество над обычным RAG для «глобальных» вопросов по корпусу объёмом около миллиона токенов в полноте и разнообразии ответов. По документации проекта, индексация делит корпус на текстовые блоки, извлекает сущности, связи и ключевые утверждения, кластеризует граф методом Лейдена и пишет сводки сообществ снизу вверх. Режимы запроса: глобальный (вопросы о корпусе в целом), локальный (о конкретных сущностях и их соседях), DRIFT (локальный с контекстом сообществ) и базовый (обычный поиск top-k). Практический вывод: индексация требует вызовов LLM по всему корпусу, поэтому заранее оцените стоимость на малой выборке; бесплатные модели из каталога подходят для пробного прогона, а размер модели влияет на качество извлечения. Экосистема графовых баз тоже даёт готовые инструменты: официальный пакет neo4j-graphrag содержит поиск по векторам в графе и конструктор графа знаний, а в числе поддерживаемых LLM есть Ollama.

Как построить: пошагово

  1. Выпишите 20-30 реальных вопросов, на которые граф должен отвечать. Они определяют схему: нужны только те классы и отношения, которые участвуют в этих вопросах.
  2. Опишите схему минимально: 5-15 классов и 10-20 отношений с указанием типов начала и конца. Усложнять можно потом.
  3. Определите источники. Структурированные данные (CMDB, каталог товаров, таблицы) загружаются кодом и надёжнее всего. Тексты обрабатываются моделью, но каждую извлечённую тройку нужно проверять по схеме (см. код ниже) и хранить ссылку на исходный фрагмент.
  4. Решите вопрос с идентичностью: «Billing API», «биллинг» и «billing-api» это один узел. Заведите справочник синонимов и сливайте дубли до загрузки.
  5. Выберите хранилище: для сотен и тысяч узлов хватает таблицы рёбер в PostgreSQL (статья про pgvector) или словаря в памяти, для миллионов и сложных обходов подойдёт графовая база.
  6. Подключите граф к модели одним из трёх способов и сравните с обычным RAG на тех же вопросах.
  7. Настройте обновление: когда меняется источник, соответствующие узлы и рёбра обновляются, а не копятся (общая логика как в статье как обновлять знания LLM).

Пример: проверка извлечённых фактов по схеме и обход зависимостей

Допустим, мы описываем ИТ-сервисы компании. Схема задаёт допустимые отношения и типы. Кандидаты в граф (например, результат извлечения моделью) проходят проверку: неверные тройки отбрасываются. Затем по графу строится запрос «что затронул инцидент» и формируется набор фактов для промпта.

from collections import defaultdict, deque

SCHEMA = {                       # отношение: (тип субъекта, тип объекта)
    "depends_on": ("Service", "Service"),
    "owned_by": ("Service", "Team"),
    "affects": ("Incident", "Service"),
}
TYPES = {
    "checkout": "Service", "billing-api": "Service", "postgres-main": "Service",
    "team-payments": "Team", "team-data": "Team", "inc-1042": "Incident",
}


def validate(triple):
    s, rel, o = triple
    if rel not in SCHEMA:
        return f"неизвестное отношение: {rel}"
    dom, rng = SCHEMA[rel]
    if TYPES.get(s) != dom or TYPES.get(o) != rng:
        return f"типы не подходят для {rel}: {s} ({TYPES.get(s)}), {o} ({TYPES.get(o)})"
    return None


candidates = [                   # например, результат извлечения из текста моделью
    ("checkout", "depends_on", "billing-api"),
    ("billing-api", "depends_on", "postgres-main"),
    ("billing-api", "owned_by", "team-payments"),
    ("postgres-main", "owned_by", "team-data"),
    ("inc-1042", "affects", "postgres-main"),
    ("checkout", "owned_by", "inc-1042"),       # ошибка модели: владельцем не может быть инцидент
    ("checkout", "uses", "billing-api"),        # такого отношения нет в схеме
]
graph = defaultdict(set)
for t in candidates:
    problem = validate(t)
    if problem:
        print("отклонено:", t, "-", problem)
        continue
    graph[t[1]].add((t[0], t[2]))


def upstream(service: str) -> set[str]:
    """Кто прямо или косвенно зависит от сервиса: обход depends_on в обратную сторону."""
    reverse = defaultdict(set)
    for s, o in graph["depends_on"]:
        reverse[o].add(s)
    seen, queue = set(), deque([service])
    while queue:
        for dep in reverse[queue.popleft()]:
            if dep not in seen:
                seen.add(dep)
                queue.append(dep)
    return seen


def facts_for_prompt(incident: str) -> list[str]:
    hit = {o for s, o in graph["affects"] if s == incident}
    scope = set(hit)
    for svc in hit:
        scope |= upstream(svc)
    owners = {s: o for s, o in graph["owned_by"] if s in scope}
    return ([f"{incident} affects {svc}" for svc in sorted(hit)]
            + [f"{s} depends_on {o}" for s, o in sorted(graph["depends_on"]) if s in scope and o in scope]
            + [f"{s} owned_by {t}" for s, t in sorted(owners.items())])


print(facts_for_prompt("inc-1042"))

Результат: две тройки отклонены, а для инцидента inc-1042 собран список из пяти фактов: что затронуто, цепочка зависимостей до checkout и команды-владельцы. Его подставляют в промпт:

Ответь на вопрос только по фактам ниже. Если фактов недостаточно, так и скажи.
В ответе укажи, какие сервисы затронуты и какие команды надо уведомить.

Факты:
{facts}

Вопрос: Кого уведомить по инциденту inc-1042?

Здесь модели остаётся простая работа, с которой справляется и небольшая (как выбрать размер), а точность по связям обеспечивает код. Для промышленной версии замените словарь на базу и проверку по схеме на SHACL: библиотека pySHACL принимает граф данных и граф форм и возвращает признак соответствия и текст отчёта через функцию validate.

Типичные ошибки

  • Слишком большая схема на старте. Начинайте с вопросов, а не с моделирования «всего мира».
  • Доверие к извлечению без проверки. Модель выдумывает отношения и путает направление; проверка типов и ссылка на исходный фрагмент снижают число таких тройк в графе.
  • Дубли сущностей. Один сервис под тремя именами ломает обход.
  • Всё содержимое графа в промпт. Передавайте окрестность и пути, а не весь граф.
  • Отсутствие замера. Если граф не дал прироста над RAG на ваших вопросах, он лишь усложнил систему.
  • Граф как замена SQL. Агрегации и фильтры по таблицам лучше оставить базе данных.

Где этим пользуются агенты

Граф особенно полезен агентам, которым нужно планировать действия и проверять условия перед вызовом инструментов. Это отдельная тема: как граф знаний помогает ИИ-агенту планировать и проверять действия. Если же вам нужен лёгкий способ извлекать сущности из текстов в граф, посмотрите извлечение сущностей маленькой моделью.

Итого

  • Онтология это схема (классы, отношения, ограничения), граф знаний это данные по ней. Начинать можно с таблицы рёбер и кода.
  • Граф окупается для вопросов про связи, цепочки и агрегации с проверяемым ответом; для вопросов по смыслу текста хватает RAG.
  • Способы подключения: окрестность графа в промпте, запросы Cypher или SPARQL с защитой, GraphRAG из текстов.
  • Каждую извлечённую моделью тройку проверяйте по схеме и храните источник.
  • Сравнивайте с обычным RAG на своих вопросах: граф нужен, только если он даёт прирост.
FL
Редакция Free-LLMsКоманда каталога бесплатных LLM API. Проверяем лимиты провайдеров и тестируем модели и инструменты руками.

Читайте также