Free-LLMs

Как граф знаний помогает ИИ-агенту планировать и проверять действия

Планирует модель, а предусловия инструментов проверяет код по графу состояния.

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

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

Зачем агенту граф, если есть контекст

Типичный агент строится по схеме «подумал, вызвал инструмент, посмотрел результат». Эту схему описывает ReAct: рассуждения и действия чередуются, и действия позволяют обращаться к внешним источникам, например к базам знаний или средам. У такого подхода есть слабое место: порядок шагов и условия живут только в голове модели. Работа LLM+P формулирует проблему так: LLM пока не умеют надёжно решать задачи долгого планирования, тогда как классические планировщики, получив задачу в формальном виде, быстро находят корректный план. Авторы предлагают переводить описание в язык PDDL и отдавать планировщику. Для большинства бизнес-агентов полноценный PDDL избыточен, но идея полезна: описывайте действия формально через предусловия и эффекты и проверяйте их кодом. Граф знаний как раз удобное место для такого описания, потому что объекты, статусы и связи уже представлены в нём. Общую схему агентов смотрите в статье архитектура LLM-агента, а основы графов в статье онтологии и графы знаний для LLM.

Архитектура: пять ролей

РольКто выполняетЧто делает
СостояниеГраф знанийОбъекты и факты: «заказ o1 доставлен», «клиент c1 не проверен», «заказ o1 принадлежит c1»
Каталог инструментовГраф или конфигДля каждого инструмента: параметры, предусловия, запрещающие условия, эффекты, нужно ли подтверждение человека
ПланировщикLLMСтроит план в виде списка шагов в JSON по цели и выдержке из графа
ПроверкаКодСухой прогон плана по копии графа; возвращает первую причину отказа для перепланирования
Исполнение и обновлениеКодПовторно проверяет предусловия на живом состоянии, запрашивает подтверждение, вызывает инструмент, при успехе применяет эффекты к графу

Цикл выглядит так: цель, выборка из графа, план от модели, проверка, при отказе возврат причины модели для исправления плана (обычно достаточно двух-трёх попыток), исполнение шаг за шагом, обновление графа, итог пользователю.

Планировщик: что давать модели

Промпт планировщика состоит из трёх частей: цель в одной фразе, каталог инструментов с предусловиями, написанными словами, и фрагмент графа, относящийся к задаче (не весь граф: сущности из цели, их соседи, статусы). Ответ модели ограничивайте схемой JSON через структурированный вывод (в Ollama это поле format со схемой, в vLLM параметр response_format; по документации Ollama схему полезно ещё и показать в тексте промпта). Пример формата плана:

[
  {"tool": "verify_customer", "args": {"customer": "c1"}},
  {"tool": "create_refund",   "args": {"order": "o1", "customer": "c1"}},
  {"tool": "notify_customer", "args": {"customer": "c1"}}
]

Хорошая практика: просить у модели не только шаги, но и краткое обоснование каждого, чтобы сохранить его в журнале. Небольшая модель обычно справляется с планами из 3-7 шагов при хорошем каталоге, а для длинных задач помогает разбиение цели на подзадачи. Выбор модели под такие задачи разобран в статье маленькие LLM в агенте.

Проверка предусловий: код

Состояние хранится как множество троек. Инструмент описывается объектом с предусловиями (requires), запретами (forbids) и эффектами (adds, removes); шаблоны используют имена параметров в фигурных скобках. Функция validate_plan прогоняет план по копии состояния; execute выполняет его по-настоящему, повторяя проверку, потому что между проверкой и вызовом состояние могло измениться.

from dataclasses import dataclass, field

State = set  # множество троек (субъект, отношение, объект)


@dataclass
class Tool:
    name: str
    params: list[str]
    requires: list[tuple] = field(default_factory=list)   # тройки, которые должны быть в графе
    forbids: list[tuple] = field(default_factory=list)    # тройки, которых быть не должно
    adds: list[tuple] = field(default_factory=list)
    removes: list[tuple] = field(default_factory=list)
    needs_confirmation: bool = False


TOOLS = {t.name: t for t in [
    Tool("verify_customer", ["customer"],
         requires=[("{customer}", "type", "Customer")],
         adds=[("{customer}", "verified", "yes")], removes=[("{customer}", "verified", "no")]),
    Tool("create_refund", ["order", "customer"],
         requires=[("{order}", "status", "delivered"), ("{order}", "owner", "{customer}"),
                   ("{customer}", "verified", "yes")],
         forbids=[("{order}", "refunded", "yes")],
         adds=[("{order}", "refunded", "yes")], needs_confirmation=True),
    Tool("notify_customer", ["customer"],
         requires=[("{customer}", "verified", "yes")]),
]}


def bind(pattern: tuple, args: dict) -> tuple:
    return tuple(x.format(**args) for x in pattern)


def check_step(state: State, step: dict) -> str | None:
    """Причина отказа или None, если предусловия выполнены."""
    tool = TOOLS.get(step["tool"])
    if tool is None:
        return f"инструмента {step['tool']} нет в каталоге"
    if set(step["args"]) != set(tool.params):
        return f"аргументы {sorted(step['args'])} не совпадают с {sorted(tool.params)}"
    for p in tool.requires:
        fact = bind(p, step["args"])
        if fact not in state:
            return f"не выполнено предусловие: {' '.join(fact)}"
    for p in tool.forbids:
        fact = bind(p, step["args"])
        if fact in state:
            return f"запрещающий факт уже есть: {' '.join(fact)}"
    return None


def apply_effects(state: State, step: dict) -> None:
    tool = TOOLS[step["tool"]]
    for p in tool.removes:
        state.discard(bind(p, step["args"]))
    for p in tool.adds:
        state.add(bind(p, step["args"]))


def validate_plan(state: State, plan: list[dict]) -> str | None:
    """Сухой прогон по копии графа: ловим ошибки порядка шагов до выполнения."""
    sim = set(state)
    for i, step in enumerate(plan, 1):
        problem = check_step(sim, step)
        if problem:
            return f"шаг {i} ({step['tool']}): {problem}"
        apply_effects(sim, step)
    return None


def execute(state: State, plan: list[dict], call, confirm) -> None:
    for step in plan:
        problem = check_step(state, step)              # состояние могло измениться после проверки
        if problem:
            raise RuntimeError(f"остановка: {problem}")
        if TOOLS[step["tool"]].needs_confirmation and not confirm(step):
            raise RuntimeError(f"оператор отклонил шаг {step['tool']}")
        result = call(step["tool"], step["args"])
        if not result.get("ok"):
            raise RuntimeError(f"инструмент {step['tool']} вернул ошибку: {result}")
        apply_effects(state, step)                     # эффекты применяем только по факту успеха

Проверим на примере. Клиент c1 ещё не проверен, заказ o1 доставлен:

state = {("c1", "type", "Customer"), ("c1", "verified", "no"),
         ("o1", "status", "delivered"), ("o1", "owner", "c1")}

bad = [{"tool": "create_refund", "args": {"order": "o1", "customer": "c1"}}]
good = [{"tool": "verify_customer", "args": {"customer": "c1"}}] + bad + \
       [{"tool": "notify_customer", "args": {"customer": "c1"}}]

print(validate_plan(state, bad))
# шаг 1 (create_refund): не выполнено предусловие: c1 verified yes
print(validate_plan(state, good))
# None
execute(state, good, call=lambda name, args: {"ok": True}, confirm=lambda s: True)
# повторный возврат того же заказа теперь запрещён:
execute(state, bad, call=lambda name, args: {"ok": True}, confirm=lambda s: True)
# RuntimeError: остановка: запрещающий факт уже есть: o1 refunded yes

Сообщение «шаг 1 (create_refund): не выполнено предусловие: c1 verified yes» возвращается модели как есть, и на втором круге она ставит проверку клиента перед возвратом. Это дешевле, чем разбираться с последствиями неверного вызова, и для этого не нужна большая модель.

Зачем проверять дважды

  • Сухой прогон ловит ошибки порядка до первого побочного эффекта. Деньги не списаны, письмо не отправлено.
  • Повторная проверка перед каждым шагом ловит гонки: другой процесс уже вернул деньги или клиент потерял статус.
  • Эффекты применяются только после успешного ответа инструмента. Иначе граф рассинхронизируется с реальностью.
  • Подтверждение человеком стоит на необратимых шагах (возврат, удаление, отправка). Принципы защиты инструментов описаны в статье про prompt injection: права инструментов проверяются на сервере, а не в тексте промпта.

Обновление графа и память

После исполнения граф обновляется фактическими результатами. Правила:

  • Эффект применяется по ответу инструмента, а не по намерению плана. Если инструмент вернул новый статус, пишем его.
  • Каждый факт хранит происхождение: какой шаг, когда, какой запрос его создал. Это нужно для разбора инцидентов.
  • Факты, созданные моделью (например, извлечённые из письма), помечаются как непроверенные и не используются как предусловия для опасных действий, пока их не подтвердил источник истины.
  • Расхождение между ожидаемым эффектом и реальным состоянием это сигнал: остановить выполнение и перепланировать или позвать человека.
  • Следите за актуальностью: общие принципы обновления данных такие же, как в статье как обновлять знания LLM.

Что хранить в графе, а что оставить в базе

Граф не обязан быть отдельной системой. Если вся информация о заказах и клиентах уже лежит в реляционной базе, то «граф» можно строить как представление: тройки читаются запросом перед планированием. Дублировать данные в отдельную графовую базу имеет смысл, когда нужны обходы на много шагов, общая схема для разных систем или проверка схемой. Выбор хранилища описан в статье про онтологии и графы.

Где это не нужно

  • Короткие одношаговые сценарии: вызвать функцию и вернуть ответ. Хватит схемы аргументов.
  • Исследовательские задачи с открытым результатом, где «предусловия» нельзя формализовать.
  • Системы, в которых состояние не наблюдается: если вы не можете узнать, верно ли предусловие, формальная проверка создаёт ложное чувство безопасности.

Как оценить, что стало лучше

Составьте набор сценариев с известным правильным результатом, включая ловушки: клиент не проверен, заказ уже возвращён, нужного инструмента нет. Сравните агента без проверки и с проверкой по доле успешно завершённых задач, числу вызовов инструментов с нарушением предусловий (должно упасть до нуля при проверке) и стоимости задачи. Методику измерения см. в статье как сравнить LLM на своих задачах, а для работы в продакшене нужны журналы шагов и версионирование каталога инструментов: LLMOps на практике.

Итого

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

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