<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:yandex="http://news.yandex.ru" xmlns:media="http://search.yahoo.com/mrss/" xmlns:turbo="http://turbo.yandex.ru" version="2.0">
	<channel>
		<title>Наши публикации</title>
		<link>https://learning.ontonet.ru</link>
		<language>ru</language>
		<item turbo="true">
			<title>Онто-методология: от бизнес-функций и контекстов исполнения к C4-диаграммам</title>
			<link>https://learning.ontonet.ru/tpost/ckphtrreg1-onto-metodologiya-ot-biznes-funktsii-i-k</link>
			<amplink>https://learning.ontonet.ru/tpost/ckphtrreg1-onto-metodologiya-ot-biznes-funktsii-i-k?amp=true</amplink>
			<pubDate>Wed, 10 Sep 2025 00:03:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<enclosure url="https://static.tildacdn.com/tild3636-3563-4437-a530-353664633631/photo.png" type="image/png"/>
			<description>Эта статья показывает, как связать бизнес-уровень и архитектуру: от функций и их контекстов исполнения через IT-Capabilities к C4-диаграммам (Context, Container, Component). </description>
			<turbo:content>
<![CDATA[<header><h1>Онто-методология: от бизнес-функций и контекстов исполнения к C4-диаграммам</h1></header><div data-block="gallery"><img src="https://static.tildacdn.com/tild3636-3563-4437-a530-353664633631/photo.png"/></div><h2  class="t-redactor__h2">Бизнес-функция vs. бизнес-процесс vs. бизнес-сервис</h2><div class="t-redactor__text">Чтобы связать бизнес-функции с архитектурой системы, важно чётко понимать отличия между <strong>бизнес-функцией</strong>, <strong>бизнес-процессом</strong> и <strong>бизнес-сервисом</strong> (услугой) в контексте BPM(Business Process Management).</div><div class="t-redactor__text"><strong>Бизнес-процесс</strong> – это <em>последовательность</em> связанных действий (шагов) с определёнными событиями начала и результата, направленная на выпуск конкретного продукта или услуги. Процесс рассматривается «снаружи» – как цепочка шагов для удовлетворения потребностей клиента (внешнего или внутреннего)<a href="https://habr.com/ru/articles/763910/#:~:text=%3E%20%3E%20%D0%91%D0%B8%D0%B7%D0%BD%D0%B5%D1%81,%D0%BD%D0%B0%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%2C%20%D1%82%D1%80%D0%B5%D0%B1%D1%83%D0%B5%D0%BC%D1%8B%D1%85%20%D0%BD%D0%B0%D0%B2%D1%8B%D0%BA%D0%BE%D0%B2%2C%20%D1%80%D0%B5%D1%81%D1%83%D1%80%D1%81%D0%BE%D0%B2%2C%20%D0%BF%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%BA%D0%B8">[1]</a>. Его цель – предоставить ценность потребителю, выступая чёрным ящиком: внутренние шаги не видны внешнему наблюдателю<a href="https://habr.com/ru/articles/763910/#:~:text=%3E%20%D0%91%D0%B8%D0%B7%D0%BD%D0%B5%D1%81,%D0%BF%D1%80%D0%BE%D1%81%D1%82%D0%BE%20%D1%87%D0%B5%D1%80%D0%BD%D1%8B%D0%B9%20%D1%8F%D1%89%D0%B8%D0%BA%2C%20%D0%BE%D1%82%D1%81%D1%8E%D0%B4%D0%B0%20%D0%B8">[2]</a>. Сложный процесс может включать подпроцессы и пересекать границы отделов. Важно, что за целый сквозной процесс обычно отвечает владелец процесса, обеспечивая координацию между подразделениями<a href="https://upr.ru/article/sistem-podhod-k-opisaniyu-biznes-processov/#:~:text=%D0%92%D0%B0%D0%B6%D0%BD%D0%BE%20%D0%BE%D1%82%D0%BC%D0%B5%D1%82%D0%B8%D1%82%D1%8C%20%D1%87%D1%82%D0%BE%20%D0%BF%D0%BE%D0%BD%D1%8F%D1%82%D0%B8%D0%B5%20%C2%AB%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F%C2%BB,%D0%BE%D1%88%D0%B8%D0%B1%D0%BA%D0%B8%20%D0%B8%C2%A0%D0%BF%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D1%8B%20%D0%BF%D1%80%D0%B8%20%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D0%B8%20%D0%B4%D0%B5%D1%8F%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B8">[3]</a><a href="https://upr.ru/article/sistem-podhod-k-opisaniyu-biznes-processov/#:~:text=%D1%8D%D1%82%D0%BE%D0%B9%20%D0%BF%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D1%8B%20%D0%B1%D1%8B%D0%BB%D0%BE%20%D0%BF%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%BE%20%D0%BF%D1%80%D0%BE%D1%81%D1%82%D0%BE%D0%B5,%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%B0">[4]</a>.</div><div class="t-redactor__text">Бизнес-функция – это тип деятельности или устойчивый набор работ, сгруппированных по общим критериям: требуемым IT-Capability, навыкам, компетенциям, организационной принадлежности и т.д.. Функция – взгляд «изнутри» на бизнес-активность: она объединяет однородные задачи, обычно выполняемые одним подразделением или ролью, и требует определённых IT-Capability/умений. В отличие от процесса, функция не задаёт жёсткой последовательности шагов, а фокусируется на том, что выполняется и какими средствами. Часто бизнес-функции являются частями бизнес-процессов – процесс состоит из ряда функций различных отделов. При этом одна функция может участвовать в нескольких процессах: между сложными процессами и функциями обычно существует связь «многие ко многим». Иными словами, бизнес-процесс – это цепочка (оркестровка) функций, а бизнес-функция предоставляет определённую способность (capacity), которая может использоваться в разных процессах.</div><div class="t-redactor__text"><strong>Бизнес-сервис (услуга)</strong> – это <em>внешнее отображение</em> возможностей организации. Бизнес-сервис представляет цельную функциональность, дающую ценность потребителю, вне зависимости от того, как она реализуется внутри компании<a href="https://habr.com/ru/articles/763910/#:~:text=%D0%92%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BD%D0%B5%20%D0%BF%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D0%B8%D1%80%D1%83%D0%B5%D1%82%D1%81%D1%8F%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%BC,%D1%82%D0%B8%D0%BF%D0%BE%D0%B2%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%20%D0%B2%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B5%D0%B3%D0%BE%20%D0%BF%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F%2C%20%D1%81%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D0%BD%D1%8B%D1%85">[10]</a>. Услуга — это то, что организация предлагает внешним или внутренним клиентам, опираясь на свои процессы и функции. Принято различать <strong>внешние</strong> услуги (для внешних клиентов) и <strong>внутренние</strong> бизнес-услуги (для поддержки внутренних процессов и функций)<a href="https://habr.com/ru/articles/763910/#:~:text=%D0%92%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BD%D0%B5%20%D0%BF%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D0%B8%D1%80%D1%83%D0%B5%D1%82%D1%81%D1%8F%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%BC,%D0%9C%D0%BE%D0%B6%D0%BD%D0%BE%20%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%81%D1%82%D0%B8%20%D1%80%D0%B0%D0%B7%D0%BB%D0%B8%D1%87%D0%B8%D0%B5%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83">[11]</a>. <strong>Бизнес-функции и процессы реализуют бизнес-сервисы</strong>: т.е. сервис – это «витрина» или интерфейс, за которым может стоять либо цепочка шагов (процесс), либо совокупность действий, выполняемых одним звеном (функция)<a href="https://habr.com/ru/articles/763910/#:~:text=%3E%20%D0%91%D0%B8%D0%B7%D0%BD%D0%B5%D1%81,%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%BE%D0%B2%2C%20%D0%BF%D0%B5%D1%80%D0%B5%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0%20%D0%B8%D0%BB%D0%B8%20%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0%20%D0%BF%D0%BB%D0%B0%D1%82%D0%B5%D0%B6%D0%B5%D0%B9">[12]</a>. Например, услуга <em>«Подключение нового абонента»</em> для клиента может реализовываться бизнес-процессом, проходящим через несколько отделов, или через единичную функцию, выполненную одним подразделением – но внешне это единая услуга подключения.</div><div class="t-redactor__text">Резюмируя различия: бизнес-процесс описывает как работа выполняется (последовательность действий для достижения результата), бизнес-функция фокусируется на чём выполняется и какими IT-Capability (группировка схожих работ по ответственности), а бизнес-сервис описывает что получает клиент (ценность/результат), скрывая внутренние детали реализации. В контексте BPMN-нотации прямого элемента “бизнес-функция” нет – BPMN оперирует процессами и задачами. Однако при бизнес-моделировании (например, по ARIS или ArchiMate) функции рассматриваются как компоненты процессов или как отдельные единицы поведения, предоставляющие сервисы. Знание этой иерархии важно, т.к. бизнес-функции будем использовать как отправную точку для разработки ИТ-архитектуры.</div><h2  class="t-redactor__h2">Контекст исполнения бизнес-функции</h2><div class="t-redactor__text">Каждая бизнес-функция выполняется <em>не в вакууме</em>, а при определённых условиях и окружении – в <strong>контексте исполнения</strong>. <em>Контекст исполнения функции</em> – это совокупность обстоятельств, при которых функция реализуется в реальности. Он определяет <strong>«как, где и кем» выполняется функция</strong>, включая такие сущности, как:</div><div class="t-redactor__text"><strong>Акторы (исполнители)</strong> – роли, сотрудники или внешние пользователи, которые участвуют в выполнении функции. Это могут быть конкретные должности (например, <em>Менеджер по подключению</em> в отделе продаж) или же сами клиенты/пользователи, если функция подразумевает самообслуживание. Актор инициирует или непосредственно выполняет задачи функции в данном контексте.</div><div class="t-redactor__text"><strong>IT-Capabilities </strong>– инструменты и системы, необходимые для выполнения функции. Сюда относятся ИТ-системы (приложения, базы данных), оборудование, материалы и т.п., используемые актором или автоматически в ходе функции. IT-Capabilities обеспечивают техническую и информационную поддержку реализации функции.</div><div class="t-redactor__text"><strong>Каналы</strong> – способы взаимодействия и среды, через которые реализуется функция. Канал отражает <em>где и как</em> происходит выполнение: например, через веб-интерфейс (портал), мобильное приложение, телефонный звонок, очно в офисе, через API интеграцию и т.д. Канал важен, поскольку от него зависят требования к интерфейсам и формату предоставления функции.</div><div class="t-redactor__text"><strong>Ограничения среды</strong> – внешние условия и регламенты, влияющие на выполнение функции. К ним относятся законодательные требования, бизнес-правила, географические или временные ограничения, нагрузка, условия эксплуатации. Например, в одном регионе функция может выполняться иначе из-за локальных законов; или само выполнение возможно только в рабочие часы, если задействованы сотрудники.</div><div class="t-redactor__text">Контекст исполнения фактически описывает вариант реализации бизнес-функции. Одна и та же бизнес-функция может иметь несколько контекстов исполнения, в зависимости от того, кто и с помощью каких средств её выполняет. Например, функция подключения нового абонента в телеком-бизнесе может выполняться: (1) через менеджера в офисе продаж (человек-исполнитель, использующий внутреннюю CRM-систему, канал – офис/фронт-офис, ограничение – рабочие часы, очное присутствие клиента), а также (2) самим абонентом через веб-портал самообслуживания (исполнитель – клиент, IT-Capability – интернет-портал, канал – онлайн, ограничения – доступность интернета, возможно упрощённые тарифы без сложных проверок). Обе реализации достигают одной цели (подключение абонента), но контекст и задействованные сущности различны.</div><div class="t-redactor__text">Зачем явно описывать разные контексты? Потому что выбор контекста влияет на архитектурное решение. Как отмечается в подходе Architecture of Business, способность (capability) организации достигается реализацией функции с учётом конкретного бизнес-контекста, и в разных условиях одна и та же функция может требовать разных IT-Capability и давать разные результаты. Иными словами, бизнес-онтология должна зафиксировать, в каком окружении существует функция, чтобы далее правильным образом спроектировать под неё систему. В онтологических терминах, функция должна быть связана с описанием её контекстов – это повышает адаптивность и точность архитектуры. Например, в одном контексте capability “подключить абонента” подразумевает одно наполнение (процедуры, системы), а в другом – иное, и оба надо учесть при проектировании.</div><h2  class="t-redactor__h2">Онтологическая модель функций и контекстов (Онто)</h2><div class="t-redactor__text">Онто-подход предполагает создание формальной модели (онтологии), описывающей основные понятия предметной области и связи между ними. Для нашей задачи ключевыми понятиями будут: бизнес-функция, контекст исполнения, актор, IT-Capability, канал, ограничение, а также связи с бизнес-процессами и сервисами. Ниже представлена концептуальная схема онтологической модели, фиксирующей эти понятия и их отношения:</div><img src="https://static.tildacdn.com/tild6634-3439-4937-b039-356335626336/___.png"><div class="t-redactor__text">Бизнес-процессы (процессы) группируют поведение по потоку работ, а бизнес-функции (функции) – по IT-Capability и компетенциям; обе могут реализовывать бизнес-сервисы (услуги). Каждая бизнес-функция может иметь один или несколько контекстов исполнения, связанных с определёнными акторами, IT-Capability, каналами и ограничениями.</div><img src="https://static.tildacdn.com/tild6230-6161-4430-a163-653738316632/_____.png"><div class="t-redactor__text">На схеме (Рис.2) отражены следующие классы и связи:</div><div class="t-redactor__text"><strong>BusinessFunction (Функция)</strong> – класс бизнес-функций. Атрибуты: название функции, описание цели. Связи: <em>имеет контексты</em> → множество <strong>ExecutionContext</strong>. Также функция может <em>реализовывать</em> один или несколько <strong>BusinessService</strong> (бизнес-сервисов), и может быть частью исполнения <strong>BusinessProcess</strong>.</div><div class="t-redactor__text"><strong>BusinessProcess (Процесс)</strong> – класс бизнес-процессов. Атрибуты: название процесса, результат. Связи: может <em>использовать или включать</em> функции (<strong>BusinessFunction</strong>), образуя цепочку из них<em><a href="https://habr.com/ru/articles/763910/#:~:text=%3E%20%3E%20%D0%9C%D0%B5%D0%B6%D0%B4%D1%83%20%D0%B1%D0%B8%D0%B7%D0%BD%D0%B5%D1%81,%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F%D1%85%20%28of%20business%20activities%29.">[9]</a></em>. Процесс тоже может <em>реализовывать</em> бизнес-сервисы.</div><div class="t-redactor__text"><strong>BusinessService (Сервис)</strong> – класс бизнес-услуг. Атрибуты: название услуги, потребитель. Связи: <em>реализуется</em> процессами или функциями. Сервис – то, что получает внешний актор, результат выполнения функции/процесса<em><a href="https://habr.com/ru/articles/763910/#:~:text=%D0%92%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BD%D0%B5%20%D0%BF%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D0%B8%D1%80%D1%83%D0%B5%D1%82%D1%81%D1%8F%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%BC,%D1%82%D0%B8%D0%BF%D0%BE%D0%B2%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%20%D0%B2%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B5%D0%B3%D0%BE%20%D0%BF%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F%2C%20%D1%81%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D0%BD%D1%8B%D1%85">[10]</a><a href="https://habr.com/ru/articles/763910/#:~:text=%3E%20%D0%91%D0%B8%D0%B7%D0%BD%D0%B5%D1%81,%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%BE%D0%B2%2C%20%D0%BF%D0%B5%D1%80%D0%B5%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0%20%D0%B8%D0%BB%D0%B8%20%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0%20%D0%BF%D0%BB%D0%B0%D1%82%D0%B5%D0%B6%D0%B5%D0%B9">[12]</a></em>.</div><div class="t-redactor__text"><strong>ExecutionContext (Контекст исполнения)</strong> – класс контекстов выполнения функции. Отражает конкретный вариант реализации функции. Атрибуты: идентификатор или имя сценария, описание условий. Связи: <em>принадлежит</em> одной <strong>BusinessFunction</strong> (обратная связь “имеет контексты”), а также соединяется с элементами среды:</div><div class="t-redactor__text"><ul><li data-list="bullet"><em>исполняется кем</em> → <strong>Actor</strong> (конкретный актор/роль в этом контексте),</li><li data-list="bullet">использует IT-Capability → Resource,</li><li data-list="bullet"><em>через канал</em> → <strong>Channel</strong>,</li><li data-list="bullet"><em>учитывает ограничения</em> → <strong>EnvironmentConstraint</strong>.</li></ul></div><div class="t-redactor__text"><strong>Actor/Role (Актор)</strong> – класс акторов или ролей. Представляет человека или внешнюю систему, инициирующую или выполняющую функцию. Атрибуты: имя роли (например, “Менеджер отдела подключений” или “Клиент”). Связи: может быть <em>назначен</em> на функцию (ответственный за функцию) – пунктирной стрелкой на схеме обозначено, что роль может отвечать за выполнение функции как таковой, но в контексте мы фиксируем конкретного исполнителя.</div><div class="t-redactor__text"><strong>IT-Capability (Способность) </strong>– класс IT-Capability/инструментов. Атрибуты: тип IT-Capability (ИТ-система, оборудование, данные и т.п.), название (например, “CRM-система”). Связи: используется в контексте исполнения функции. Одна функция может требовать несколько IT-Capability.</div><div class="t-redactor__text"><strong>Channel (Канал)</strong> – класс каналов взаимодействия. Атрибуты: тип канала (web, мобильный, офлайн и т.д.). Связи: контекст функции происходит <em>через</em> определённый канал.</div><div class="t-redactor__text"><strong>EnvironmentConstraint (Ограничение среды)</strong> – класс ограничений. Атрибуты: описание ограничения (например, “Регламент РФ о персональных данных” или “Доступно в рабочие дни 9–18”). Связи: контекст <em>подчиняется</em> этим ограничениям.</div><div class="t-redactor__text">Эта онтология (Онто-модель) позволяет в структурированном виде описать, <em>какими способами реализуется каждая бизнес-функция</em>. Внешне можно представить данные по конкретной функции в виде таблицы: слева сама функция, далее перечислены возможные контексты и их ключевые элементы. Например, для функции <strong>«Управление подключением абонентов»</strong> (телеком-сфера) возможны контексты:</div><div class="t-table__viewport"><div class="t-table__wrapper"><table class="t-table__table"><tbody><tr class="t-table__row"><td class="t-table__cell" data-row="0" data-column="0"><div class="t-table__cell-content">Бизнес-функция</div></td><td class="t-table__cell" data-row="0" data-column="1"><div class="t-table__cell-content">Контекст исполнения</div></td><td class="t-table__cell" data-row="0" data-column="2"><div class="t-table__cell-content">Акторы</div></td><td class="t-table__cell" data-row="0" data-column="3"><div class="t-table__cell-content">IT-Capabilities</div></td><td class="t-table__cell" data-row="0" data-column="4"><div class="t-table__cell-content">Каналы</div></td></tr><tr class="t-table__row"><td class="t-table__cell" data-row="1" data-column="0"><div class="t-table__cell-content">Управление подключением абонентов</div></td><td class="t-table__cell" data-row="1" data-column="1"><div class="t-table__cell-content">Через менеджера в офисе – абонент подключается при помощи сотрудника компании (очное обслуживание).</div></td><td class="t-table__cell" data-row="1" data-column="2"><div class="t-table__cell-content">Менеджер по продажам, Абонент (клиент)</div></td><td class="t-table__cell" data-row="1" data-column="3"><div class="t-table__cell-content">IT-Capability «Управление клиентскими и сетевыми данными»</div></td><td class="t-table__cell" data-row="1" data-column="4"><div class="t-table__cell-content">Очный (офис продаж); телефон (для верификации)</div></td></tr><tr class="t-table__row"><td class="t-table__cell" data-row="2" data-column="0"><div class="t-table__cell-content"></div></td><td class="t-table__cell" data-row="2" data-column="1"><div class="t-table__cell-content">Самообслуживание онлайн – абонент подключается самостоятельно через интернет-портал.</div></td><td class="t-table__cell" data-row="2" data-column="2"><div class="t-table__cell-content">Абонент (конечный пользователь)</div></td><td class="t-table__cell" data-row="2" data-column="3"><div class="t-table__cell-content">IT-Capability «Онлайн самообслуживание абонентов»</div></td><td class="t-table__cell" data-row="2" data-column="4"><div class="t-table__cell-content">Онлайн (Web, Mobile)</div></td></tr></tbody><colgroup><col style="max-width:180px;min-width:180px;width:180px;"><col style="max-width:180px;min-width:180px;width:180px;"><col style="max-width:180px;min-width:180px;width:180px;"><col style="max-width:180px;min-width:180px;width:180px;"><col style="max-width:180px;min-width:180px;width:180px;"></colgroup></table></div></div><div class="t-redactor__text"><em>Таблица 1: Пример описания бизнес-функции и её двух контекстов исполнения.</em> Каждый контекст фиксирует “картинку” выполнения функции: <strong>кто</strong> выполняет, <strong>с помощью чего</strong> и <strong>где</strong>, а также особые условия. Благодаря онтологической связке, мы можем однозначно проследить: от функции → к контекстам → к задействованным системам и ролям. Далее на основе этой информации можно переходить к проектированию архитектуры.</div><h2  class="t-redactor__h2">Переход от бизнес-функции к архитектуре (C4-модель)</h2><div class="t-redactor__text">Имея онтологически описанные функции и их контексты, мы готовы трансформировать это в конкретные архитектурные представления. Мы используем <strong>модель C4</strong> – подход, предлагающий иерархию диаграмм для описания программной архитектуры: уровень контекста (Context), контейнеров (Containers), компонентов (Components) и кода (Code)<em><a href="https://habr.com/ru/articles/778726/#:~:text=%D0%9D%D0%B0%D0%B7%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%20">[16]</a></em>. В нашем методе мы сконцентрируемся на первых трёх уровнях C4, чтобы проследить путь <em>от бизнес-функции (через контекст) к технической реализации</em>. Ниже описан пошаговый “рецепт” такой трансформации.</div><h3  class="t-redactor__h3">Шаг 1: Диаграмма системного контекста (C4: System Context)</h3><div class="t-redactor__text">На первом уровне C4 строится <strong>диаграмма контекста системы</strong>, которая показывает систему(ы), реализующие функцию, в окружении пользователей и внешних зависимостей. По сути, мы отвечаем на вопрос: <em>какова граница нашей системы для данного бизнес-контекста и как она взаимодействует с внешним миром?</em></div><div class="t-redactor__text"><strong>Как построить диаграмму контекста из описания функции:</strong></div><div class="t-redactor__text">1.Выделить систему или систему-в-сфокусе, которая выполняет данную бизнес-функцию в выбранном контексте. В онто-модели это соответствует основному IT-Capability/системе, использующемуся в контексте. Например, для контекста “через менеджера” это будет CRM/система управления подключениями, которую использует сотрудник.</div><div class="t-redactor__text">2.Определить ключевых акторов – внешних пользователей этой системы. Из контекста возьмём роль исполнителя и, возможно, клиента. На диаграмме контекста они изображаются как пользователи (персоны) вне системы. Например, <em>Менеджер</em> будет внешним пользователем CRM-системы, а также можно отразить <em>Абонента</em>, если он косвенно участвует (через менеджера).</div><div class="t-redactor__text">3.Определить внешние системы, с которыми наша система должна интегрироваться в процессе выполнения функции. Эти сведения тоже есть в контексте: например, для подключения абонента CRM может обращаться к биллинг-системе (для создания счёта) и системе активации (OSS, для активации SIM в сети). Такие внешние ИТ-сервисы станут отдельными узлами на диаграмме.</div><div class="t-redactor__text">4.Нанести связи (интеграции) между центральной системой, актором и внешними системами. Стрелками показываем, кто как взаимодействует: пользователь → система (выполнение через UI/API), система ↔ внешние системы (обмен данными). На этом шаге достаточно текстового описания взаимодействия (например, “использует интерфейс”, “отправляет запрос на активацию”).</div><div class="t-redactor__text">Диаграмма системного контекста помогает сразу увидеть <em>границы ответственности</em>: что входит в нашу систему, а что остается внешними сервисами; кто основные пользователи. Она используется на ранних этапах проектирования для общего понимания окружения<em><a href="https://habr.com/ru/articles/778726/#:~:text=%D0%9F%D0%BE%D0%BA%D0%B0%D0%B7%D1%8B%D0%B2%D0%B0%D0%B5%D1%82%2C%20%D0%BA%D0%B0%D0%BA%20%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0%20%D0%B2%D0%B7%D0%B0%D0%B8%D0%BC%D0%BE%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82%20%D1%81,%D0%A1%D1%80%D0%B0%D0%B7%D1%83%20%D0%B2%D0%B8%D0%B4%D0%BD%D0%BE%20%D0%B8%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D1%86%D0%B8%D0%B8">[17]</a></em>. Элементы такой диаграммы – система (наш программный продукт), пользователи (акторы) и внешние системы, а также связи между ними (интеграции, взаимодействия).</div><div class="t-redactor__text">Для примера возьмём бизнес-функцию “Управление подключением абонентов” в контексте обслуживания через менеджера. Основная система здесь – предположим, “Backend Service (Application, реализующее IT-Capabilities)”, которая обеспечивает оформление нового подключения. Внешний актор – Менеджер по продажам, использующий эту систему. Внешние системы – Billing Adapter (Application, интеграция с внешним биллингом) (начисление оплаты) и Provisioning Adapter (Application, реализующее IT-Capability «Активация SIM-карт») (включает номер в сети), плюс сама телеком-сеть как инфраструктура. </div><img src="https://static.tildacdn.com/tild3734-3239-4365-b639-663531646266/______.png"><div class="t-redactor__text">Пользователь-менеджер (слева) взаимодействует с целевой системой Backend Service (Application, реализующее IT-Capabilities) – условно, модуль CRM для подключения. Система, в свою очередь, интегрируется с внешними: биллингом и системой активации, которая связана с телеком-сетью. На схеме сразу видны границы нашей системы и все внешние взаимодействия.</div><h3  class="t-redactor__h3">Шаг 2: Диаграмма контейнеров (C4: Container)</h3><blockquote class="t-redactor__quote">Примечание: В дополнение к стандартным контейнерам добавлен API-GW, через который Agent Web Portal взаимодействует с Backend Service. Это отражает современный паттерн интеграции.</blockquote><div class="t-redactor__text">Следующий уровень – <strong>диаграмма контейнеров</strong> – раскрывает внутреннюю структуру нашей системы на крупные компоненты-развертывания (containers): приложения, базы данных, микросервисы, пользовательские интерфейсы и пр. Это архитектурный <em>«черчёж»</em> высокоуровневого дизайна системы. Диаграмма контейнеров описывает из чего состоит система, какие технологии используются и как разделены зоны ответственности<em><a href="https://habr.com/ru/articles/778726/#:~:text=%D0%9E%D0%BF%D0%B8%D1%81%D1%8B%D0%B2%D0%B0%D0%B5%D1%82%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B5%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D0%B5%D0%B2%D1%83%D1%8E%20%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D1%83%20%D0%B8%20%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B8,%D1%81%D1%82%D0%B5%D0%BA%D0%B0%20%D0%B8%20%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B7%D0%BE%D0%BD%20%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8">[18]</a></em>. Элементы здесь: <strong>контейнеры</strong> (например, веб-приложение, база данных, API-сервер и т.п.), их <strong>взаимосвязи</strong> (протоколы, вызовы) и важные <strong>технологии/фреймворки</strong><em><a href="https://habr.com/ru/articles/778726/#:~:text=%D0%9E%D0%BF%D0%B8%D1%81%D1%8B%D0%B2%D0%B0%D0%B5%D1%82%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B5%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D0%B5%D0%B2%D1%83%D1%8E%20%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D1%83%20%D0%B8%20%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B8,%D1%81%D1%82%D0%B5%D0%BA%D0%B0%20%D0%B8%20%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B7%D0%BE%D0%BD%20%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8">[18]</a></em>.</div><div class="t-redactor__text"> Примечание: В дополнение к стандартным контейнерам добавлен API-GW, через который Agent Web Portal взаимодействует с Backend Service. Это отражает современный паттерн интеграции.</div><div class="t-redactor__text"><strong>Переход от контекста функции к контейнерам:</strong></div><div class="t-redactor__text">1.Выявить основные компоненты системы, которые понадобятся для реализации функции в данном контексте. Вспомним требования контекста: какой канал используется? Если, например, канал – веб-портал для менеджера, очевидно нужен контейнер фронт-энда (веб-приложение) и контейнер серверной логики (бэкенд). Если есть хранилище данных – будет контейнер базы данных. Фактически, на основе IT-Capability/системы из контекста мы декомпозируем её на части: пользовательский интерфейс, серверную часть, БД, интеграционные модули и т.д.</div><div class="t-redactor__text">2.<strong>Определить взаимодействия между контейнерами</strong> внутри системы. Например, фронтэнд обращается к бэкенду (REST API), бэкенд к базе данных (SQL запросы). Если в системе несколько приложений, показать связи между ними.</div><div class="t-redactor__text">3.<strong>Отразить внешние системы и пользователей на этой диаграмме</strong> там, где они взаимодействуют с конкретными контейнерами. В C4-модели на уровне Container обычно всё ещё показывают, с какого контейнера происходят вызовы во внешние системы, и какой контейнер обслуживает какого пользователя. Таким образом, некоторые элементы из диаграммы контекста (акторы, внешние системы) могут присутствовать и здесь, но фокус – на внутренних контейнерах.</div><div class="t-redactor__text">4.<strong>Добавить технические детали</strong> (по возможности): типы контейнеров и технологии. Например, отметить что веб-приложение – это Angular SPA, бэкенд – Spring Boot, база – Oracle DB. Это помогает понимать стек. На методологическом уровне можно оставить технологии шаблонно (например “Web Application”, “Database”) как роли контейнеров, если конкретика не известна.</div><div class="t-redactor__text">Диаграмма контейнеров даёт картину <em>высокоуровневой архитектуры системы</em>: какие приложения и хранилища задействованы и как они общаются. Она полезна архитекторам и разработчикам для разбивки системы на модули и выбора технологий<em><a href="https://habr.com/ru/articles/778726/#:~:text=%D0%9E%D0%BF%D0%B8%D1%81%D1%8B%D0%B2%D0%B0%D0%B5%D1%82%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B5%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D0%B5%D0%B2%D1%83%D1%8E%20%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D1%83%20%D0%B8%20%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B8,%D1%81%D1%82%D0%B5%D0%BA%D0%B0%20%D0%B8%20%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B7%D0%BE%D0%BD%20%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8">[18]</a></em>.</div><div class="t-redactor__text"> Примечание: В дополнение к стандартным контейнерам добавлен API-GW, через который Agent Web Portal взаимодействует с Backend Service. Это отражает современный паттерн интеграции.</div><div class="t-redactor__text">Продолжим наш пример “Управление подключением абонентов” – теперь детализируем Backend Service (Application, реализующее IT-Capabilities) из Рис.2. Предположим, это классическое веб-приложение для сотрудников: у менеджера есть веб-интерфейс (портал) для ввода данных клиента, есть сервер приложений, который обрабатывает бизнес-логику подключения, и база данных, где сохраняются заявки и данные абонентов. Бэкенд-сервер также интегрируется с внешними системами (биллингом и системой активации). </div><img src="https://static.tildacdn.com/tild3664-6338-4634-a434-363034383334/Container_________.png"><div class="t-redactor__text">Такой уровень детализации основан на знаниях о контексте: например, мы знали, что канал – веб, поэтому появился контейнер Web Portal; знали о внешних интеграциях – поэтому на бэкенде предусмотрены взаимодействия с биллингом и OSS. Важно: диаграмма контейнеров для другого контекста той же функции могла бы отличаться. Если бы функция выполнялась клиентом через мобильное приложение, вместо “Agent Web Portal” был бы контейнер “Mobile App”, и, возможно, иной набор контейнеров (например, потребовался бы API-шлюз). Поэтому преобразование делается для каждого контекста исполнения отдельно, чтобы учесть специфику каналов и IT-Capability.</div><h3  class="t-redactor__h3">Шаг 3: Диаграмма компонентов (C4: Component)</h3><blockquote class="t-redactor__quote">Примечание: Все компоненты (Subscription Manager, Billing API Client, Provisioning API Client, Data Access) являются частью Application Backend Service. Их интеграции с внешними системами реализуются через Applications типа Adapter (например, Provisioning Adapter).</blockquote><div class="t-redactor__text">Третий уровень C4 – <strong>диаграмма компонентов</strong> – детализирует внутреннее устройство отдельных контейнеров системы. Обычно фокус идёт на одном из контейнеров, раскрывая его на составные <em>компоненты кода/модули</em> и показывая, как они взаимодействуют друг с другом и внешним окружением<em><a href="https://habr.com/ru/articles/778726/#:~:text=%D0%94%D0%B5%D1%82%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D1%83%D0%B5%D1%82%20%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%83%20%D0%B2%D0%BD%D1%83%D1%82%D1%80%D0%B8%20%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%B9%D0%BD%D0%B5%D1%80%D0%B0%20%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D1%8B%2C,%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%B9%D0%BD%D0%B5%D1%80%20%D0%B8%D0%B7%20%D0%BF%D1%80%D0%B5%D0%B4%D1%8B%D0%B4%D1%83%D1%89%D0%B5%D0%B3%D0%BE%20%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D1%8F">[19]</a></em>. Диаграмма компонентов помогает разработчикам понять распределение ответственности внутри приложения и точки интеграции. Элементы: <strong>компоненты</strong> (функциональные части внутри контейнера, например, классы, модули, службы), их <strong>взаимосвязи</strong> (вызовы, зависимости), используемые <strong>технологии</strong> и внешние зависимости (базы, внешние сервисы)<em><a href="https://habr.com/ru/articles/778726/#:~:text=%D0%94%D0%B5%D1%82%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D1%83%D0%B5%D1%82%20%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%83%20%D0%B2%D0%BD%D1%83%D1%82%D1%80%D0%B8%20%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%B9%D0%BD%D0%B5%D1%80%D0%B0%20%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D1%8B%2C,%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%B9%D0%BD%D0%B5%D1%80%20%D0%B8%D0%B7%20%D0%BF%D1%80%D0%B5%D0%B4%D1%8B%D0%B4%D1%83%D1%89%D0%B5%D0%B3%D0%BE%20%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D1%8F">[19]</a></em>.</div><div class="t-redactor__text"> Примечание: Все компоненты (Subscription Manager, Billing API Client, Provisioning API Client, Data Access) являются частью Application Backend Service. Их интеграции с внешними системами реализуются через Applications типа Adapter (например, Provisioning Adapter).</div><div class="t-redactor__text"><strong>Методика декомпозиции на компоненты:</strong></div><div class="t-redactor__text">1.<strong>Выбрать контейнер для детализации.</strong> Обычно выбирают наиболее сложный или ключевой контейнер. В нашем примере это <strong>Backend Service</strong>, т.к. в нём сосредоточена бизнес-логика подключения. (Отдельно можно было бы детализировать и Portal, но предположим, что фронтэнд типовой.)</div><div class="t-redactor__text">2.<strong>Выделить основные компоненты внутри контейнера</strong>, исходя из функциональности, которую он реализует. Для бэкенда “подключение абонента” логично выделить, например: компонент, управляющий процессом подключения (орchestrator), компоненты-интеграторы для каждого внешнего сервиса (например, <em>Billing API Client</em>, <em>Provisioning API Client</em>), а также компонент доступа к базе данных (DAO или репозиторий). Также могут быть компоненты валидации, логирования, но мы фокусируемся на бизнес-функциях.</div><div class="t-redactor__text">3.<strong>Показать взаимодействия компонентов между собой.</strong> Например, orchestrator вызывает компонент интеграции с биллингом и компонент доступа к данным. Компоненты интеграции, в свою очередь, взаимодействуют с внешними системами (эти внешние системы можно указать на диаграмме для наглядности). Все связи подписываем: чем именно обмениваются или через какой интерфейс (например, REST вызов, JDBC запрос).</div><div class="t-redactor__text">4.<strong>Указать внешние элементы, с которыми компоненты работают.</strong> Это могут быть: база данных (которая уже была отдельным контейнером на уровне выше), внешние системы, а также, возможно, компоненты в других контейнерах. На компонентной диаграмме допускается показать, что, скажем, <em>BillingClient компонент</em> вызывает внешний <em>Billing System API</em>. По сути, мы детализируем одну “коробочку” (контейнер) из предыдущего уровня, не забывая о его связях наружу<em><a href="https://habr.com/ru/articles/778726/#:~:text=match%20at%20L256%20%D0%94%D0%B5%D1%82%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D1%83%D0%B5%D1%82%20%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%83,%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%B9%D0%BD%D0%B5%D1%80%20%D0%B8%D0%B7%20%D0%BF%D1%80%D0%B5%D0%B4%D1%8B%D0%B4%D1%83%D1%89%D0%B5%D0%B3%D0%BE%20%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D1%8F">[20]</a></em>.</div><div class="t-redactor__text">Таким образом, диаграмма компонентов – это углубление <em>внутри одного контейнера</em>, показывающее реализацию функции на уровне архитектурных классов/модулей. Её используют при проектировании и документировании внутренней реализации системы, распределяя ответственность по компонентам<em><a href="https://habr.com/ru/articles/778726/#:~:text=%D0%94%D0%B5%D1%82%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D1%83%D0%B5%D1%82%20%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%83%20%D0%B2%D0%BD%D1%83%D1%82%D1%80%D0%B8%20%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%B9%D0%BD%D0%B5%D1%80%D0%B0%20%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D1%8B%2C,%D0%BE%D0%B4%D0%B8%D0%BD%20%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%B9%D0%BD%D0%B5%D1%80%20%D0%B8%D0%B7%20%D0%BF%D1%80%D0%B5%D0%B4%D1%8B%D0%B4%D1%83%D1%89%D0%B5%D0%B3%D0%BE%20%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D1%8F">[19]</a></em>.</div><div class="t-redactor__text">Продемонстрируем на нашем примере детализацию Backend Service для подключения абонента. Предположим, серверная логика состоит из следующих компонентов: Subscription Manager (основной компонент, управляющий процессом подключения: проверяет данные, orchestrates), Billing API Client (класс/модуль, отвечающий за взаимодействие с биллингом), Provisioning API Client (модуль для связи с OSS/сетью) и Data Access (компонент доступа к базе, например репозиторий, обеспечивающий сохранение/чтение заявок). </div><img src="https://static.tildacdn.com/tild3332-3639-4063-a439-343561623664/Component___Backend_.png"><div class="t-redactor__text"> Здесь контейнер Backend разбит на компоненты: SubscriptionManager, ProvisioningAPIClient, DataAccess. Основной компонент SubscriptionManager вызывает компоненты Billing и Provisioning для выполнения внешних операций, а также использует DataAccess для работы с базой (стрелки “calls”). Показаны и внешние системы: BillingAPIClient общается с Billing System (REST API), ProvisioningAPIClient – с Provisioning Adapter (Application, интеграция с SIM capability) (SOAP), а DataAccess – с Subscription DB (SQL запросы). Внешние элементы (БД и внешние сервисы) отмечены пунктиром, указывая, что они не являются частью данного контейнера.</div><div class="t-redactor__text">Диаграмма компонентов отражает реализацию конкретной бизнес-функции на уровне приложений. Например, мы видим, что чтобы подключить абонента, <em>SubscriptionManager</em> координирует сразу несколько действий (биллинг, активация, сохранение данных). Такая схематизация помогает при разработке: можно распределить реализацию между командами (например, одна команда пишет интеграцию с биллингом, другая – ядро SubscriptionManager) и удостовериться, что все нужные части предусмотрены.</div><div class="t-redactor__text"> Примечание: Все компоненты (Subscription Manager, Billing API Client, Provisioning API Client, Data Access) являются частью Application Backend Service. Их интеграции с внешними системами реализуются через Applications типа Adapter (например, Provisioning Adapter).</div><h3  class="t-redactor__h3">Дополнительные замечания</h3><div class="t-redactor__text"><strong>Шаблоны и повторное использование:</strong> Представленный подход можно оформить как <strong>шаблонную последовательность</strong> действий. Для каждой бизнес-функции:</div><div class="t-redactor__text"><ul><li data-list="bullet">Составьте таблицу контекстов (как Таблица 1) с актором, IT-Capability, каналами, ограничениями.</li><li data-list="bullet">Для каждого контекста проделайте шаги 1–3: нарисуйте диаграмму контекста (система + акторы + интеграции), затем диаграмму контейнеров (архитектура системы), затем при необходимости – диаграмму компонентов (внутреннее устройство ключевых приложений).</li><li data-list="bullet">Убедитесь, что на диаграммах отражены все элементы из контекста: все указанные акторы должны появиться как пользователи, все IT-Capabilities – либо как сама целевая система, либо как части внутри неё, все каналы – как типы интерфейсов (например, канал “мобильное приложение” отразится контейнером Mobile App), все ограничения – как пометки или требования к компонентам (их можно указывать в документации к диаграмме). Таким образом сохраняется прослеживаемость от бизнес-модели к дизайну системы.</li><li data-list="bullet"><strong>Онтология vs диаграммы:</strong> Онто-модель обеспечивает связь между уровнями – например, зная, что функция реализует определённый бизнес-сервис, можно на контекстной диаграмме подчеркнуть, какой именно сервис предоставляется внешнему актору. Кроме того, она помогает проверить полноту диаграмм: если для функции заявлено 3 контекста, а архитектурно покрыто только 2 сценария – значит третий сценарий либо не реализован, либо потерян.</li><li data-list="bullet"><strong>Без привязки к OWL:</strong> Мы сознательно описываем онтологию на концептуальном уровне (классы, связи, атрибуты) без использования языков типа OWL, чтобы метод был понятен широкому кругу специалистов. Достаточно понимать структуру связей (как на Рис.1) и использовать её при структурировании требований и архитектурных артефактов.</li></ul></div><h2  class="t-redactor__h2">Заключение</h2><div class="t-redactor__text">Предложенная методология – своего рода “кухня” построения архитектуры на основе знаний о бизнесе. Начав с четких определений бизнес-функций, мы помещаем их в контекст выполнения (акторы, IT-Capabilities, каналы, ограничения), формализуем в виде онтологии, а затем пошагово преобразуем каждый контекст в систему и её компоненты с помощью C4-нотации. Такой подход обеспечивает трассировку: от бизнес-целей и способов работы (что делает бизнес) – к конкретным модулям программной системы (как это поддерживается технически). Он понятен бизнес-аналитикам (они видят, как их функции “переводятся” в софт), системным архитекторам (они получают исходные точки для проектирования систем под каждый сценарий), и разработчикам внешних решений (они получают наглядные схемы, какие компоненты нужны и как они взаимодействуют).</div><div class="t-redactor__text">Методология Онто + C4 способствует тому, чтобы архитектура <strong>отвечала потребностям бизнеса</strong>: каждый элемент системы можно вывести из бизнес-функции и её контекста. Это уменьшает разрывы между описанием процессов и реализацией ИТ-решений. Применяя данный “рецепт” на практике, вы сможете последовательно и обоснованно проектировать системы, обеспечивая нужный функционал в нужном контексте – будь то подключение абонентов в телекоммуникациях или любая другая бизнес-функция в вашей предметной области. Каждый шаг – от слов к схемам – прозрачен и обоснован, а результатом являются чёткие C4-диаграммы, служащие понятной документацией архитектуры внешнего продукта.</div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Интеграция RAG(Retrieval-Augmented Generation) и графов знаний в генеративных ИИ (часть 1)</title>
			<link>https://learning.ontonet.ru/tpost/69yx8icxk1-integratsiya-ragretrieval-augmented-gene</link>
			<amplink>https://learning.ontonet.ru/tpost/69yx8icxk1-integratsiya-ragretrieval-augmented-gene?amp=true</amplink>
			<pubDate>Fri, 26 Sep 2025 22:46:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>AI</category>
			<category>Knowledge Graphs</category>
			<category>LLM</category>
			<enclosure url="https://static.tildacdn.com/tild6161-3039-4936-b530-313935336464/_RAG_KG.png" type="image/png"/>
			<turbo:content>
<![CDATA[<header><h1>Интеграция RAG(Retrieval-Augmented Generation) и графов знаний в генеративных ИИ (часть 1)</h1></header><figure><img src="https://static.tildacdn.com/tild6161-3039-4936-b530-313935336464/_RAG_KG.png"/></figure><h2  class="t-redactor__h2">Интеграция RAG(Retrieval-Augmented Generation) и графов знаний в генеративных ИИ (часть 1)</h2><h2  class="t-redactor__h2"><strong>Введение</strong></h2><div class="t-redactor__text">Генеративные модели на базе больших языковых моделей (Large Language Models, LLM) добились впечатляющих успехов, однако им присуща проблема <strong>«галлюцинаций»</strong> – уверенной генерации фактологически неверной информации<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=finance%2C%20and%20education,2022">[1]</a>. Галлюцинации возникают из-за ограничений обучения: модель может полагаться на устаревшие или обобщённые данные и выдавать правдоподобные, но неверные ответы<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=finance%2C%20and%20education,2022">[1]</a>. Особенно опасно это в чувствительных областях (медицина, финансы, право), где ошибки недопустимы. Для борьбы с этим явлением исследователи обратились к стратегии <strong>Retrieval-Augmented Generation (RAG)</strong> – дополнения процесса генерации этапом поиска внешней информации<a href="https://arxiv.org/html/2311.07914v2#:~:text=Retrieval,related%20triples%20from%20knowledge%20graphs">[2]</a>. RAG, впервые предложенный компанией Facebook (Meta) в 2020 году (Lewis et al., 2020), сочетает работу LLM с модулем поиска по внешней базе знаний. При поступлении запроса сначала извлекаются релевантные документы, затем модель генерирует ответ с опорой на найденные данные<a href="https://arxiv.org/html/2311.07914v2#:~:text=Retrieval,related%20triples%20from%20knowledge%20graphs">[2]</a>. Такая архитектура позволяет <strong>уменьшить количество галлюцинаций</strong>, предоставляя модели актуальные факты в контексте и не требуя изменений в самой модели<a href="https://arxiv.org/html/2311.07914v2#:~:text=Retrieval,related%20triples%20from%20knowledge%20graphs">[2]</a>.<br /><br />Однако классические реализации RAG обычно работают с неструктурированными текстовыми данными (например, фрагментами документов), что тоже имеет ограничения. Часто извлекаются избыточные или повторяющиеся фрагменты, нарушается связность (при разбиении текстов на куски), и модель всё ещё может терять контекст или логические связи<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=Retrieval,HKUDS%20for%20LightRAG%2C%20and%20BUPT">[3]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=Before%20exploring%20graph,shortcomings%20of%20conventional%20RAG%20approaches">[4]</a>. Например, исходный подход RAG дробил документы на куски по ~100 слов, что нарушало семантику и иногда приводило к галлюцинациям<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=and%20Lee%2C%202023%29,been%20proposed%20to%20improve%20the">[5]</a>. Были предложены улучшения – скользящее окно при разбиении, контекстное расширение на уровне предложений, добавление метаданных источника и пр.<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=and%20Lee%2C%202023%29,been%20proposed%20to%20improve%20the">[5]</a> – но проблема полностью не устраняется.<br /><br />В последние пять лет появилась новая тенденция: интеграция <strong>графов знаний (Knowledge Graphs, KG)</strong> в контур RAG для более надёжного извлечения и представления знаний. <strong>Граф знаний</strong> – это структурированная база фактов, где узлы – сущности (объекты, люди, организации и т.п.), а рёбра – отношения между ними. Такой формат хранит <strong>курированные, взаимосвязанные знания</strong> и позволяет делать многшаговые выводы по связям<a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Rather%20than%20storing%20data%20in,possess%2C%20like%20size%20or%20color">[6]</a>. В данной работе представлено исследование практического использования связки RAG + граф знаний в генеративных ИИ-системах в период 2020–2025 гг. Мы рассмотрим реальные примеры от ведущих компаний (Google, Meta, OpenAI, Microsoft и др.), опишем архитектуры и методики интеграции, а также проанализируем, как это влияет на точность и надежность ответов моделей. Особое внимание уделяется снижению доли галлюцинаций благодаря использованию графов знаний и наличию открытых реализаций таких систем.</div><h2  class="t-redactor__h2">RAG и графы знаний: структурированное знание против галлюцинаций</h2><div class="t-redactor__text"><strong>Почему графы знаний?</strong> Неструктурированные документы содержат много лишнего текста и неявных связей, тогда как <strong>граф знаний предлагает явную структурированную карту фактов</strong>. В нём каждое знание представлено в виде триплета «сущность – связь – сущность», например: «Париж – столица – Франции». Такая структура <strong>более точно отражает факты и связи</strong>, чем разрозненные тексты. Исследования показывают, что <strong>использование хорошо организованных, проверенных знаний из структурированных источников (KG)</strong> позволяет лучше придерживаться фактов в ответах моделей<a href="https://arxiv.org/html/2311.07914v2#:~:text=helpful%20for%20tasks%20needing%20external,based%20retrieval%20for%20complex">[7]</a>. Иными словами, интеграция графа знаний ближе выравнивает ответы ИИ с реальной фактической информацией, снижая риск выдуманных деталей<a href="https://arxiv.org/html/2311.07914v2#:~:text=helpful%20for%20tasks%20needing%20external,based%20retrieval%20for%20complex">[7]</a>.<br /><br />Кроме того, графовые базы поддерживают <strong>логические переходы между связанными фактами</strong>, что даёт модели возможность совершать <strong>multi-hop</strong> выводы (переходы по цепочкам отношений) для ответа на сложные запросы<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=GraphRAG%20%E2%80%94%20developed%20and%20maintained,on%20a%20flat%20text%20dump">[8]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=edges%20%28capturing%20their%20relationships%29,text%20is%20transformed%20into%20a">[9]</a>. В традиционном RAG, где контекст – плоский список фрагментов текста, такие многшаговые рассуждения затруднены<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=which%20can%20mislead%20the%20LLM,in%20truncated%20or%20incomplete%20context">[10]</a>. Граф знаний же явно хранит, какие сущности связаны, и тем самым облегчает моделям поиск опорной информации через несколько шагов. Это не только повышает достоверность, но и способствует <strong>объяснимости</strong>: путь по графу знаний можно интерпретировать как основание для ответа, предоставляя своеобразное «объяснение» вывода модели<a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=By%20using%20the%20LLM,context%20window%20with%20higher%20relevance">[11]</a>. Исследования 2023–2024 гг. отмечают, что интеграция KGs в LLM не только уменьшает галлюцинации, но и <strong>улучшает логическое рассуждение, интерпретируемость и доступ к узкоспециализированным знаниям</strong><a href="https://aclanthology.org/2025.acl-srw.53.pdf#:~:text=publications%20were%20chosen%20for%20in,outline%20directions%20for%20future%20work">[12]</a>.<br /><br />Важно подчеркнуть, что использование графа знаний в RAG можно реализовать разными способами. В обзоре Agrawal et al. (2024) методы классифицируются по этапам интеграции: на стадии извлечения знаний (retrieval), на стадии самого рассуждения модели, на этапе обучения или валидации результатов<a href="https://arxiv.org/html/2311.07914v2#:~:text=The%20contemporary%20LLMs%20are%20prone,three%20overarching%20groups%2C%20offering%20methodological">[13]</a><a href="https://arxiv.org/html/2311.07914v2#:~:text=1%20Introduction">[14]</a>. Наш фокус – <em>инференс</em>, то есть как именно LLM получает и применяет структурированные факты при генерации ответа (иногда это называют <strong>KG-augmented retrieval</strong>). Здесь возможны варианты:<br /><br /><ul><li data-list="bullet"><strong>Прямой запрос к графу знаний.</strong> Модель или связанный с ней модуль формирует запрос (например, в языке запросов к графу или в виде ключевых сущностей) и извлекает из графа релевантные триплеты. Так, Baek и соавт. предложили систему <strong>KAPING (2023)</strong>, которая определяет сущности в пользовательском вопросе и подтягивает из графа знаний связанные факты-триплеты для ответа<a href="https://arxiv.org/html/2311.07914v2#:~:text=knowledge%20from%20structured%20sources%20or,augments%20LLMs%20with%20data%20from">[15]</a>. Было показано, что такая подача фактов из KG улучшает ответы моделей в задачах <strong>zero-shot</strong> вопрос-ответ, давая им нужные факты вместо того, чтобы модель «догадывалась» сама<a href="https://arxiv.org/html/2311.07914v2#:~:text=knowledge%20from%20structured%20sources%20or,augments%20LLMs%20with%20data%20from">[15]</a>. Аналогично, Wu и др. (2023) выяснили, что если преобразовать найденные триплеты в естественно-языковые утверждения и добавить их в контекст LLM, то качество ответов заметно растёт<a href="https://arxiv.org/html/2311.07914v2#:~:text=matches%20entities%20in%20questions%20to,%282023%29%2C%20and%20SAFARI%C2%A0Wang%20et%C2%A0al">[16]</a>.</li><li data-list="bullet"><strong>Специализированные графовые поисковики.</strong> Столкнувшись со сложными вопросами, в которых простого семантического совпадения недостаточно, исследователи обучают <strong>графовые модели поиска</strong>. Например, Sen и др. (2023) разработали модуль-ретривер на основе модели для вопросо-ответных задач по графам (KGQA), чтобы лучше справляться со сложными запросами, где обычный векторный поиск по тексту неэффективен<a href="https://arxiv.org/html/2311.07914v2#:~:text=matches%20entities%20in%20questions%20to,%282023%29%2C%20and%20SAFARI%C2%A0Wang%20et%C2%A0al">[16]</a>.</li><li data-list="bullet"><strong>Комбинация структурированных и неструктурированных данных.</strong> Проект <strong>StructGPT</strong> (Jiang et al., 2023) демонстрирует подход, где LLM может обращаться не только к текстам, но и к таблицам, базам данных и графам знаний, используя специализированные «структурированные» подсказки и запросы<a href="https://arxiv.org/html/2311.07914v2#:~:text=converting%20these%20triples%20into%20textualized,%282023b">[17]</a>. Это позволяет извлекать точные данные (например, числа из таблиц или факты из графа) и вставлять их в ответ, повышая его точность.</li></ul><br />Таким образом, накоплен значительный опыт по обогащению RAG структурированным знанием. Рассмотрим конкретные кейсы ведущих технологических компаний и сообществ, реализовавших связку RAG+KG на практике, и оценим, каких результатов удалось достичь.</div><h2  class="t-redactor__h2">Примеры практической интеграции графов знаний и RAG</h2><h3  class="t-redactor__h3">GraphRAG от Microsoft: графовая надстройка над RAG</h3><div class="t-redactor__text">Одним из наиболее известных примеров является <strong>GraphRAG</strong>, разработанный в Microsoft Research в 2023–2024 гг. Это расширение RAG, в котором строится <strong>граф знаний на основе анализируемой коллекции документов</strong> и используется для улучшения извлечения и ответа. Важная особенность GraphRAG – граф знаний <strong>генерируется самой LLM</strong>: модель прогоняет весь корпус данных, выделяет сущности и отношения, и на этой основе автоматически строится граф<a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=,window%20when%20answering%20a%20question">[18]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=Image%3A%20Figure%203%3A%20LLM,4%20Turbo">[19]</a>. По сути, GraphRAG создает <strong>индекс знаний в виде графа</strong> поверх исходных текстов. Далее этот граф применяется двояко: (1) <strong>На этапе поиска</strong> – вместо плоского набора фрагментов ищутся связанные подграфы, содержащие все релевантные сущности для запроса<a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Sending%20a%20query%20to%20a,data%20will%20be%20retrieved%20once">[20]</a>. Например, запрос по продуктовой базе данных вытащит связанный подграф характеристик товара, вместо десятка почти идентичных описаний<a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Sending%20a%20query%20to%20a,data%20will%20be%20retrieved%20once">[20]</a>. (2) <strong>Для смысловой агрегации</strong> – граф позволяет выявлять кластеры связанных сведений и <strong>предварительно их суммировать</strong>. В Microsoft отметили, что GraphRAG выявляет тематические сообщества в данных (по сути, группы плотно связанных узлов) и генерирует для них краткие обзоры<a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=GraphRAG%20uses%20a%20large%20language,describes%20its%20entities%20and%20their">[21]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=In%20a%20recent%20preprint%2C%20we,texts%20needed%20to%20answer%20it">[22]</a>. Это даёт модели обзор всех ключевых тем датасета ещё до поступления конкретного вопроса. Затем при запросе GraphRAG умеет отвечать на <strong>“глобальные” вопросы о всём датасете</strong>, например “каковы основные темы этого корпуса документов?”, чего не может обычный RAG<a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=In%20a%20recent%20preprint%2C%20we,texts%20needed%20to%20answer%20it">[22]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=However%2C%20if%20a%20question%20addresses,from%20the%20global%20data%20context">[23]</a>.<br /><br />Архитектура GraphRAG включает несколько модулей. В блоге Microsoft (2024) описаны стадии: <strong>переформулировка запроса</strong>, <strong>обогащение запроса</strong> (например, извлечение связанных сущностей), <strong>двойной поиск</strong> – одновременно <strong>семантический</strong> (по графу) и обычный <strong>векторный</strong> (по текстам)<a href="https://jeongiitae.medium.com/from-rag-to-graphrag-what-is-the-graphrag-and-why-i-use-it-f75a7852c10c#:~:text=When%20using%20GraphRAG">[24]</a><a href="https://jeongiitae.medium.com/from-rag-to-graphrag-what-is-the-graphrag-and-why-i-use-it-f75a7852c10c#:~:text=,information%20to%20inject%20into%20prompts">[25]</a>. Совмещение двух видов поиска позволяет проверять соответствие найденной информации: графовая составляющая подтверждает семантическую связанность результатов, а векторная – покрытие исходного текста<a href="https://jeongiitae.medium.com/from-rag-to-graphrag-what-is-the-graphrag-and-why-i-use-it-f75a7852c10c#:~:text=from%20both%20RAG%20and%20GraphRAG,accuracy%20of%20the%20fetched%20information">[26]</a>. В итоге собирается контекст для генерации ответа. При генерации GraphRAG также применяет технику <strong>prompt compression</strong> – на основе графа отбирает только наиболее важные куски знаний для включения в подсказку модели<a href="https://jeongiitae.medium.com/from-rag-to-graphrag-what-is-the-graphrag-and-why-i-use-it-f75a7852c10c#:~:text=,Retrieval%2C%20and%20Prompt%20Compression">[27]</a><a href="https://jeongiitae.medium.com/from-rag-to-graphrag-what-is-the-graphrag-and-why-i-use-it-f75a7852c10c#:~:text=,information%20to%20inject%20into%20prompts">[28]</a>. Это избавляет контекст от лишнего текста, экономя токены и снижая шанс конфабуляций.<br /><br />Практические результаты GraphRAG впечатляют. По данным Microsoft Research, интеграция графа знаний позволила <strong>значительно улучшить качество ответов</strong> по ряду параметров. В частности, при сравнительном тестировании на сложных корпусах <strong>GraphRAG в ~70–80% случаев побеждал классический RAG</strong> по метрикам полноты ответа и разнообразия содержащейся информации<a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=The%20results%20show%20that%20GraphRAG%2C,is%20shown%20in%20Figure%202">[29]</a>. Например, GraphRAG способен охватить <strong>больше аспектов вопроса</strong> и привести разные перспективы или факты, тогда как обычный RAG нередко упускает часть информации<a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=comparison%20of%20generated%20answers%2C%20as,supports%20informed%20decision%20making">[30]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=The%20results%20show%20that%20GraphRAG%2C,is%20shown%20in%20Figure%202">[29]</a>. Это особенно важно для аналитических запросов. При этом, что критически значимо, <strong>достоверность не страдает</strong>: проверка с помощью метрики SelfCheckGPT показала, что <strong>уровень фактической точности (faithfulness) у GraphRAG не ниже, чем у базового RAG</strong><a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=In%20addition%20to%20relative%20comparisons%2C,as%20accuracy%20and%20context%20relevance">[31]</a>. Иными словами, добавление графа знаний не приводит к появлению новых ошибок – ответы остаются столь же (или более) верными исходным данным. Более того, GraphRAG предоставляет пользователю прозрачность: <strong>каждое утверждение в ответе сопровождается ссылкой на исходный источник</strong><a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=By%20using%20the%20LLM,context%20window%20with%20higher%20relevance">[11]</a>. Модель буквально «прикладывает» доказательства из базы знаний к своим словам, что резко повышает доверие – пользователь может сам проверить, откуда взят тот или иной факт. На рисунке в блоге Microsoft показан пример: традиционный RAG не смог ответить на вопрос о «Novorossiya», а GraphRAG обнаружил эту сущность в графе, нашёл связанные факты и выдал развернутый ответ с цитированием источника<a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=In%20comparison%2C%20the%20GraphRAG%20approach,the%20exact%20content%20the%20LLM">[32]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=commissariats%2C%20ATMs%E2%80%99">[33]</a>. Такая <strong>прозрачность и обоснованность ответов</strong> напрямую помогает бороться с галлюцинациями, ведь модель не выдаёт непроверенную информацию – все факты подтверждены данными из графа.<br />Отдельно стоит отметить кейсы применения GraphRAG в индустрии. Банк BNP Paribas в 2025 году опубликовал результаты экспериментов с GraphRAG на финансовых документах (проекты <strong>FactRAG</strong> и <strong>HybridRAG</strong>). В задачах по нормативной документации они добились <strong>снижения числа галлюцинаций на 6%</strong> по сравнению с обычным RAG<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=strategies%E2%80%94FactRAG%20and%20HybridRAG%E2%80%94which%20leverage%20knowledge,DORA%29%20from%20the">[34]</a>, одновременно сократив количество затраченных токенов на 80%. Структурированное хранение знаний позволило эффективнее отсеивать лишнюю информацию и экономить контекст<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=performance,DORA%29%20from%20the">[35]</a>. Также за счёт графовых методов выявления противоречий повысилась точность: при сравнении двух больших регуляторных документов GraphRAG быстрее и точнее находил несовпадения и обеспечил 734-кратное снижение объёма обработанного текста, нужного для проверки консистентности<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=HybridRAG%20by%20comparing%20the%20Digital,based">[36]</a>. Этот пример демонстрирует, что <strong>GraphRAG полезен не только для открытого веб-знания, но и для частных корпоративных данных</strong> – финансовых, юридических и др., где особенно важно исключить вымышленные или ошибочные выводы. В середине 2024 г. Microsoft открыла исходный код GraphRAG<a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=private%20or%20previously%20unseen%20datasets,free%20in%20a%20few%20clicks">[37]</a>, а также выложила связанный ускоритель (GraphRAG Accelerator) для простого деплоя в Azure<a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=GraphRAG%20is%20now%20available%20on,free%20in%20a%20few%20clicks">[38]</a>. Это позволило сообществу экспериментировать с технологией и адаптировать её к своим данным. Таким образом, Microsoft продемонстрировала, что связка “LLM + граф знаний” способна значительно укрепить надёжность генеративного ИИ, и предоставила инструменты для её практического внедрения.</div><h3  class="t-redactor__h3"><strong>DataGemma от Google: привязка языковых моделей к фактам Data Commons</strong></h3><div class="t-redactor__text">Компания Google также активно работает над снижением галлюцинаций путём подключения LLM к структурированным данным. В 2024 году Google представила проект <strong>DataGemma</strong> – семейство открытых моделей, которые <strong>соединяют языковую модель с огромным графом статистических данных Google Data Commons</strong><a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=DataGemma%20are%20the%20world%E2%80%99s%20first,data%20of%20Google%27s%20Data%20Commons">[39]</a><a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=statistical%20information,drawn%20from%20Google%27s%20Data%20Commons">[40]</a>. Data Commons – это общедоступный граф знаний, агрегирующий свыше 240 миллиардов статистических фактов из надёжных источников (ООН, ВОЗ, Всемирный банк и др.)<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=Data%20Commons%3A%20A%20vast%20repository,of%20publicly%20available%2C%20trustworthy%20data">[41]</a>. Идея DataGemma в том, чтобы <strong>«приземлить» ответы модели на прочный фундамент реальной статистики</strong>, особенно для вопросов, связанных с данными, числами и актуальными фактами<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=Today%20we%27re%20sharing%20promising%20research,drawn%20from%20Google%27s%20Data%20Commons">[42]</a>.<br /><br />В рамках DataGemma Google исследовал два режима интеграции знаний: <strong>Retrieval-Interleaved Generation (RIG)</strong> и классический <strong>Retrieval-Augmented Generation (RAG)</strong><a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=1.%20RIG%20%28Retrieval,the%20DataGemma%20framework%20is%20unique">[43]</a><a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=2.%20RAG%20%28Retrieval,enhancing%20the%20accuracy%20of%20responses">[44]</a>. RIG предполагает, что модель <strong>динамически сама делает запросы</strong> к базе во время генерации ответа, чтобы проверить факты (“interleaved” – перемежая генерацию запросами)<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=1.%20RIG%20%28Retrieval,the%20DataGemma%20framework%20is%20unique">[43]</a>. По сути, модель пытается <em>фактчекинг</em> в реальном времени: заметив, что нужен статистический показатель, она извлекает его из Data Commons и включает в ответ. RAG же в реализации Google – это использование расширенного контекста: перед генерацией <strong>модель получает релевантные выдержки из Data Commons</strong> по заданному вопросу<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=2.%20RAG%20%28Retrieval,enhancing%20the%20accuracy%20of%20responses">[44]</a>. Так, на запрос <em>«Повысилось ли использование возобновляемых источников энергии в мире?»</em> DataGemma-RAG найдёт в графе знаний последние мировые данные по возобновляемой энергетике и выдаст ответ с этими цифрами, снабдив сноской на источник<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=1.%20RIG%20%28Retrieval,the%20DataGemma%20framework%20is%20unique">[43]</a><a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=2.%20RAG%20%28Retrieval,enhancing%20the%20accuracy%20of%20responses">[44]</a>. Благодаря длинному контекстному окну (в эксперименте использовалась модель Gemini 1.5 Pro с расширенным контекстом) модель способна учесть большой объем фактов перед генерацией ответа<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=2.%20RAG%20%28Retrieval,enhancing%20the%20accuracy%20of%20responses">[44]</a>. <strong>Ключевое – ответы DataGemma обогащены проверенными данными, что минимизирует риск галлюцинаций</strong> по критически важным пунктам<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=language%20model%2C%20Gemma%202%2C%20by,the%20DataGemma%20framework%20is%20unique">[45]</a><a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=2.%20RAG%20%28Retrieval,enhancing%20the%20accuracy%20of%20responses">[44]</a>.<br /><br />Предварительные результаты Google оказались обнадёживающими. Разработчики сообщают, что при использовании RAG/RIG с Data Commons <strong>точность ответов модели на запросы с числовыми данными заметно возросла</strong><a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=Our%20preliminary%20findings%20using%20RIG,making%20or%20simply">[46]</a>. Модель стала правильно называть статистику там, где ранее могла бы угадывать. В результате пользователи, по оценке Google, <strong>столкнутся с существенно меньшим количеством галлюцинаций</strong> во многих сценариях – от исследовательских запросов до повседневных вопросов из любопытства<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=Our%20preliminary%20findings%20using%20RIG,making%20or%20simply">[46]</a>. Проще говоря, если модель знает, где взять истинный факт, ей нет нужды его выдумывать. Команда Google опубликовала демонстрационные блокноты (Colab) для RIG и RAG с DataGemma и открыла доступ исследователям к самой модели на HuggingFace<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=DataGemma%20models%20are%20available%20to,researchers%20and%20developers%20starting%20now">[47]</a><a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=By%20sharing%20our%20research%20and,of%20the%20world%20around%20us">[48]</a>. Это свидетельствует об уверенности в том, что такой подход полезен и для сообщества. Более того, в блоге отмечается намерение <strong>внедрить эту функциональность в будущие модели семейства Gemini</strong> (флагманские LLM Google)<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=Our%20research%20is%20ongoing%2C%20and,access%20approach">[49]</a>, сначала в ограниченном доступе. То есть Google планирует на производственном уровне <strong>интегрировать граф знаний Data Commons в свои ИИ-системы</strong>, сделав их ответы более надёжными. В совокупности, опыт Google показывает, что <strong>привязка генеративной модели к масштабному глобальному графу знаний</strong> способна существенно уменьшить фактологические ошибки. Модель не просто черпает из “интернета” (где данные могут быть устаревшими или недостоверными), а обращается к <strong>единому достоверному источнику</strong>. Это особенно ценно для вопросов о свежих данных (например, статистика последних лет), где обычная LLM без обновления знаний будет галлюцинировать. DataGemma решает эту проблему, соединяя лучшее из двух миров: мощь генеративной модели и достоверность базы знаний.</div><h3  class="t-redactor__h3"><strong>LightRAG и PathRAG: оптимизация знаний для эффективности</strong></h3><div class="t-redactor__text">Помимо крупных компаний, вклад в развитие связки RAG+KG внесло академическое сообщество и стартапы. Появилось несколько ответвлений, нацеленных на улучшение <strong>эффективности</strong> и <strong>фокусировки</strong> при использовании графов знаний.<br /><br /><strong>LightRAG</strong> – разработка команды HKUDS (Гонконг) в 2023 г., которая стремится сохранить основные преимущества GraphRAG, но сделать систему более лёгкой и быстрой<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=LightRAG%20,scale%20GraphRAG">[50]</a>. Авторы LightRAG отмечают, что построение полного графа знаний для большого корпуса – затратная операция (как по вычислениям, так и по поддержке обновления данных)<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=Limitations%3A">[51]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=,indexing%20or%20partial%20rebuilds">[52]</a>. Поэтому LightRAG предлагает <strong>«облегчённый» графовый индекс</strong>, который включает <strong>только самые важные сущности и связи</strong><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=%2A%20Lean%20Graph,the%20system%20avoids%20information%20overload">[53]</a>. Фактически происходит отбор ключевых узлов и рёбер, релевантных решаемым задачам, формируя компактный граф. Далее LightRAG использует <strong>двухуровневый поиск</strong>: локальный (по ключевым узлам графа) и глобальный (по остальным данным)<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=and%20relationships%2C%20generating%20a%20%E2%80%9Clightweight%E2%80%9D,As">[54]</a>. Это позволяет, с одной стороны, быстро находить точечные факты, а с другой – не потерять общий контекст<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=%2A%20Dual,scale%20graph%20reconstruction">[55]</a>. Важная особенность – <strong>инкрементальное обновление</strong> графа: LightRAG умеет добавлять новые данные, перестраивая только затронутые части графа, без полной переработки всего индекса<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=overload.%20,this%20lean%20indexing%20approach%20works">[56]</a>. Преимущества такого подхода: <strong>высокая эффективность</strong> (меньше вычислений, чем у полного GraphRAG) и <strong>гибкость</strong> для динамически меняющихся данных<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=,suited%20for%20rapidly%20changing%20environments">[57]</a>. Разработчики показывают, что LightRAG достигает сопоставимого качества извлечения, экономя при этом значительные ресурсы<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=,suited%20for%20rapidly%20changing%20environments">[57]</a>. Однако за счёт агрессивной фильтрации информации LightRAG <strong>может упускать тонкие детали</strong> – если важный факт не попал в лёгкий граф, модель его не учтёт<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=Limitations%3A">[58]</a>. Таким образом, LightRAG – это компромиссный вариант: снижение нагрузки ценой потенциальной потери некоторой глубины знаний. Код LightRAG также открыт на GitHub<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=LightRAG%20,scale%20GraphRAG">[50]</a>, что позволило провести независимые оценки и убедиться в его эффективности на различных корпусах.<br /><br /><strong>PathRAG</strong> – другое направление, предложенное командой BUPT-GAMMA (Пекинский университет почты и телеком) в 2023 г. Если GraphRAG строит полный граф, а LightRAG сокращает граф по узлам, то PathRAG концентрируется на <strong>наиболее важных путях в графе знаний</strong><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=PathRAG%20distinguishes%20itself%20with%20a,a%20knowledge%20graph%2C%20rather%20than">[59]</a>. Основная идея PathRAG: для каждого запроса <strong>выделить подграф, связанный с запросом, и в нём отфильтровать только те пути (последовательности связей), которые непосредственно относятся к вопросу</strong><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=PathRAG%20begins%20by%20isolating%20the,Based%20Path%20Pruning">[60]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=By%20filtering%20out%20less%20useful,of%20token%20bloat%2C%20enabling%20the">[61]</a>. По сути, PathRAG реализует <strong>умную обрезку графа</strong>. Алгоритм начинает с поиска в графе узлов, наиболее соответствующих запросу (релевантных сущностей)<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=PathRAG%20begins%20by%20isolating%20the,Based%20Path%20Pruning">[60]</a>. Затем выполняется <em>pruning</em> – отсечение всех ветвей, которые не ведут к этим узлам напрямую или через короткие связи<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=PathRAG%20begins%20by%20isolating%20the,Based%20Path%20Pruning">[60]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=match%20at%20L223%20By%20filtering,of%20token%20bloat%2C%20enabling%20the">[62]</a>. Остаются <strong>только «магистральные» пути знаний</strong>, по которым информация перетекает к ключевым сущностям вопроса. Эти пути превращаются в компактный контекст для LLM. Такой подход имеет два явных плюса: во-первых, модель получает <strong>высоко релевантные и концентрированные данные без информационного шума</strong><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=match%20at%20L223%20By%20filtering,of%20token%20bloat%2C%20enabling%20the">[62]</a>; во-вторых, <strong>сокращается объём токенов</strong>, необходимых для представления знаний – ничего лишнего не включается<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=By%20filtering%20out%20less%20useful,of%20token%20bloat%2C%20enabling%20the">[61]</a>. Авторы PathRAG подчёркивают, что система <strong>минимизирует избыточность</strong> и тем самым экономит контекстное окно и снижает риски «утонуть» в посторонней информации<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=match%20at%20L196%20GAMMA%2FPathRAG%2C%20this,minimizing%20redundancy%20and%20token%20waste">[63]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=match%20at%20L223%20By%20filtering,of%20token%20bloat%2C%20enabling%20the">[62]</a>. По результатам их экспериментов PathRAG показал <strong>высокую точность и интерпретируемость</strong> ответов: поскольку внимание уделяется только ключевым фактам, ответы получаются чёткими и обоснованными, а каждый шаг рассуждения можно проследить по выбранному пути в графе<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=LightRAG%2C%20and%20PathRAG%20marks%20a,the%20field%20of%20knowledge%20retrieval">[64]</a>. Проект PathRAG также доступен на GitHub<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=PathRAG%20is%20the%20brainchild%20of,work%20has%20significantly%20influenced%20the">[65]</a> и получил внимание сообщества как пример тонкой настройки баланса между полнотой и точностью знаний.<br /><br />Помимо LightRAG и PathRAG, в 2024–2025 гг. появились и другие гибридные решения. Некоторые компании предлагают интегрировать существующие <strong>графовые базы данных</strong> в RAG-пайплайн. Например, в облачной платформе AWS есть инструменты для подключения собственного <strong>непрерывно обновляемого графа знаний</strong> к RAG-приложениям, используя сервисы Amazon Neptune (граф СУБД) совместно с генеративными ИИ. Появились утилиты в популярных библиотеках: фреймворк <strong>LangChain</strong> включает модули LLMGraphTransformer и Diffbot для автоматического извлечения графа из текстов, а также модель <strong>REBEL</strong> для выделения отношений из неструктурированного текста<a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=built%20to%20extract%20information%20from,tool%20REBEL%20is%20another%20option">[66]</a>. Это позволяет разработчикам быстро построить граф знаний из своих документов и добавить его в контур RAG. Интересно, что при небольших масштабах данных вовсе не обязателен развёрнутый графовый движок – эксперты показывают, что <strong>небольшие графовые запросы можно выполнять и на существующих реляционных базах или даже в памяти</strong>, не разворачивая отдельно GraphDB<a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Diffbot%2C%20while%20the%20knowledge%20extraction,tool%20REBEL%20is%20another%20option">[67]</a><a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Storing%20your%20knowledge%20graph%20data,with%20new%20data%20over%20time">[68]</a>. Такой <strong>прагматичный подход</strong> упрощает внедрение: компания может хранить знания в привычной базе, а поверх реализовать логику выборки по графу в несколько запросов SQL или Gremlin, интегрировав это с LLM.<br /><br />В целом, разнообразие проектов – от тяжеловесного GraphRAG до узкоспециализированного PathRAG – демонстрирует высокий интерес сообщества к сочетанию RAG и графов знаний. Каждый подход стремится снизить галлюцинации и повысить точность, но делает это с разных углов (полнота vs. быстродействие vs. минимизация токенов). А открытость кода многих решений стимулирует дальнейшие улучшения и адаптации под разные задачи.</div><div class="t-redactor__text">Выводы, заключение и ссылки на используемые при подготовке статьи материалы <a href="https://ontonet.ru/learning/tpost/hougegkla1-integratsiya-ragretrieval-augmented-gene" target="_blank" rel="noreferrer noopener">в продолжении</a></div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Интеграция RAG(Retrieval-Augmented Generation) и графов знаний в генеративных ИИ (выводы и заключение)</title>
			<link>https://learning.ontonet.ru/tpost/hougegkla1-integratsiya-ragretrieval-augmented-gene</link>
			<amplink>https://learning.ontonet.ru/tpost/hougegkla1-integratsiya-ragretrieval-augmented-gene?amp=true</amplink>
			<pubDate>Sat, 27 Sep 2025 11:16:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>AI</category>
			<category>Knowledge Graphs</category>
			<category>LLM</category>
			<enclosure url="https://static.tildacdn.com/tild3938-6339-4630-b231-366433636239/_RAG_KG2.png" type="image/png"/>
			<turbo:content>
<![CDATA[<header><h1>Интеграция RAG(Retrieval-Augmented Generation) и графов знаний в генеративных ИИ (выводы и заключение)</h1></header><figure><img src="https://static.tildacdn.com/tild3938-6339-4630-b231-366433636239/_RAG_KG2.png"/></figure><h2  class="t-redactor__h2">Интеграция RAG(Retrieval-Augmented Generation) и графов знаний в генеративных ИИ (Выводы и заключение)</h2><h2  class="t-redactor__h2"><strong>Влияние интеграции графов знаний на качество и точность ответов</strong></h2><div class="t-redactor__text">Практические кейсы последних лет практически единодушно подтверждают: <strong>добавление графа знаний делает ответы генеративных моделей более точными, полными и проверяемыми</strong>. Рассмотрим ключевые аспекты влияния.<br /><br /><strong>Снижение числа галлюцинаций.</strong> Главный критерий – стало ли меньше неправдивых выдуманных фактов в ответах. По приведённым примерам, ответ – да. В финансовом эксперименте FactRAG (BNP Paribas) графовый подход дал на 6% меньше галлюцинаций относительно базовой системы<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=strategies%E2%80%94FactRAG%20and%20HybridRAG%E2%80%94which%20leverage%20knowledge,DORA%29%20from%20the">[34]</a>. В проектах Microsoft GraphRAG при оценке на новостных и социальных датасетах отмечено, что модель <strong>чаще даёт корректные ответы на сложные вопросы</strong>, избегая случаев «не знаю, но скажу»<a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=In%20comparison%2C%20the%20GraphRAG%20approach,the%20exact%20content%20the%20LLM">[32]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=commissariats%2C%20ATMs%E2%80%99">[33]</a>. Система SelfCheckGPT зафиксировала, что фактическая точность ответов GraphRAG по важным утверждениям не уступает оригиналу, при том что содержательность ответа выше<a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=In%20addition%20to%20relative%20comparisons%2C,as%20accuracy%20and%20context%20relevance">[31]</a>. В случае Google DataGemma интеграция с Data Commons привела к заметному сокращению ошибок при работе с количественной информацией, и Google ожидает <strong>существенного уменьшения галлюцинаций</strong> в пользовательских сценариях на базе этой технологии<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=Our%20preliminary%20findings%20using%20RIG,making%20or%20simply">[46]</a>. По сути, <strong>структурированные знания действуют как “прививка от галлюцинаций”</strong>: модель опирается на прочные факты и уже не вынуждена фантазировать.<br /><br /><strong>Повышение полноты и связности ответов.</strong> Граф знаний помогает охватить больше релевантных деталей. Например, GraphRAG в ответе на глобальный вопрос сумел перечислить <strong>5 ключевых тематических направлений</strong> корпуса новостей, в то время как обычный RAG упомянул лишь 2 общих темы<a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=match%20at%20L334%20However%2C%20with,summarized.%C2%A0The%20LLM%20uses%20these">[69]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=match%20at%20L395%20Observing%20the,by%20the%20LLM%20for%20each">[70]</a>. Модель с доступом к графу «видит картину целиком», поэтому её ответ более комплексный. При этом сохраняется и логическая связность: раз граф объединяет связанные факты, в ответе они тоже подаются связно, а не как разрозненные предложения. PathRAG показал, что сфокусированный на ключевых путях контекст позволяет давать <strong>чёткие ответы без лишней “воды”</strong>, сохраняя в них только суть вопроса<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=match%20at%20L223%20By%20filtering,of%20token%20bloat%2C%20enabling%20the">[62]</a>.<br /><br /><strong>Обоснованность и воспроизводимость.</strong> Ещё одно важное следствие – <strong>улучшение объяснимости ответов</strong>. Когда LLM черпает информацию из KG, она зачастую возвращает вместе с ответом и указание на источник (например, первичный документ или узел графа). GraphRAG, как обсуждалось, цитирует оригинальные тексты – это делает ответы <em>воспроизводимыми</em>: другой исследователь, имея тот же граф знаний, может повторно получить эти же факты, проверив путь по графу. Более формально, интеграция KG добавляет элемент <strong>доказательного рассуждения</strong> – путь в графе можно рассматривать как простейшее доказательство. Некоторые работы выделяют это как отдельное преимущество: модель становится <strong>«knowledge-grounded»</strong>, а значит, более доверенной пользователем<a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=By%20using%20the%20LLM,context%20window%20with%20higher%20relevance">[11]</a>. Если раньше пользователь должен был «поверить на слово» чёрному ящику нейросети, то теперь он может сам проверить цепочку: сущность A связана с B (см. граф), B связана с C, поэтому утверждается факт A–C. Вдобавок, наличие структурированных данных позволяет внедрять <strong>дополнительные проверки</strong> – например, верифицировать ответы с помощью внешних правил или валидаторов. Это то, что исследователи называют повышением <strong>контролируемости и воспроизводимости</strong> работы LLM. В обзоре Wagner et al. (2025) подчёркивается: помимо борьбы с галлюцинациями, граф знаний в цикле вывода улучшает <strong>объяснимость решений</strong> и даёт доступ к точному отраслевому знанию, что в сумме повышает надёжность всей системы<a href="https://aclanthology.org/2025.acl-srw.53.pdf#:~:text=publications%20were%20chosen%20for%20in,outline%20directions%20for%20future%20work">[12]</a>.<br /><br /><strong>Показатели качества на открытых бенчмарках.</strong> Integraция KG отражается и на метриках стандартных наборов задач. По ряду исследований 2022–2023 гг., модели с доступом к графам знаний показывали <strong>лучшую точность ответа на вопросы</strong> (метрики Hits@1, точность выбора верного варианта и т.п.) по сравнению с обычными LLM, особенно на сложных вопросах с несколькими шагами логики<a href="https://arxiv.org/html/2311.07914v2#:~:text=knowledge%20from%20structured%20sources%20or,databases%2C%20utilizing%20structured%20queries%20for">[71]</a><a href="https://arxiv.org/html/2311.07914v2#:~:text=KG,%28%20107%29%2C%20Reflexion%C2%A0Shinn%20et%C2%A0al">[72]</a>. Есть данные, что и в генеративных задачах (например, порождение объяснений или обоснованных выводов) такие модели превосходят по критериям корректности и логичности вывода. Таким образом, добавление KG обычно измеримо улучшает качество, что зафиксировано как в промышленных, так и академических оценках.<br /><br /><strong>Стоимость и производительность.</strong> Интересно отметить, что графовые методы могут ещё и <strong>снижать вычислительные затраты</strong>. Парадоксально, но факт: лучше структурировав знания, можно сократить объём данных, которые приходится каждый раз прокачивать через модель. Пример – 80% экономии токенов в эксперименте FactRAG уже упомянут<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=performance,DORA%29%20from%20the">[35]</a>. Другой пример: GraphRAG при ответах на глобальные вопросы тратил лишь 2–3% токенов от объёма, который потребовался бы на наивное суммирование всех документов для ответа, показав при этом равное или лучшее покрытие информации<a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=the%20community%20hierarchy%2C%20outperforms%20naive,is%20shown%20in%20Figure%202">[73]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=community%20summaries%20also%20performed%20better,is%20shown%20in%20Figure%202">[74]</a>. LightRAG и PathRAG также нацелены на оптимизацию – они уменьшают граф до нужного минимума, что ускоряет поиск и снижает нагрузку. В конечном счёте, это повышает <strong>практическую пригодность</strong>: быстрее ответы, ниже требования к памяти и т.д. Для бизнеса это важный фактор качества – решение должно быть не только точным, но и экономичным.<br /><br />Конечно, есть и <strong>ограничения</strong>. Интеграция графов знаний требует усилий по подготовке и поддержанию графа (либо автоматического, либо ручного). Если данные очень динамичны, граф нужно часто обновлять, иначе он тоже устареет и станет источником ошибок<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=,indexing%20or%20partial%20rebuilds">[52]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=overload.%20,this%20lean%20indexing%20approach%20works">[56]</a>. Также, как упоминалось, урезанные графы могут пропускать факты. Поэтому в каждом случае важно оценивать, оправданы ли выгоды – например, на узкотематических задачах с небольшим количеством документов обычный RAG может быть достаточен. Но в сложных областях, где критична достоверность, граф знаний становится практически необходимым звеном.</div><h2  class="t-redactor__h2"><strong>Заключение</strong></h2><div class="t-redactor__text">С 2020 по 2025 год мы наблюдаем формирование <strong>нового технического подхода</strong> в области генеративного ИИ: объединение мощи больших языковых моделей с <strong>структурированным знанием графов</strong>. Эта связка RAG+KG зародилась как ответ на проблему галлюцинаций – и уверенно доказала свою эффективность. Примеры от технологических гигантов (Microsoft GraphRAG, Google DataGemma) и исследования ведущих групп показали, что <strong>LLM, подкреплённая знанием из графа, выдаёт более точные, консистентные и обоснованные ответы</strong>. Количество фактических ошибок уменьшается, модель начинает “знать, о чём говорит” – ведь за каждым её словом стоят конкретные узлы графа знаний.<br /><br />Интеграция графа знаний не только повышает фактическую <strong>точность</strong>, но и даёт дополнительные плюсы: улучшает <strong>понимание контекста</strong> за счёт многосвязных данных, позволяет отвечать на комплексные запросы, требующие синтеза разрозненных фактов, обеспечивает <strong>прозрачность</strong> – пользователь может увидеть, откуда взялась информация. Всё это крайне важно для доверия к ИИ-системам. Можно сказать, что граф знаний играет роль <strong>«компаса истины»</strong> для языковой модели, направляя генерацию и предотвращая уход в вымысел.<br /><br />Практическая реализация таких систем за последние годы стала гораздо доступнее. Открыты исходные реализации (GraphRAG<a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=private%20or%20previously%20unseen%20datasets,free%20in%20a%20few%20clicks">[37]</a>, LightRAG, PathRAG и др.), появилось множество библиотек и инструментов для интеграции внешних знаний (от LangChain до плагинов ChatGPT<a href="https://arxiv.org/html/2311.07914v2#:~:text=LLMs%20serve%20as%20natural%20language,these%20models%20perform%20well%20with">[75]</a>). Это позволяет инженерам создавать собственные <strong>гибридные интеллектуальные системы</strong>, где знание хранится в базе/графе, а генеративная модель – в диалоге с этой базой. Уже сейчас такие системы применяются для корпоративных чатботов, анализаторов документов, рекомендательных сервисов и т.д., то есть там, где нужна <strong>точность и актуальность ответа</strong>.<br /><br />Перспективы на будущее выглядят многообещающе. Ожидается дальнейшее развитие методов автоматического построения графов знаний из текстов (чтобы сразу извлекать знания при обучении моделей) и более глубокая интеграция – вплоть до того, что будущие LLM будут изначально тренироваться с учётом графовых знаний для получения <strong>«knowledge-aware»</strong> интеллектов. Кроме того, возможен прогресс в <strong>оценке фактической достоверности</strong>: появятся метрики и бенчмарки, напрямую измеряющие снижение галлюцинаций при использовании KGs<a href="https://aclanthology.org/2025.acl-srw.53.pdf#:~:text=traversed%2C%20and%20how%20the%20context,outline%20directions%20for%20future%20work">[76]</a><a href="https://aclanthology.org/2025.acl-srw.53.pdf#:~:text=of%20knowledge%20graphs%20,enhanced%20LLMs">[77]</a>. Всё это будет способствовать созданию <strong>более надёжных и объяснимых ИИ</strong>, которым можно доверять решение информационных задач.<br /><br />Подводя итог, последние пять лет стали периодом зарождения и становления практик RAG+Knowledge Graph. Полученные результаты ясно показывают: <strong>структурированные знания – мощный союзник генеративного ИИ</strong>. Совмещение гибкости нейросетевого текста и строгости графовой фактуры даёт системы, которые говорят не только убедительно, но и по делу. Уменьшение галлюцинаций – ключевой шаг на пути к ответственному ИИ, и связка с графами знаний уже сейчас зарекомендовала себя как один из наиболее действенных путей к этой цели.</div><h2  class="t-redactor__h2"><strong>Источники</strong></h2><div class="t-redactor__text"><ul><li data-list="bullet">Lewis et al., 2020. Retrieval-Augmented Generation for Knowledge-Intensive NLP. <em>(введен термин RAG, показано улучшение точности ответов за счёт поиска по базе знаний)</em>.</li><li data-list="bullet">Microsoft Research Blog. <em>GraphRAG: Unlocking LLM discovery on narrative private data</em> (Feb 13, 2024) – описание концепции GraphRAG и преимуществ на сложных датасетах<a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=match%20at%20L179%20GraphRAG%20uses,performing%20discovery%20on%20private%20datasets">[78]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=By%20using%20the%20LLM,context%20window%20with%20higher%20relevance">[11]</a>.</li><li data-list="bullet">Microsoft Research Blog. <em>GraphRAG: New tool for complex data discovery now on GitHub</em> (July 2, 2024) – анонс открытого релиза GraphRAG и результаты оценки (выигрыш по метрикам полноты/разнообразия)<a href="https://www.microsoft.com/en-us/research/blog/graphrag-new-tool-for-complex-data-discovery-now-on-github/#:~:text=The%20results%20show%20that%20GraphRAG%2C,is%20shown%20in%20Figure%202">[29]</a><a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=In%20addition%20to%20relative%20comparisons%2C,as%20accuracy%20and%20context%20relevance">[31]</a>.</li><li data-list="bullet">Mariam Barry et al., 2025. <em>GraphRAG: Leveraging Graph-Based Efficiency to Minimize Hallucinations in LLM-Driven RAG for Finance Data</em>. GenAI&amp;KG Workshop – применение GraphRAG в финансах, 6% снижение галлюцинаций<a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=strategies%E2%80%94FactRAG%20and%20HybridRAG%E2%80%94which%20leverage%20knowledge,DORA%29%20from%20the">[34]</a>, 80% экономия токенов.</li><li data-list="bullet">Dom Couldwell, 2024. <em>Overcoming AI hallucinations with RAG and knowledge graphs</em>. InfoWorld (Sept 17, 2024) – обзор преимуществ сочетания RAG с графами на примере GraphRAG, объяснение принципов<a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Combining%20knowledge%20graphs%20with%20RAG,semantic%20understanding%20in%20your%20requests">[79]</a><a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Using%20a%20knowledge%20graph%20with,RAG">[80]</a>.</li><li data-list="bullet">Garima Agrawal et al., 2024. <em>Can Knowledge Graphs Reduce Hallucinations in LLMs? – A Survey</em>. arXiv 2311.07914 – обзор методов интеграции KG в разных стадиях работы LLM, эффекты на фактичность<a href="https://arxiv.org/html/2311.07914v2#:~:text=Retrieval,related%20triples%20from%20knowledge%20graphs">[2]</a><a href="https://aclanthology.org/2025.acl-srw.53.pdf#:~:text=publications%20were%20chosen%20for%20in,outline%20directions%20for%20future%20work">[12]</a>.</li><li data-list="bullet">Robin Wagner et al., 2025. <em>Mitigating Hallucination by Integrating Knowledge Graphs into LLM Inference – a Systematic Literature Review</em>. ACL 2025 – систематический обзор 9 работ, вывод о снижении галлюцинаций и росте объяснимости при использовании KG<a href="https://aclanthology.org/2025.acl-srw.53.pdf#:~:text=publications%20were%20chosen%20for%20in,outline%20directions%20for%20future%20work">[12]</a>.</li><li data-list="bullet">Google AI Blog. <em>DataGemma: Using real-world data to address AI hallucinations</em> (Sept 12, 2024) – представление DataGemma, использование графа Data Commons, уменьшение ошибок на числовых фактах<a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=language%20model%2C%20Gemma%202%2C%20by,the%20DataGemma%20framework%20is%20unique">[45]</a><a href="https://blog.google/technology/ai/google-datagemma-ai-llm/#:~:text=Our%20preliminary%20findings%20using%20RIG,making%20or%20simply">[46]</a>.</li><li data-list="bullet">Robert Dennyson, 2025. <em>Revolutionizing RAG with Knowledge Graphs: The Future of Contextual AI</em>. Medium (Apr 13, 2025) – обзор GraphRAG, LightRAG, PathRAG, их плюсы/минусы и отличия<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=Retrieval,HKUDS%20for%20LightRAG%2C%20and%20BUPT">[3]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=match%20at%20L196%20GAMMA%2FPathRAG%2C%20this,minimizing%20redundancy%20and%20token%20waste">[63]</a>.</li><li data-list="bullet">Jeong Yitae, 2024. <em>From RAG to GraphRAG – Why I use it</em>. Medium (Mar 12, 2024) – детали реализации GraphRAG, модули семантического и векторного поиска, рекомендации по применению<a href="https://jeongiitae.medium.com/from-rag-to-graphrag-what-is-the-graphrag-and-why-i-use-it-f75a7852c10c#:~:text=from%20both%20RAG%20and%20GraphRAG,accuracy%20of%20the%20fetched%20information">[26]</a><a href="https://jeongiitae.medium.com/from-rag-to-graphrag-what-is-the-graphrag-and-why-i-use-it-f75a7852c10c#:~:text=match%20at%20L263%20Overall%2C%20GraphRAG,relevance%20of%20the%20responses%20generated">[81]</a>.</li><li data-list="bullet">Прочие: Baek et al. 2023 (KAPING)<a href="https://arxiv.org/html/2311.07914v2#:~:text=knowledge%20from%20structured%20sources%20or,augments%20LLMs%20with%20data%20from">[15]</a>, Wu et al. 2023<a href="https://arxiv.org/html/2311.07914v2#:~:text=matches%20entities%20in%20questions%20to,%282023%29%2C%20and%20SAFARI%C2%A0Wang%20et%C2%A0al">[16]</a>, Sen et al. 2023<a href="https://arxiv.org/html/2311.07914v2#:~:text=matches%20entities%20in%20questions%20to,%282023%29%2C%20and%20SAFARI%C2%A0Wang%20et%C2%A0al">[16]</a>, Jiang et al. 2023 (StructGPT)<a href="https://arxiv.org/html/2311.07914v2#:~:text=converting%20these%20triples%20into%20textualized,%282023b">[17]</a> – исследования по интеграции KG для улучшения QA; PathRAG (Chen et al. 2023)<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=PathRAG%20distinguishes%20itself%20with%20a,a%20knowledge%20graph%2C%20rather%20than">[59]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=match%20at%20L223%20By%20filtering,of%20token%20bloat%2C%20enabling%20the">[62]</a>; LightRAG (Xu et al. 2023)<a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=%2A%20Lean%20Graph,the%20system%20avoids%20information%20overload">[53]</a><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=,suited%20for%20rapidly%20changing%20environments">[57]</a> и др.</li></ul></div><h2  class="t-redactor__h2">Сноски в статье</h2><div class="t-redactor__text"><ol><li data-list="ordered"><a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=finance%2C%20and%20education,2022">[1]</a> <a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=and%20Lee%2C%202023%29,been%20proposed%20to%20improve%20the">[5]</a> <a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=strategies%E2%80%94FactRAG%20and%20HybridRAG%E2%80%94which%20leverage%20knowledge,DORA%29%20from%20the">[34]</a> <a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=performance,DORA%29%20from%20the">[35]</a> <a href="https://aclanthology.org/2025.genaik-1.6.pdf#:~:text=HybridRAG%20by%20comparing%20the%20Digital,based">[36]</a> GraphRAG: Leveraging Graph-Based Efficiency to Minimize Hallucinations in LLM-Driven RAG for Finance Data <a href="https://aclanthology.org/2025.genaik-1.6.pdf">https://aclanthology.org/2025.genaik-1.6.pdf</a></li><li data-list="ordered"><a href="https://arxiv.org/html/2311.07914v2#:~:text=Retrieval,related%20triples%20from%20knowledge%20graphs">[2]</a> <a href="https://arxiv.org/html/2311.07914v2#:~:text=helpful%20for%20tasks%20needing%20external,based%20retrieval%20for%20complex">[7]</a> <a href="https://arxiv.org/html/2311.07914v2#:~:text=The%20contemporary%20LLMs%20are%20prone,three%20overarching%20groups%2C%20offering%20methodological">[13]</a> <a href="https://arxiv.org/html/2311.07914v2#:~:text=1%20Introduction">[14]</a> <a href="https://arxiv.org/html/2311.07914v2#:~:text=knowledge%20from%20structured%20sources%20or,augments%20LLMs%20with%20data%20from">[15]</a> <a href="https://arxiv.org/html/2311.07914v2#:~:text=matches%20entities%20in%20questions%20to,%282023%29%2C%20and%20SAFARI%C2%A0Wang%20et%C2%A0al">[16]</a> <a href="https://arxiv.org/html/2311.07914v2#:~:text=converting%20these%20triples%20into%20textualized,%282023b">[17]</a> <a href="https://arxiv.org/html/2311.07914v2#:~:text=knowledge%20from%20structured%20sources%20or,databases%2C%20utilizing%20structured%20queries%20for">[71]</a> <a href="https://arxiv.org/html/2311.07914v2#:~:text=KG,%28%20107%29%2C%20Reflexion%C2%A0Shinn%20et%C2%A0al">[72]</a> <a href="https://arxiv.org/html/2311.07914v2#:~:text=LLMs%20serve%20as%20natural%20language,these%20models%20perform%20well%20with">[75]</a> Can Knowledge Graphs Reduce Hallucinations in LLMs? : A Survey <a href="https://arxiv.org/html/2311.07914v2">https://arxiv.org/html/2311.07914v2</a></li><li data-list="ordered"><a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=Retrieval,HKUDS%20for%20LightRAG%2C%20and%20BUPT">[3]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=Before%20exploring%20graph,shortcomings%20of%20conventional%20RAG%20approaches">[4]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=GraphRAG%20%E2%80%94%20developed%20and%20maintained,on%20a%20flat%20text%20dump">[8]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=edges%20%28capturing%20their%20relationships%29,text%20is%20transformed%20into%20a">[9]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=which%20can%20mislead%20the%20LLM,in%20truncated%20or%20incomplete%20context">[10]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=LightRAG%20,scale%20GraphRAG">[50]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=Limitations%3A">[51]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=,indexing%20or%20partial%20rebuilds">[52]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=%2A%20Lean%20Graph,the%20system%20avoids%20information%20overload">[53]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=and%20relationships%2C%20generating%20a%20%E2%80%9Clightweight%E2%80%9D,As">[54]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=%2A%20Dual,scale%20graph%20reconstruction">[55]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=overload.%20,this%20lean%20indexing%20approach%20works">[56]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=,suited%20for%20rapidly%20changing%20environments">[57]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=Limitations%3A">[58]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=PathRAG%20distinguishes%20itself%20with%20a,a%20knowledge%20graph%2C%20rather%20than">[59]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=PathRAG%20begins%20by%20isolating%20the,Based%20Path%20Pruning">[60]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=By%20filtering%20out%20less%20useful,of%20token%20bloat%2C%20enabling%20the">[61]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=match%20at%20L223%20By%20filtering,of%20token%20bloat%2C%20enabling%20the">[62]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=match%20at%20L196%20GAMMA%2FPathRAG%2C%20this,minimizing%20redundancy%20and%20token%20waste">[63]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=LightRAG%2C%20and%20PathRAG%20marks%20a,the%20field%20of%20knowledge%20retrieval">[64]</a> <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9#:~:text=PathRAG%20is%20the%20brainchild%20of,work%20has%20significantly%20influenced%20the">[65]</a> Revolutionizing RAG with Knowledge Graphs: The Future of Contextual AI | by Robert Dennyson | Medium <a href="https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9">https://medium.com/@robertdennyson/revolutionizing-rag-with-knowledge-graphs-the-future-of-contextual-ai-b3addf5d9cc9</a></li><li data-list="ordered"><a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Rather%20than%20storing%20data%20in,possess%2C%20like%20size%20or%20color">[6]</a> <a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Sending%20a%20query%20to%20a,data%20will%20be%20retrieved%20once">[20]</a> <a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=built%20to%20extract%20information%20from,tool%20REBEL%20is%20another%20option">[66]</a> <a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Diffbot%2C%20while%20the%20knowledge%20extraction,tool%20REBEL%20is%20another%20option">[67]</a> <a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Storing%20your%20knowledge%20graph%20data,with%20new%20data%20over%20time">[68]</a> <a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Combining%20knowledge%20graphs%20with%20RAG,semantic%20understanding%20in%20your%20requests">[79]</a> <a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html#:~:text=Using%20a%20knowledge%20graph%20with,RAG">[80]</a> Overcoming AI hallucinations with RAG and knowledge graphs | InfoWorld <a href="https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html">https://www.infoworld.com/article/3511437/overcoming-ai-hallucinations-with-rag-and-knowledge-graphs.html</a></li><li data-list="ordered"><a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=By%20using%20the%20LLM,context%20window%20with%20higher%20relevance">[11]</a> <a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=,window%20when%20answering%20a%20question">[18]</a> <a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=Image%3A%20Figure%203%3A%20LLM,4%20Turbo">[19]</a> <a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=In%20addition%20to%20relative%20comparisons%2C,as%20accuracy%20and%20context%20relevance">[31]</a> <a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=In%20comparison%2C%20the%20GraphRAG%20approach,the%20exact%20content%20the%20LLM">[32]</a> <a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=commissariats%2C%20ATMs%E2%80%99">[33]</a> <a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=match%20at%20L334%20However%2C%20with,summarized.%C2%A0The%20LLM%20uses%20these">[69]</a> <a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=match%20at%20L395%20Observing%20the,by%20the%20LLM%20for%20each">[70]</a> <a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/#:~:text=match%20at%20L179%20GraphRAG%20uses,performing%20discovery%20on%20private%20datasets">[78]</a> GraphRAG: Unlocking LLM discovery on narrative private data - Microsoft Research <a href="https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/">https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/</a> </li><li data-list="ordered"><a href="https://aclanthology.org/2025.acl-srw.53.pdf#:~:text=publications%20were%20chosen%20for%20in,outline%20directions%20for%20future%20work">[12]</a> <a href="https://aclanthology.org/2025.acl-srw.53.pdf#:~:text=traversed%2C%20and%20how%20the%20context,outline%20directions%20for%20future%20work">[76]</a> <a href="https://aclanthology.org/2025.acl-srw.53.pdf#:~:text=of%20knowledge%20graphs%20,enhanced%20LLMs">[77]</a> aclanthology.org <a href="https://aclanthology.org/2025.acl-srw.53.pdf">https://aclanthology.org/2025.acl-srw.53.pdf</a></li></ol></div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Контекст‑карты — это истории в картинках</title>
			<link>https://learning.ontonet.ru/tpost/4xstgpct51-kontekstkarti-eto-istorii-v-kartinkah</link>
			<amplink>https://learning.ontonet.ru/tpost/4xstgpct51-kontekstkarti-eto-istorii-v-kartinkah?amp=true</amplink>
			<pubDate>Sat, 04 Oct 2025 18:21:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>Knowledge Graphs</category>
			<category>Практика</category>
			<turbo:content>
<![CDATA[<header><h1>Контекст‑карты — это истории в картинках</h1></header><h3  class="t-redactor__h3">Зачем это нужно</h3><div class="t-redactor__text"><ul><li data-list="bullet">Быстро объяснить ситуацию без длинных ТЗ.</li><li data-list="bullet">Согласовать границы системы: что внутри, что снаружи.</li><li data-list="bullet">Связать язык бизнеса (сюжеты) с языком архитектуры (компоненты, интерфейсы).</li></ul></div><h3  class="t-redactor__h3">Из чего состоит контекст‑карта</h3><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Сцена</strong> (setting): место/рамки ситуации</li><li data-list="ordered"><strong>Акторы</strong>: роли/системы, у которых есть мотив</li><li data-list="ordered"><strong>Цель</strong>: измеримый исход (Definition of Done)</li><li data-list="ordered"><strong>Взаимодействия</strong>: события, команды, данные</li><li data-list="ordered"><strong>Ограничения</strong>: правила, ресурсы, риски</li></ol></div><div class="t-redactor__text">Одно предложение‑ядро:</div><div class="t-redactor__text"> <strong>Когда [Актор] в [Сцене] хочет [Цель], он взаимодействует с [Актор/Система] через [Интерфейс/Событие], соблюдая [Ограничение].</strong></div><h3  class="t-redactor__h3">Как превратить историю в диаграмму (быстрый рецепт)</h3><div class="t-redactor__text"><ul><li data-list="bullet">Подчеркните в тексте <strong>существительные</strong> → узлы (акторы/системы/контексты).</li><li data-list="bullet">Подчеркните <strong>глаголы</strong> и <strong>существительные‑артефакты</strong> → связи и потоки (команда/событие/документ/данные).</li><li data-list="bullet">Вынесите <strong>цель</strong> на уровень бейджа/аннотации узла (так видна метрика успеха).</li></ul></div><h3  class="t-redactor__h3">Мини‑шаблон для Онто (можно прямо в OntoNet)</h3><div class="t-redactor__text"><strong>Шаблоны</strong></div><div class="t-redactor__text"><ul><li data-list="bullet">[CTX] Контекст: цель, метрика, границы</li><li data-list="bullet">[ROLE] Актор: тип (пользователь/система/внешний), мотивация</li><li data-list="bullet">[EVT] Взаимодействие: вид (команда|событие|запрос), артефакт/данные, SLA</li><li data-list="bullet">[RULE] Ограничение: правило, политика, ресурс</li></ul></div><div class="t-redactor__text"><strong>Связи</strong></div><div class="t-redactor__text"><ul><li data-list="bullet">Актор —исполняет→ Контекст</li><li data-list="bullet">Контекст —обменивается→ Взаимодействие</li><li data-list="bullet">Взаимодействие —подчиняется→ Ограничение</li><li data-list="bullet">Контекст —достигает→ Цель(метрика)</li></ul></div><h3  class="t-redactor__h3">Пример (одна строка → одна картинка)</h3><div class="t-redactor__text">«Когда <strong>Менеджер закупок</strong> в <strong>Контексте: пополнение склада</strong> хочет <strong>снизить дефицит до &lt;2%</strong>, он <strong>создаёт заказ</strong> в <strong>ERP</strong>, ERP <strong>уведомляет</strong> <strong>Поставщика</strong> через <strong>EDI</strong>, соблюдая <strong>лимит бюджета и SLA поставки 48ч</strong>».</div><div class="t-redactor__text">На диаграмме это даст: роли (Менеджер, ERP, Поставщик), контекст (Пополнение склада), потоки (Заказ, Уведомление), цель (дефицит &lt;2%), ограничения (бюджет, SLA).</div><img src="https://static.tildacdn.com/tild6363-6665-4234-b061-623636316163/photo.png"><h3  class="t-redactor__h3">Связка с архитектурой (C4/компоненты)</h3><div class="t-redactor__text"><ul><li data-list="bullet">Каждый <strong>Контекст</strong> → уровень System/Container с чёткими внешними интерфейсами.</li><li data-list="bullet"><strong>Взаимодействия</strong> → интерфейсы/контракты (API/события).</li><li data-list="bullet"><strong>Ограничения</strong> → нефункциональные требования (SLA, бюджет, политика данных).</li><li data-list="bullet"><strong>Цели/метрики</strong> → бейджи качества на узлах (health‑индикаторы).</li></ul></div><h3  class="t-redactor__h3">Практика за 15 минут</h3><div class="t-redactor__text"><ol><li data-list="ordered">Напишите 3–5 историй по шаблону (одна цель — один контекст).</li><li data-list="ordered">Выделите акторов/потоки → перенесите в контекст‑карту.</li><li data-list="ordered">Добавьте цель и ограничения как бейджи.</li><li data-list="ordered">Привяжите интерфейсы к реальным системам (для C4).</li></ol></div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Живое знание как процессный движок для импорта данных Часть 1 — «Предыстория и замысел»</title>
			<link>https://learning.ontonet.ru/tpost/s16pbtd2r1-zhivoe-znanie-kak-protsessnii-dvizhok-dl</link>
			<amplink>https://learning.ontonet.ru/tpost/s16pbtd2r1-zhivoe-znanie-kak-protsessnii-dvizhok-dl?amp=true</amplink>
			<pubDate>Sat, 08 Nov 2025 17:13:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>Практика</category>
			<category>Knowledge Graphs</category>
			<enclosure url="https://static.tildacdn.com/tild3562-3835-4135-b430-353937646365/Snipaste_2025-11-08_.png" type="image/png"/>
			<description>Наш кейс на ЛЦТ Фест 2025 (https://lct-fest2025.ru/): задача «Интеллектуальный цифровой инженер данных».</description>
			<turbo:content>
<![CDATA[<header><h1>Живое знание как процессный движок для импорта данных Часть 1 — «Предыстория и замысел»</h1></header><figure><img src="https://static.tildacdn.com/tild3562-3835-4135-b430-353937646365/Snipaste_2025-11-08_.png"/></figure><h2  class="t-redactor__h2">Часть 1 — «Предыстория и замысел».</h2><h2  class="t-redactor__h2">Предыстория и замысел</h2><div class="t-redactor__text">Моя позиция проста: ИТ должно делать процессы дешевле, надёжнее и понятнее — к этому я пришёл за почти 30 лет практики в разных ролях разработки ПО. Не наоборот. Когда в Онто мы начали системно собирать прикладные кейсы и практиковать «живое знание» — не статичный документ, а модель, которая помогает действовать здесь и сейчас — стало ясно, что следующий логичный шаг — показать это на реальной задаче импорта данных. Не очередной одноразовый MVP, а управляемый процесс, который выдержит разговор с архитекторами и поддержкой.</div><img src="https://static.tildacdn.com/tild3039-6337-4563-a331-363534323764/image.png"><div class="t-redactor__text">Письмо с приглашением на ЛЦТ я увидел <strong>4 августа</strong>, заявку подал <strong>5 сентября</strong>, а <strong>8 сентября</strong> нас включили в буткемп. <strong>22 сентября</strong> получил техническую задачу, <strong>29 сентября</strong> сел за работу, <strong>2 октября</strong> сдал решение. <strong>15 октября</strong> организаторы опубликовали списки финалистов, <strong>20 октября</strong> состоялась защита и питч. Этот ритм задал важный тон: вместо долгих «обмозгований» — короткий цикл гипотеза → проверка → результат.</div><div class="t-redactor__text">Зачем вообще понадобился «ассистент цифрового дата-инженера»? Потому что ручные скрипты и разнородные пайплайны быстро превращаются в дорогой и хрупкий зоопарк. Каждая новая загрузка — это чуть-чуть другая «маленькая уникальная снежинка», а в сумме — рост TCO и операционных рисков. Нам нужна единая управляемая процедура импорта: понятные шаги, повторяемые решения, воспроизводимые артефакты. И главное — предсказуемость: маршрут файла выбирают не догадки модели, а прозрачные алгоритмы и правила.</div><div class="t-redactor__text">Это важная позиция. «Чистая» нейросеть — соблазнительный ярлык, но в проде цена ошибки высока: неверная классификация датасета тянет за собой неправильную схему БД, поломанные загрузки, прямые потери. Поэтому в нашем подходе LLM — помощник и объяснитель, а не арбитр. Решение принимает детерминированная логика: хэши заголовка, устойчивые к перестановкам хэши, простые эвристики по заголовкам и PII-признакам, пороги уверенности. Это то, что можно ревьюить, версионировать и защищать на продкомитете.</div><div class="t-redactor__text">Где здесь Онто? Онто становится «мозгом» процесса: мы сохраняем <strong>сигнатуры</strong> датасетов (нормализованный хедер, хэши, число колонок, базовые типы) и сопоставляем их с <strong>объектами класса датасета</strong>. Как только класс найден (или создан как черновик), у нас появляется устойчивый маршрут: какой шаблон пайплайна применить, куда сложить сырьё, какие правила использовать при загрузке. Это и есть «живое знание»: модель не описывает мир — она помогает действовать.</div><div class="t-redactor__text">Остальная архитектура — исполнительный контур, минимальный и понятный. <strong>MCP</strong> выступает оркестратором шагов и «переводчиком» между моделью в Онто и инфраструктурой. <strong>MinIO</strong> — сырьевой слой (presigned-загрузка без проксирования через сервер). <strong>Airflow</strong> — один универсальный DAG для профилирования, генерации DDL и безопасной загрузки. <strong>Postgres</strong> — целевая база, где появляется таблица, пригодная для работы. Вместо множества разношёрстных скриптов — один проход, одна точка правды, один набор артефактов.</div><img src="https://static.tildacdn.com/tild3738-3363-4265-a266-663235396336/image.png"><div class="t-redactor__text">Ключевая гипотеза, которую мы подтвердили на практике: <strong>если сохранить сигнатуру в Онто, нужный пайплайн всегда находится и воспроизводится</strong>. Это и дешевле, и честнее, чем конструировать «мелкие MVP под каждый случай»: модель живёт дольше, чем конкретная реализация, и со временем только усиливается.</div><div class="t-redactor__text">Команда была компактной, но собранной. Я взял на себя архитектуру, ТЗ, контроль разработки и DevOps и демо. <strong>Алёна </strong>собрала презентацию, <strong>Кристина </strong>вычитывала и следила за качеством. В роли «ускорителей» — ассистенты: <strong>ChatGPT-5</strong> как бизнес- и системный аналитик, <strong>Codex-5</strong> как бэкенд- и DevOps-разработчик и автор DAG, <strong>Qorder</strong> как тестировщик. Итог — «человек + инструменты» движутся быстрее и аккуратнее, если правило простое: алгоритмы принимают решения, LLM объясняет.</div><img src="https://static.tildacdn.com/tild3962-3339-4135-b362-373266366161/image.png"><div class="t-redactor__text">В <a href="https://ontonet.ru/learning/tpost/0nzeyvam11-zhivoe-znanie-kak-protsessnii-dvizhok-dl">следующей части</a> — практический <strong>how-to</strong>: один проход от пробы до Postgres, набор инструментов, параметры запуска и минимальный DAG, с которым легко жить в проде. А в финале — выводы: почему такой процесс проходит у архитекторов и поддержки, и чем «разработка на данных в Онто» выигрывает у привычной гонки за одноразовыми MVP.</div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Живое знание как процессный движок для импорта данных Часть 2. How-to</title>
			<link>https://learning.ontonet.ru/tpost/0nzeyvam11-zhivoe-znanie-kak-protsessnii-dvizhok-dl</link>
			<amplink>https://learning.ontonet.ru/tpost/0nzeyvam11-zhivoe-znanie-kak-protsessnii-dvizhok-dl?amp=true</amplink>
			<pubDate>Sun, 09 Nov 2025 00:45:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<enclosure url="https://static.tildacdn.com/tild3562-3835-4135-b430-353937646365/Snipaste_2025-11-08_.png" type="image/png"/>
			<description>Наш кейс на ЛЦТ Фест 2025 (https://lct-fest2025.ru/): задача «Интеллектуальный цифровой инженер данных».</description>
			<turbo:content>
<![CDATA[<header><h1>Живое знание как процессный движок для импорта данных Часть 2. How-to</h1></header><figure><img src="https://static.tildacdn.com/tild3562-3835-4135-b430-353937646365/Snipaste_2025-11-08_.png"/></figure><h2  class="t-redactor__h2">Часть 2. How-to: один проход от пробы до Postgres</h2><div class="t-redactor__text">Ниже — практический маршрут, который мы реально прогнали на демо. Он опирается на Онто как «мозг» процесса и на минимальный исполнительный контур (MCP → MinIO → Airflow → Postgres). Цель — предсказуемый импорт без «магии» нейросети и без лишнего трафика.</div><h3  class="t-redactor__h3">Архитектурная рамка</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Онто</strong> — хранит знания: объекты <em>DatasetSignature</em>, <em>DatasetClass</em>, <em>PipelineTemplate</em>, <em>RecognitionResult</em> и правила сопоставления.</li><li data-list="bullet"><strong>MCP</strong> — оркестратор шагов и API-слой (инструменты: preflight_plan, preflight_submit, upload_url, pipeline_import_pg).</li><li data-list="bullet"><strong>MinIO</strong> — S3-совместимое «сырое» хранилище (presigned PUT/GET).</li><li data-list="bullet"><strong>Airflow</strong> — один универсальный DAG csv_ingest_pg (profile → DDL → COPY → отчёт).</li><li data-list="bullet"><strong>Postgres</strong> — целевая БД.</li></ul></div><img src="https://static.tildacdn.com/tild3865-3362-4261-b731-393364636432/image.png"><h2  class="t-redactor__h2">MCP — оркестратор шагов и API-слой</h2><div class="t-redactor__text"><strong>Роль MCP.</strong> Координирует четыре шага процесса между Онто (модель знаний), MinIO (сырьё), Airflow (исполнение) и Postgres (целевая БД). Принципы: storage-first, детерминизм вместо «магии», без проксирования тяжёлых данных через сервер.</div><div class="t-redactor__text">Репозиторий на <a href="https://github.com/OntoNet/mcpmsk/" target="_blank" rel="noreferrer noopener">гитхаб</a></div><h3  class="t-redactor__h3">Поток из четырёх инструментов</h3><div class="t-redactor__text"><ol><li data-list="ordered"><strong>preflight_plan — подготовка пробы (локально)</strong></li><li data-list="ordered"> MCP возвращает план для клиента: одну команду, которая локально считает «сигнатуру» файла (заголовок, хэши, базовые типы), и затем отправку этой сигнатуры обратно в MCP.</li><li data-list="ordered"> <em>Смысл:</em> ничего не гоняем по сети и не грузим нейросеть ради очевидного.</li><li data-list="ordered"><strong>preflight_submit — анализ и решение в Онто</strong></li><li data-list="ordered"> MCP сопоставляет сигнатуру с объектами в Онто: если профиль (DatasetClass) найден — фиксирует выбор; если нет — создаёт аккуратный черновик. На этом же шаге <strong>жёстко выбирается хранилище</strong> (StorageConfig) и рассчитывается s3Key для загрузки.</li><li data-list="ordered"> <em>Смысл:</em> маршрут определён до любых перемещений данных; решения — по алгоритмам, LLM лишь объясняет.</li><li data-list="ordered"><strong>upload_url — загрузка в MinIO по presigned URL</strong></li><li data-list="ordered"> По signatureId MCP выдаёт presigned PUT (single или multipart). Клиент <strong>заливает напрямую в MinIO</strong>, MCP байты не трогает.</li><li data-list="ordered"> <em>Смысл:</em> надёжная, дешёвая загрузка без посредников и лишнего трафика.</li><li data-list="ordered"><strong>pipeline_import_pg — запуск импорта в Postgres</strong></li><li data-list="ordered"> MCP создаёт/выбирает шаблон пайплайна (если нужно) и триггерит единый DAG csv_ingest_pg в Airflow с параметрами: источник (presigned GET или {endpoint,bucket,key}), sep/encoding, target {schema, table}. На выходе — runId, статус и артефакты (DDL/отчёт).</li><li data-list="ordered"> <em>Смысл:</em> один универсальный DAG, предсказуемый контракт, воспроизводимый результат.</li></ol></div><h3  class="t-redactor__h3">Как это выглядит end-to-end (сверху вниз)</h3><div class="t-redactor__text"><ul><li data-list="bullet">Клиент запускает preflight_plan → локальная сигнатура готова.</li><li data-list="bullet">preflight_submit фиксирует знание в Онто и <strong>сразу</strong> определяет StorageConfig + s3Key.</li><li data-list="bullet">upload_url выдаёт подписи → файл попадает в <strong>MinIO</strong></li><li data-list="bullet">pipeline_import_pg запускает DAG → Postgres получает таблицу, Онто — артефакты и статус.</li></ul></div><h3  class="t-redactor__h3">Почему это работает в корп-среде</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Предсказуемо.</strong> Решения принимают правила (хэши, устойчивые совпадения), не «интуиция» модели.</li><li data-list="bullet"><strong>Бережливо.</strong> Аналитика — в локальной пробе, сервер не возит гигабайты и не «жжёт» GPU.</li><li data-list="bullet"><strong>Трассируемо.</strong> В Онто остаются сигнатуры, выбранные профили и шаблоны: легко объяснить «почему так».</li><li data-list="bullet"><strong>Экономно.</strong> Один DAG и переиспользуемые классы/шаблоны вместо «зоопарка» MVP.</li></ul></div><h2  class="t-redactor__h2">Что хранит Онто — детально: что это и зачем</h2><img src="https://static.tildacdn.com/tild3536-3437-4366-b364-376535616536/image.png"><div class="t-redactor__text"><strong>DatasetSignature</strong></div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Что это:</strong> «паспорт» конкретного файла — нормализованный заголовок, число колонок, хэши (обычный и отсортированный), разделитель, кодировка, имя/размер.</li><li data-list="bullet"><strong>Зачем:</strong> служит основанием для сопоставления с профилями; фиксирует параметры, по которым будет выполняться загрузка; даёт воспроизводимость («вот именно этот файл мы импортировали вот так»).</li></ul></div><div class="t-redactor__text"><strong>DatasetClass</strong></div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Что это:</strong> «профиль» типа датасета (не мета-шаблон, а объект): хэши и отсортированный список колонок, ключевые слова домена, флаги PII, статус draft/active.</li><li data-list="bullet"><strong>Зачем:</strong> определяет маршрут импорта для всех файлов такого типа; позволяет автоматически выбирать шаблон пайплайна и не изобретать логику заново при каждом новом источнике.</li></ul></div><div class="t-redactor__text"><strong>PipelineTemplate</strong></div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Что это:</strong> «маршрут» обработки для профиля: дефолты парсинга (sep/encoding/loadMode), целевой таргет (storage/schema/table/partitionBy), версия/статус.</li><li data-list="bullet"><strong>Зачем:</strong> делает импорт параметризуемым и повторяемым: один универсальный DAG + набор шаблонов, вместо «зоопарка» одноразовых скриптов; снижает стоимость поддержки.</li></ul></div><div class="t-redactor__text"><strong>RecognitionResult</strong></div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Что это:</strong> протокол решения сопоставления: чем именно совпало (matchedBy), с какой уверенностью (score), когда принято, краткие заметки.</li><li data-list="bullet"><strong>Зачем:</strong> обеспечивает объяснимость и аудит — можно ответить «почему выбран именно этот профиль/маршрут» и воспроизвести решение при повторных запусках.</li></ul></div><div class="t-redactor__text">Выше приведены шаблоны для создания объектов в Онто.</div><h2  class="t-redactor__h2">Что такое шаблон в Онто</h2><div class="t-redactor__text">Шаблон — это не «одна конкретная запись», а <strong>тип объекта с фиксированным смыслом и набором полей</strong>. Он:</div><div class="t-redactor__text"><ul><li data-list="bullet">задаёт <strong>структуру</strong> (какие поля есть и как они называются);</li><li data-list="bullet">делает данные <strong>однородными и сравнимыми</strong> между кейсами;</li><li data-list="bullet">даёт точку входа для <strong>автоматизации</strong> (MCP знает, что создавать и чем заполнять);</li><li data-list="bullet">обеспечивает <strong>проверяемость и воспроизводимость</strong> (одни и те же правила → одни и те же решения).</li></ul></div><h3  class="t-redactor__h3">Почему это важно для MCP-driven процесса</h3><div class="t-redactor__text"><ul><li data-list="bullet">MCP может <strong>детерминированно</strong> создавать/заполнять объекты по шаблонам (никакой импровизации в полях и названиях).</li><li data-list="bullet">Вся логика «почему и что делать дальше» считывается из <strong>стандартных</strong> сущностей — решение предсказуемо и защищаемо перед архитекторами.</li><li data-list="bullet">Шаблоны снижают стоимость поддержки: один раз договорились о форме — дальше масштабируем без переписывания «под каждый случай».</li></ul></div><h2  class="t-redactor__h2">Проба: считаем сигнатуру локально (детально)</h2><div class="t-redactor__text">Наша цель — получить <strong>минимальный, но достаточный портрет файла</strong> без гонки трафика и без «магии». Всё делаем локально, быстрыми детерминированными правилами.</div><img src="https://static.tildacdn.com/tild6430-3234-4763-b236-663033386233/image.png"><h3  class="t-redactor__h3">1) Что считаем (поля сигнатуры)</h3><div class="t-redactor__text"><ul><li data-list="bullet">encoding — кодировка чтения.</li><li data-list="bullet">sep — разделитель (,, ;, \t, реже |).</li><li data-list="bullet">hasHeader — есть ли заголовок.</li><li data-list="bullet">headers[] — нормализованные имена колонок.</li><li data-list="bullet">numCols — количество колонок.</li><li data-list="bullet">headerHash — sha256('h1;h2;…;hn').</li><li data-list="bullet">headerSortedHash — sha256('sorted(h1…hn)').</li><li data-list="bullet">headersSorted — строка с отсортированными именами через ;.</li><li data-list="bullet">dtypeGuess (по колонкам) — bool|int|float|datetime|text.</li><li data-list="bullet">piiFlags — phone|fio|inn|birthday|uuid (true/false).</li><li data-list="bullet">(опц.) rowsScanned — сколько строк просмотрели (для статистики).</li></ul></div><h3  class="t-redactor__h3">2) Нормализация заголовков (строго в таком порядке)</h3><div class="t-redactor__text"><ol><li data-list="ordered">lower()</li><li data-list="ordered">strip() (обрезать пробелы по краям)</li><li data-list="ordered">заменить [' ', '-'] → _</li><li data-list="ordered">удалить все, кроме [a-z0-9_а-яё]</li><li data-list="ordered">схлопнуть повторные _ → один _</li><li data-list="ordered">убрать _ в начале/конце</li></ol></div><div class="t-redactor__text">Пример: " Start Date-Time " → start_date_time</div><h3  class="t-redactor__h3">3) Кодировка и разделитель</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Encoding:</strong> сначала пробуем utf-8 (срез первых 256–512 КБ). Если ошибка декодирования — пробуем cp1251. (Если хочется тонкости — локально подключаем детектор, но дефолт utf-8 чаще всего верен.)</li><li data-list="bullet"><strong>Sep:</strong> считаем частоты , ; \t | в первых ~256 КБ, выбираем максимум (если \t в топе — ставим табуляцию). Для спорных случаев допускаем ручную подсказку --sep.</li></ul></div><h3  class="t-redactor__h3">4) Объём пробы</h3><div class="t-redactor__text"><ul><li data-list="bullet">Читаем <strong>только заголовок + первые N строк</strong> (обычно N=1000).</li><li data-list="bullet">Память не распухает, чтение идёт потоково.</li><li data-list="bullet">Если строки разной длины — считаем «битые» и игнорируем их при типизации.</li></ul></div><h3  class="t-redactor__h3">5) Типизация колонок (простые эвристики)</h3><div class="t-redactor__text">Для каждого значения v (обрезанного):</div><div class="t-redactor__text"><ul><li data-list="bullet">bool: true|false|0|1 (без регистра)</li><li data-list="bullet">int: ^-?\d+$</li><li data-list="bullet">float: ^-?\d+([.,]\d+)?$ (запятую не превращаем в точку — только детект)</li><li data-list="bullet">datetime: ISO-подобные YYYY-MM-DD, YYYY-MM-DD[ T]HH:MM(:SS)?, YYYY-MM-DDTHH:MM:SS±ZZ:ZZ</li><li data-list="bullet">иначе text</li></ul></div><div class="t-redactor__text">Выбор типа — <strong>мода</strong> по сэмплу (чаще всего встречающийся). При близких долях — text.</div><h3  class="t-redactor__h3">6) PII-эвристики (по сэмплу)</h3><div class="t-redactor__text"><ul><li data-list="bullet">phone: ^(7|8)?\d{10}$</li><li data-list="bullet">inn: ^\d{10}$</li><li data-list="bullet">uuid: [0-9a-f]{8}-[0-9a-f]{4}-</li><li data-list="bullet">birthday: ^\d{4}-\d{2}-\d{2}$ или ^\d{2}\.\d{2}\.\d{4}$</li><li data-list="bullet">fio (капсом, 2–3 слова кириллицей): ^[А-ЯЁ]+(?: [А-ЯЁ]+){1,2}$</li></ul></div><div class="t-redactor__text">Флаги поднимаем, если найдено <strong>хотя бы одно</strong> соответствие в колонке/сэмпле (или несколько — по желанию).</div><h3  class="t-redactor__h3">7) Контроль качества пробы (самопроверки)</h3><div class="t-redactor__text"><ul><li data-list="bullet">numCols заголовка и строк совпадают ≥ 95% в сэмпле — иначе предупреждение «пляшущие колонки».</li><li data-list="bullet">Дубли заголовков → автоматически переписываем name__2, name__3 и фиксируем в заметках.</li><li data-list="bullet">Слишком много пустых — помечаем колонку как nullableHint=true (если ведём такую метку).</li></ul></div><h3  class="t-redactor__h3">8) Формат выходного JSON (payload сигнатуры)</h3><div class="t-redactor__text"><div class="ql-code-block" data-language="plain">{</div><div class="ql-code-block" data-language="plain">  "fileName": "tickets.csv",</div><div class="ql-code-block" data-language="plain">  "fileSize": 348243289,</div><div class="ql-code-block" data-language="plain">  "signature": {</div><div class="ql-code-block" data-language="plain">    "encoding": "utf-8",</div><div class="ql-code-block" data-language="plain">    "sep": ";",</div><div class="ql-code-block" data-language="plain">    "hasHeader": true,</div><div class="ql-code-block" data-language="plain">    "numCols": 27,</div><div class="ql-code-block" data-language="plain">    "headers": ["created","order_status","ticket_status","..."],</div><div class="ql-code-block" data-language="plain">    "headerHash": "sha256:…",</div><div class="ql-code-block" data-language="plain">    "headerSortedHash": "sha256:…",</div><div class="ql-code-block" data-language="plain">    "headersSorted": "birthday_date;client_name;…;visitor_category",</div><div class="ql-code-block" data-language="plain">    "stats": {</div><div class="ql-code-block" data-language="plain">      "rowsScanned": 1000,</div><div class="ql-code-block" data-language="plain">      "dtypeGuess": { "created":"datetime","ticket_price":"float","is_active":"bool","..." },</div><div class="ql-code-block" data-language="plain">      "piiFlags": { "phone": true, "fio": true, "inn": true, "birthday": true, "uuid": true }</div><div class="ql-code-block" data-language="plain">    }</div><div class="ql-code-block" data-language="plain">  }</div><div class="ql-code-block" data-language="plain">}</div></div><h3  class="t-redactor__h3">9) CLI-процедура (быстрый сценарий)</h3><div class="t-redactor__text"><ol><li data-list="ordered">preflight_plan возвращает одну команду shell → запускаем → получаем payload.json.</li><li data-list="ordered">Сохраняем рядом с файлом (или в temp).</li><li data-list="ordered">Передаём в preflight_submit без изменений.</li></ol></div><h3  class="t-redactor__h3">10) Граница ответственности (важно)</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>На пробе мы не двигаем байты в хранилище и не включаем LLM.</strong></li><li data-list="bullet">Все решения — детерминированные, воспроизводимые и дешёвые.</li><li data-list="bullet">Если sep/encoding спорные — на этапе анализа возвращаем <em>рекомендации</em> и, при необходимости, запрашиваем ручную подсказку.</li></ul></div><h3  class="t-redactor__h3">11) Краевые случаи и что делать</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>BOM/странный нулевой байт</strong> — отрезаем BOM, чистим управляющие.</li><li data-list="bullet"><strong>Супердлинные поля</strong> — режем предпросмотр, но не весь файл; считаем только заголовок и первые N строк.</li><li data-list="bullet"><strong>Много «битых» строк</strong> — фиксируем процент и предупреждаем; маршрут импорта не стартуем, пока не будет явной валидации.</li><li data-list="bullet"><strong>Нет заголовка</strong> — hasHeader=false: на анализе вернём «нужно сопоставить имена колонок» (mapping), класс не создаём автоматически.</li></ul></div><div class="t-redactor__text">Эта проба даёт <strong>стабильную сигнатуру</strong>, по которой анализ в Онто либо находит готовый класс и маршрут, либо создаёт аккуратный черновик. Дальше — storage-first, presigned PUT и один универсальный DAG.</div><h3  class="t-redactor__h3">Сопоставление в Онто: класс найден/создан</h3><div class="t-redactor__text"><strong>Алгоритм.</strong></div><img src="https://static.tildacdn.com/tild3534-3062-4466-b564-623162336365/image.png"><div class="t-redactor__text"><ol><li data-list="ordered">Поиск по headerHash → если пусто, по headerSortedHash.</li><li data-list="ordered">Если всё ещё пусто — кандидаты по numCols и Jaccard по множеству заголовков.</li><li data-list="ordered">Порог уверенности (score) зафиксирован; если не дотягивает — создаём черновой объект <em>DatasetClass(draft)</em>.</li></ol></div><div class="t-redactor__text"><strong>Что записываем.</strong></div><div class="t-redactor__text"><ul><li data-list="bullet"><em>DatasetSignature</em> (факт пробы).</li><li data-list="bullet"><em>DatasetClass</em> (найденный или черновой).</li><li data-list="bullet"><em>PipelineTemplate</em> (если нет — создаём draft с дефолтами).</li><li data-list="bullet"><em>RecognitionResult</em> (matchedBy, score, timestamp).</li></ul></div><div class="t-redactor__text"><strong>Важно.</strong> До любой загрузки мы <strong>определяем хранилище</strong>. MCP выбирает объект <em>StorageConfig</em> (или default) и рассчитывает s3Key по шаблону (raw/{dataset}/{yyyy}/{mm}/source-{uuid}.csv). Это исключает гонки и перезаписи.</div><div class="t-redactor__text">Вот как действуем, если в Онто подходящий объект [DATA] DatasetClass <strong>не найден</strong>.</div><h2  class="t-redactor__h2">Алгоритм</h2><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Нормализация входа</strong></li></ol></div><div class="t-redactor__text"><ul><li data-list="bullet">headers → lower/trim, пробелы и - → _, убрать все кроме [a-z0-9_а-яё], схлопнуть _.</li><li data-list="bullet">Считаем headerHash, headerSortedHash, headersSorted=';'.join(sorted(headers)), numCols.</li></ul></div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Последняя попытка “похожести”</strong></li></ol></div><div class="t-redactor__text"><ul><li data-list="bullet">Берём кандидатов по numCols.</li><li data-list="bullet">Для каждого считаем Jaccard по множествам имён колонок.</li><li data-list="bullet">Если score = 0.4*Jaccard ≥ 0.7 — считаем найденным (иначе — создаём новый).</li></ul></div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Формирование черновика класса</strong></li></ol></div><div class="t-redactor__text"><ul><li data-list="bullet">Создаём <strong>DatasetClass(draft=true)</strong> с полями:</li><li data-list="bullet"> headerHash, headerSortedHash, headersSorted, numCols.</li><li data-list="bullet">Генерируем <strong>keywords</strong> из заголовков (токены: ticket,event,museum,…) и сохраняем строкой.</li><li data-list="bullet">Считаем профиль ПДн (<strong>PII</strong>): piiPhone, piiFio, piiInn, piiBirthday по простым регэкспам/эвристикам и записываем флаги.</li><li data-list="bullet">priority=0, comment='created from signature &lt;signatureId&gt;'.</li></ul></div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Колонки класса</strong></li></ol></div><div class="t-redactor__text"><ul><li data-list="bullet">На каждую колонку создаём ColumnSignature:</li><li data-list="bullet"> name (нормализованное), originalName (если хочется), position (0..n-1),</li><li data-list="bullet"> dtypeGuess (эвристика: bool/int/float/datetime/text), examples (до 3 значений).</li><li data-list="bullet">Это фиксирует «какой набор мы увидели» и пригодится для последующей точной подстройки.</li></ul></div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Шаблон пайплайна (draft)</strong></li></ol></div><div class="t-redactor__text"><ul><li data-list="bullet">Создаём PipelineTemplate(draft=true) с дефолтами:</li><li data-list="bullet"> defaults = {"sep": "&lt;из сигнатуры&gt;", "encoding": "&lt;…&gt;", "loadMode": "append", "createTable": true}</li><li data-list="bullet"> target = {"storage":"postgres","schema":"public","table":"&lt;предложить по домену, напр. tickets_fact&gt;"}</li><li data-list="bullet">(Если есть активный StorageConfig) рассчитываем s3Key по pathPatternRaw и сохраняем его в сигнатуру.</li></ul></div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Фиксация факта распознавания</strong></li></ol></div><div class="t-redactor__text"><ul><li data-list="bullet">Создаём DatasetSignature (если ещё не создана) и RecognitionResult с:</li><li data-list="bullet"> matchedBy="created_draft_class", score=&lt;ниже порога&gt;, timestamp=now.</li><li data-list="bullet">(Связи можно добавить позже, если в этом спринте выключены.)</li></ul></div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Идемпотентность (важно!)</strong></li></ol></div><div class="t-redactor__text"><ul><li data-list="bullet">Перед созданием <strong>повторно</strong> пробуем find по:</li><li data-list="bullet"> A) headerHash; B) (headerSortedHash, numCols, headersSorted) — защита от гонок/повторных запусков.</li><li data-list="bullet">Если за время операции кто-то уже создал класс с теми же ключами — используем его, наш черновик не плодим.</li></ul></div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Требование ревью</strong></li></ol></div><div class="t-redactor__text"><ul><li data-list="bullet">draft=true означает: класс не участвует в автопринятии решений без ручного подтверждения.</li><li data-list="bullet">В UI/Онто — тег/фильтр “нужен просмотр”; после ревью draft=false и (опц.) priority↑.</li></ul></div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Переиспользование</strong></li></ol></div><div class="t-redactor__text"><ul><li data-list="bullet">Следующий файл с тем же headerHash/headerSortedHash попадёт в этот класс без создания новых объектов.</li><li data-list="bullet">При незначительных расхождениях (добавилась колонка) можно:</li><li data-list="bullet"> а) обновить ColumnSignature + перевести класс из draft,</li><li data-list="bullet"> б) завести новый класс и поднять/понизить priority.</li></ul></div><h2  class="t-redactor__h2">Что получает инженер на выходе</h2><div class="t-redactor__text"><ul><li data-list="bullet">Новый <strong>класс-черновик</strong> с полным описанием полей и предложенным шаблоном пайплайна.</li><li data-list="bullet">Объективная метка «почему создали класс» и «насколько он близок» к найденным.</li><li data-list="bullet">Возможность одним кликом/скриптом: подтвердить, поправить столбцы, назначить целевую таблицу — и запустить импорт уже как «активный» класс.</li></ul></div><div class="t-redactor__text">Это держит процесс бережливым и управляемым: сначала фиксация знания в Онто, потом — воспроизводимый маршрут импорта.</div><h3  class="t-redactor__h3">Загрузка в MinIO: только presigned PUT</h3><img src="https://static.tildacdn.com/tild6362-6164-4362-b464-653735323633/image.png"><img src="https://static.tildacdn.com/tild3731-6132-4233-b036-626561343738/image.png"><img src="https://static.tildacdn.com/tild3463-3732-4430-b830-303430626633/image.png"><div class="t-redactor__text"><strong>Инструмент.</strong> upload_url по signatureId.</div><div class="t-redactor__text"><strong>Режимы.</strong></div><div class="t-redactor__text"><ul><li data-list="bullet"><em>single</em> — файл до 5 GiB; возвращаем один putUrl.</li><li data-list="bullet"><em>multipart</em> — крупные файлы; клиент грузит частями параллельно, затем CompleteMultipartUpload.</li></ul></div><div class="t-redactor__text"><strong>Правило.</strong> MCP никогда не проксирует содержимое — только выдаёт подписи. Если объект ещё не загружен, инструмент может вернуть putUrl без запуска DAG (режим ensureUploaded=true), чтобы не смешивать этапы.</div><h3  class="t-redactor__h3">Импорт: один DAG для всех</h3><div class="t-redactor__text"><strong>DAG csv_ingest_pg</strong> принимает либо presigned_get_url, либо трио {s3_endpoint, bucket, key} и работает по шагам:</div><img src="https://static.tildacdn.com/tild6132-6665-4133-b531-306165393836/image.png"><img src="https://static.tildacdn.com/tild6633-3762-4635-b132-346536323233/image.png"><div class="t-redactor__text"><ol><li data-list="ordered"><strong>download_csv</strong> — скачивает во временный файл (presigned GET или генерация presign внутри DAG).</li><li data-list="ordered"><strong>sample_profile</strong> — быстрая проверка: строки, заголовок, типы-эвристики.</li><li data-list="ordered"><strong>generate_ddl</strong> — формирует DDL под Postgres (idempotent).</li><li data-list="ordered"><strong>create_table</strong> — применяет DDL.</li><li data-list="ordered"><strong>load_to_pg</strong> — COPY … FROM STDIN (CSV, HEADER, DELIMITER).</li><li data-list="ordered"><strong>write_report</strong> — JSON-отчёт (профиль + DDL) — можно положить в reports/.</li></ol></div><div class="t-redactor__text"><strong>Контракты.</strong> В params передаём минимум: sep, encoding, target: {schema, table}, плюс ссылку на источник. Один DAG — меньше поддержки, понятный аудит.</div><img src="https://static.tildacdn.com/tild6536-3865-4661-a137-326661643137/image.png"><img src="https://static.tildacdn.com/tild6263-6464-4364-a538-353463653734/image.png"><h3  class="t-redactor__h3">Где здесь «живое знание»</h3><div class="t-redactor__text">Онто хранит не слайды, а рабочие сущности: сигнатуры, классы, шаблоны, результаты распознавания. Это позволяет:</div><div class="t-redactor__text"><ul><li data-list="bullet">воспроизводить маршрут для любого будущего файла того же типа;</li><li data-list="bullet">объяснять <strong>почему</strong> был выбран именно такой путь (hash, пороги, кандидаты);</li><li data-list="bullet">целостно связать инженера, пробы, LLM-подсказки и фактический импорт.</li></ul></div><h3  class="t-redactor__h3">Почему это дешевле MVP-гоночки</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Переиспользование.</strong> Один <em>DatasetClass</em> и один <em>PipelineTemplate</em> обслуживают множество файлов/источников.</li><li data-list="bullet"><strong>Один DAG.</strong> Универсальный, параметризуемый, с контрактом — вместо «зоопарка» одноразовых скриптов.</li><li data-list="bullet"><strong>Бережливость.</strong> Аналитика — в локальной пробе; сеть и LLM не расходуются «на всякий случай».</li><li data-list="bullet"><strong>Меньше рисков.</strong> Хранилище и путь рассчитываются <strong>до</strong> загрузки; политика no-overwrite.</li></ul></div><h3  class="t-redactor__h3">Чек-лист запуска</h3><div class="t-redactor__text"><ol><li data-list="ordered">Создать в Онто шаблоны и (при необходимости) объект <em>StorageConfig</em> (bucket=raw, pathPatternRaw=raw/{dataset}/{yyyy}/{mm}/source-{uuid}.csv).</li><li data-list="ordered">Запустить preflight_plan → получить payload.json.</li><li data-list="ordered">Вызвать preflight_submit → получить signatureId, выбранный класс/шаблон и рассчитанный s3Key.</li><li data-list="ordered">upload_url → загрузить файл по putUrl.</li><li data-list="ordered">pipeline_import_pg (или dag_trigger) → дождаться runId и success.</li><li data-list="ordered">Проверить таблицу в Postgres и отчёт (при желании — сложить в reports/).</li></ol></div><h3  class="t-redactor__h3">Типичные ошибки и как их не допускать</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Загрузка без выбора StorageConfig.</strong> Решение: storage-first.</li><li data-list="bullet"><strong>Дублирующиеся файлы.</strong> Включить политику no-overwrite, добавлять суффикс к s3Key при коллизии.</li><li data-list="bullet"><strong>Несогласованные sep/encoding.</strong> Передавать их из сигнатуры; не менять наугад в DAG.</li><li data-list="bullet"><strong>«LLM всё решит».</strong> В нашем процессе LLM — только пояснитель; маршрут задают правила.</li></ul></div><div class="t-redactor__text">В <a href="https://ontonet.ru/learning/tpost/okm5r1din1-zhivoe-znanie-kak-protsessnii-dvizhok-dl">финальной части</a> — <strong>выводы</strong>: почему такой подход проходит у архитекторов и эксплуатации, чем «разработка на данных в Онто» выигрывает у серии одноразовых MVP и как бережливость вычислений превращается в реальную экономию.</div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Живое знание как процессный движок для импорта данных Часть 3 — «Заключение и вывод»</title>
			<link>https://learning.ontonet.ru/tpost/okm5r1din1-zhivoe-znanie-kak-protsessnii-dvizhok-dl</link>
			<amplink>https://learning.ontonet.ru/tpost/okm5r1din1-zhivoe-znanie-kak-protsessnii-dvizhok-dl?amp=true</amplink>
			<pubDate>Sun, 09 Nov 2025 02:00:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>Практика</category>
			<category>Knowledge Graphs</category>
			<enclosure url="https://static.tildacdn.com/tild6230-3163-4561-b031-333163613864/Snipaste_2025-11-08_.png" type="image/png"/>
			<turbo:content>
<![CDATA[<header><h1>Живое знание как процессный движок для импорта данных Часть 3 — «Заключение и вывод»</h1></header><figure><img src="https://static.tildacdn.com/tild6230-3163-4561-b031-333163613864/Snipaste_2025-11-08_.png"/></figure><h2  class="t-redactor__h2">Часть 3. Финал: риски LLM-оркестрации в проде, польза LLM как ассистента, экономика и рост качества</h2><h3  class="t-redactor__h3">1) Почему «LLM-оркестратор» в проде — риск</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Непредсказуемость и дрейф промптов.</strong> Один и тот же запрос может давать разные ответы из-за температуры, контекста и скрытых апдейтов модели. Для конвейера импорта это означает <em>нестабильные маршруты</em> и «случайные» DDL/касты.</li><li data-list="bullet"><strong>Галлюцинации и уверенная неправда.</strong> LLM может «уверенно» придумать схему таблицы или правила сопоставления там, где данных недостаточно. В результате — поломка загрузки, накладные расходы на откаты и репроцессинг.</li><li data-list="bullet"><strong>Невоспроизводимость.</strong> Решение, принятое вчера, сегодня может не воспроизвестись (новая версия модели, иной порядок сообщений). Без детерминированной опоры это превращается в «экзотику инженера», а не в промышленный процесс.</li><li data-list="bullet"><strong>Комплаенс/ПДн.</strong> Автоматическая маршрутизация через LLM рискует случайно «протолкнуть» PII в неподходящее хранилище или без маскирования — с последствиями для безопасности и аудита.</li><li data-list="bullet"><strong>Экономика.</strong> На «вспомогательные» задачи (определение разделителя, типов, маршрута) тратятся токены и цикл времени. Это не добавляет ценности, но накапливает счёт и задержки.</li><li data-list="bullet"><strong>Операционные риски.</strong> Подменять инженера black-box-агентом — это рост MTTR и падение доверия эксплуатации: непонятно, <em>почему</em> принято решение и <em>как</em> его быстро повторить/исправить.</li></ul></div><div class="t-redactor__text"><strong>Вывод:</strong> в критическом пути должен работать <em>детерминизм</em> — алгоритмы, правила, хэши, пороги, проверяемые эвристики и чёткие контракты. LLM — рядом, но не вместо.</div><img src="https://static.tildacdn.com/tild6630-3166-4233-b136-306439313938/image.png"><h3  class="t-redactor__h3">2) Где LLM реально полезен (как ассистент)</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Документация и пояснения.</strong> Переводит «сухие» артефакты (сигнатура, выбор класса, DDL) в понятные краткие отчёты для инженера/архитектуры/менеджмента.</li><li data-list="bullet"><strong>Шаблонная разработка.</strong> Генерирует болванку DAG, DDL, конфигов, README; ускоряет рутину, где цена ошибки низкая, а ревью — простое.</li><li data-list="bullet"><strong>Диагностика и разбор инцидентов.</strong> По логам и артефактам объясняет, где «сломалось» сопоставление/загрузка, предлагает варианты фикса — но решение остаётся за инженером.</li><li data-list="bullet"><strong>Навигация по знаниям.</strong> Помогает искать похожие <em>DatasetClass</em>, сравнивать заголовки, находить дубликаты — как «умная лупа» поверх Онто.</li><li data-list="bullet"><strong>Контроль качества текста и UX.</strong> Причесывает сообщения об ошибках, делает инструкции яснее — снижает когнитивную нагрузку команды.</li></ul></div><div class="t-redactor__text"><strong>Золотое правило:</strong> <em>алгоритмы принимают решения, LLM объясняет и ускоряет</em>. Такой раздел ответственности и безопасен, и экономически оправдан.</div><h3  class="t-redactor__h3">3) Экономика: где мы выигрываем деньги и время</h3><div class="t-redactor__text"><strong>Состав TCO у «зоопарка» MVP</strong>: разрозненные скрипты, «одноразовые» пайплайны, много ручных перезапусков, разбор нестабильных решений LLM, рост нагрузки на инженеров поддержки.</div><div class="t-redactor__text"><strong>Состав TCO у управляемого процесса</strong>:</div><div class="t-redactor__text"><ul><li data-list="bullet"><em>Один универсальный DAG</em> (параметризуемый) вместо множества кастомных — меньше сопровождения.</li><li data-list="bullet"><em>Переиспользуемые объекты Онто</em> (DatasetClass/PipelineTemplate) — решение принимается один раз и живёт дальше; на новых источниках стоимость подключения падает.</li><li data-list="bullet"><em>Storage-first</em> и presigned — меньше сетевых «танцев» и откатов; сервер не проксирует гигабайты.</li><li data-list="bullet"><em>LLM только там, где ускоряет</em> — меньше «токенов на воздух».</li></ul></div><div class="t-redactor__text"><strong>Практический эффект:</strong> MVP за <strong>3 дня</strong> одним экспертом, без «жёсткой» связки на капризную маршрутизацию LLM. Дальше масштабирование — это создание новых <em>DatasetClass</em> и правка шаблонов, а не переписывание конвейера.</div><h3  class="t-redactor__h3">4) Качество: как растёт предсказуемость и доверие</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Воспроизводимость.</strong> Каждая «проба» оставляет <em>DatasetSignature</em>, каждая развилка — <em>RecognitionResult</em>. Любое решение объяснимо и может быть повторено <em>байт-в-байт</em>.</li><li data-list="bullet"><strong>Управляемый онбординг источников.</strong> Новый файл → либо попадает в существующий <em>DatasetClass</em>, либо рождает <em>draft</em>, который инженер подтверждает. Человеческий контроль остаётся там, где он обязателен.</li><li data-list="bullet"><strong>Снижение инцидентов.</strong> Порог/джаккард/хэши защищают от «ложноположительных» совпадений; <em>StorageConfig</em> выставляет понятные рамки (куда и что кладём).</li><li data-list="bullet"><strong>Быстрые ревью и обучение команды.</strong> Шаблоны дают общий язык; отчёты читаемы и одинаковы для всех.</li></ul></div><img src="https://static.tildacdn.com/tild3037-6430-4436-a139-353364343765/image.png"><h3  class="t-redactor__h3">5) Операционная модель: как «встроить» это в прод</h3><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Правила в устав:</strong> <em>storage-first</em>, <em>без проксирования байтов</em>, <em>LLM-assistant only</em>, <em>один DAG — много параметров</em>, <em>всё фиксируем в Онто</em>.</li><li data-list="bullet"><strong>Контракты и SLO.</strong> Контракт conf для DAG, SLO на шаги (проба, выбор, загрузка, импорт), понятные метрики (время полного прохода, % воспроизводимых маршрутов, доля auto-match vs draft).</li><li data-list="bullet"><strong>Процедуры ревью.</strong> Чётко: кто утверждает <em>DatasetClass</em>, кто правит <em>PipelineTemplate</em>, при каких условиях переводим из draft в active.</li><li data-list="bullet"><strong>Безопасность/ПДн.</strong> Маскирование в шаблоне, запрет загрузки без профиля PII, минимальные права на бакеты.</li><li data-list="bullet"><strong>Обратная связь в модель.</strong> Любой инцидент — обновление правил/шаблонов, чтобы повторно не наступать.</li></ul></div><h3  class="t-redactor__h3">6) Финальная позиция</h3><img src="https://static.tildacdn.com/tild3161-3163-4630-b465-636166626133/image.png"><div class="t-redactor__text">Мы сознательно выбрали алгоритмический путь и сделали LLM <em>ассистентом</em>, а не «дирижёром» производства. Это:</div><div class="t-redactor__text"><ul><li data-list="bullet">снимает ключевые риски прод-оркестрации,</li><li data-list="bullet">снижает стоимость владения,</li><li data-list="bullet">ускоряет работу команды,</li><li data-list="bullet">повышает качество и доверие архитектуры/поддержки.</li></ul></div><div class="t-redactor__text"><strong>Живое знание как процессный движок</strong> — это не лозунг. Это практика: Онто хранит факты и правила, MCP исполняет маршрут, MinIO/Airflow/Postgres делают своё дело. Так мы получаем предсказуемый, бережливый и воспроизводимый импорт — ровно тот, который проходит согласование и реально работает в большой организации.</div><h2  class="t-redactor__h2">Материалы</h2><div class="t-redactor__text"><ol><li data-list="ordered">Ссылка на презентацию <a href="https://docs.google.com/presentation/d/1XvosdqKlN1ugXyzgiJpmaJ3oAlRlbgFC/edit?usp=drive_link&amp;ouid=111692219285607393184&amp;rtpof=true&amp;sd=true" target="_blank" rel="noreferrer noopener">pptx</a></li><li data-list="ordered">Репозиторий на <a href="https://github.com/OntoNet/mcpmsk/" target="_blank" rel="noreferrer noopener">гитхаб</a></li></ol></div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Интеллект в графе: как структурированное знание становится капиталом</title>
			<link>https://learning.ontonet.ru/tpost/bx07y5d741-intellekt-v-grafe-kak-strukturirovannoe</link>
			<amplink>https://learning.ontonet.ru/tpost/bx07y5d741-intellekt-v-grafe-kak-strukturirovannoe?amp=true</amplink>
			<pubDate>Sun, 30 Nov 2025 15:39:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>Knowledge Graphs</category>
			<category>LLM</category>
			<category>AI</category>
			<description>OntoAI и новая роль онтологий в эпоху GenAI</description>
			<turbo:content>
<![CDATA[<header><h1>Интеллект в графе: как структурированное знание становится капиталом</h1></header><h2  class="t-redactor__h2">Предыстория и мотивация</h2><div class="t-redactor__text">В современном цифровом предприятии знания перестали быть статичными документами — они живут, развиваются и меняются вместе с системой.</div><div class="t-redactor__text"> Каждый сервис, процесс, интерфейс или поток данных является носителем смыслов, и все эти смыслы взаимосвязаны.</div><div class="t-redactor__text"> Чем сложнее организация, тем важнее становится способность <strong>сохранять и использовать знания в структурированном виде</strong>.</div><h3  class="t-redactor__h3">Почему это важно</h3><div class="t-redactor__text">Когда знание зафиксировано только в презентациях, описаниях или локальных моделях — оно быстро устаревает.</div><div class="t-redactor__text"> В отличие от этого, <strong>структурированное знание</strong>, хранящееся в таких системах как Onto, живёт в виде <strong>взаимосвязанного графа фактов</strong>.</div><div class="t-redactor__text"> Это знание можно:</div><div class="t-redactor__text"><ul><li data-list="bullet">анализировать автоматически,</li><li data-list="bullet">преобразовывать в разные форматы,</li><li data-list="bullet">использовать повторно в других системах.</li></ul></div><div class="t-redactor__text">Такое знание становится не просто описанием, а <strong>машиночитаемым активом</strong> — его можно экспортировать, интегрировать, визуализировать, а главное — доверять его актуальности.</div><h3  class="t-redactor__h3">Разнообразие представлений</h3><div class="t-redactor__text">Сила онтологической модели в том, что <strong>одно и то же знание может быть представлено десятками разных способов</strong> — без потери смысла:</div><div class="t-redactor__text"><ul><li data-list="bullet">📘 как <strong>Mermaid или PlantUML</strong> — для архитектурной документации;</li><li data-list="bullet">📊 как <strong>JSON или CSV</strong> — для аналитики и интеграции;</li><li data-list="bullet">🧩 как <strong>Graphviz DOT</strong> — для графических отчётов и визуализации;</li><li data-list="bullet">🧠 как <strong>Cypher / RDF / SPARQL</strong> — для интеллектуальных запросов и reasoning-моделей.</li></ul></div><div class="t-redactor__text">OntoAI позволяет автоматически конвертировать граф знаний из Onto во все эти форматы, превращая модель предприятия в <strong>универсальный источник истины (Single Source of Truth)</strong>, который доступен любому инструменту — от Confluence до BI-платформы.</div><h2  class="t-redactor__h2">🧭 Представление информации из Onto с помощью OntoAI</h2><div class="t-redactor__text">Современные цифровые платформы и корпоративные ИТ-системы состоят из множества взаимосвязанных сервисов, потоков данных и бизнес-процессов.</div><div class="t-redactor__text"> Часто их структура живёт только «в головах» архитекторов, в устаревших схемах или разрозненных документах.</div><div class="t-redactor__text"> Это приводит к <strong>информационной разрозненности</strong>, дублированию знаний и сложностям при развитии архитектуры.</div><div class="t-redactor__text">Платформа <strong>Onto</strong> решает эту проблему, позволяя моделировать все объекты компании — от микросервисов до бизнес-доменов — в едином онтологическом графе.</div><div class="t-redactor__text"> Однако, когда количество сущностей растёт, архитекторы и аналитики сталкиваются с новой задачей:</div><div class="t-redactor__text">🔹 Как <strong>представлять, документировать и анализировать</strong> сложные диаграммы и связи, сохраняя при этом актуальность и машиночитаемость данных?</div><div class="t-redactor__text">Именно для этого используется <strong>OntoAI</strong> — интеллектуальный помощник, который позволяет извлекать данные из Onto и преобразовывать их в <strong>стандартизированные форматы</strong>:</div><div class="t-redactor__text"> для документации, анализа, интеграции и визуализации.</div><div class="t-redactor__text">📘 <strong>Пример кейса:</strong></div><div class="t-redactor__text">В рамках проектирования архитектуры <strong>Data Platform</strong> была создана диаграмма контейнеров (уровень C4), описывающая процесс <em>публикации данных из сервисов предприятия в платформу данных</em>.</div><div class="t-redactor__text"> С помощью OntoAI эту диаграмму можно выгрузить в форматы, подходящие для разных целей — документации, аналитики, интеграции с другими инструментами.</div><img src="https://static.tildacdn.com/tild6230-3466-4133-b236-646261633761/image.png"><h3  class="t-redactor__h3">1. Введение</h3><div class="t-redactor__text"><strong>Onto</strong> — это платформа управления знаниями, в которой сущности, связи и диаграммы формируют <strong>единую онтологическую модель</strong> бизнеса.</div><div class="t-redactor__text"> <strong>OntoAI</strong> расширяет возможности платформы, позволяя автоматически извлекать, анализировать и визуализировать данные из этой модели — в удобных и стандартизированных форматах.</div><h3  class="t-redactor__h3">2. Цели использования OntoAI</h3><div class="t-redactor__text">OntoAI решает следующие задачи:</div><div class="t-redactor__text"><ul><li data-list="bullet">🔍 <strong>Извлечение структурированных данных</strong> из Onto через API;</li><li data-list="bullet">🧩 <strong>Преобразование диаграмм</strong> и графов в открытые форматы;</li><li data-list="bullet">📊 <strong>Интеграция</strong> с аналитическими и документационными системами;</li><li data-list="bullet">🧠 <strong>Автоматический анализ связей</strong> и потоков данных.</li></ul></div><h3  class="t-redactor__h3">3. Поддерживаемые способы представления информации</h3><div class="t-redactor__text">OntoAI поддерживает всевозможные типов <strong>экспорта и визуализации</strong>, каждый из которых подходит для разных сценариев.</div><div class="t-table__viewport"><div class="t-table__wrapper"><table class="t-table__table"><tbody><tr class="t-table__row"><td class="t-table__cell" data-row="0" data-column="0"><div class="t-table__cell-content">Формат</div></td><td class="t-table__cell" data-row="0" data-column="1"><div class="t-table__cell-content">Применение </div></td><td class="t-table__cell" data-row="0" data-column="2"><div class="t-table__cell-content">Пример</div></td></tr><tr class="t-table__row"><td class="t-table__cell" data-row="1" data-column="0"><div class="t-table__cell-content">Mermaid</div></td><td class="t-table__cell" data-row="1" data-column="1"><div class="t-table__cell-content">Документация (Markdown, Confluence, Notion)</div></td><td class="t-table__cell" data-row="1" data-column="2"><div class="t-table__cell-content">flowchart TD схемы</div></td></tr><tr class="t-table__row"><td class="t-table__cell" data-row="2" data-column="0"><div class="t-table__cell-content">Graphviz (DOT)</div></td><td class="t-table__cell" data-row="2" data-column="1"><div class="t-table__cell-content">Визуализация графов, отчёты</div></td><td class="t-table__cell" data-row="2" data-column="2"><div class="t-table__cell-content">.dot → .png</div></td></tr><tr class="t-table__row"><td class="t-table__cell" data-row="3" data-column="0"><div class="t-table__cell-content">JSON</div></td><td class="t-table__cell" data-row="3" data-column="1"><div class="t-table__cell-content">Интеграция с API, Neo4j, D3.js</div></td><td class="t-table__cell" data-row="3" data-column="2"><div class="t-table__cell-content">nodes + links</div></td></tr><tr class="t-table__row"><td class="t-table__cell" data-row="4" data-column="0"><div class="t-table__cell-content">CSV / Excel</div></td><td class="t-table__cell" data-row="4" data-column="1"><div class="t-table__cell-content">Табличная аналитика</div></td><td class="t-table__cell" data-row="4" data-column="2"><div class="t-table__cell-content">source,target,type</div></td></tr><tr class="t-table__row"><td class="t-table__cell" data-row="5" data-column="0"><div class="t-table__cell-content">PlantUML</div></td><td class="t-table__cell" data-row="5" data-column="1"><div class="t-table__cell-content">UML и C4 модели</div></td><td class="t-table__cell" data-row="5" data-column="2"><div class="t-table__cell-content">`@start</div></td></tr><tr class="t-table__row"><td class="t-table__cell" data-row="6" data-column="0"><div class="t-table__cell-content">DrawIO</div></td><td class="t-table__cell" data-row="6" data-column="1"><div class="t-table__cell-content">Документация</div></td><td class="t-table__cell" data-row="6" data-column="2"><div class="t-table__cell-content"></div></td></tr></tbody><colgroup><col style="max-width:180px;min-width:180px;width:180px;"><col style="max-width:180px;min-width:180px;width:180px;"><col style="max-width:180px;min-width:180px;width:180px;"></colgroup></table></div></div><h2  class="t-redactor__h2">📎 Пример использования OntoAI</h2><div class="t-redactor__text">Для демонстрации возможностей экспорта и визуализации использована диаграмма уровня C4 —<br /><br /><strong>«Публикация в платформу данных»</strong>, доступная в Onto по ссылке:<br /><br />🔗 <a href="https://app.ontonet.ru/ru/context/633663e6-7d07-4b1b-89d6-41862d2c25a5/diagram/8c4843c5-20d4-4495-b54e-d768b501cc61">Открыть диаграмму в Onto</a><br /><br />Процесс генерации различных форматов представления (Mermaid, Graphviz, JSON и др.) выполнен в OntoAI:<br /><br />💬 <a href="https://chatgpt.com/share/692c3ee2-f298-8007-83a3-af172973405a" target="_blank" rel="noreferrer noopener">Открыть чат с генерацией примера</a></div><h3  class="t-redactor__h3">Mermaid</h3><blockquote class="t-redactor__quote">graph TD<br />scheduler["scheduler"] --&gt;|"2 раза в сутки (вкл и выкл)"| data_platform["data-platform"]<br />data_platform --&gt;|"читает"| transaction_lifecycle["transaction-lifecycle"]<br />data_platform --&gt;|"читает"| payment_instruction_lifecycle["payment-instruction-lifecycle"]<br />data_platform --&gt;|"читает"| accounting_instruction_lifecycle["accountig-instruction-lifecycle"]<br />data_platform --&gt;|"читает по запросу"| contract_event_dp["contract-event-dp"]<br />data_platform --&gt;|"публикация"| accounting["accounting"]<br />data_platform --&gt;|"публикация"| payment["payment"]<br />data_platform --&gt;|"объекты"| data_platform_core["Платформа данных"]<br />data_platform --&gt;|"enrich"| report_service["report_service"]<br />data_platform --&gt;|"No Name"| справочники["Справочники"]</blockquote><img src="https://static.tildacdn.com/tild3434-3561-4464-b964-353963666566/image.png"><h3  class="t-redactor__h3">Graphviz</h3><blockquote class="t-redactor__quote">digraph "C4_Data_Platform_Containers" {<br /> rankdir=LR;<br /> node [shape=box style=filled color=lightgrey fontname="Arial"];<br /><br /> scheduler [label="scheduler\n(периодический запуск REST сервисов)"];<br /> data_platform [label="data-platform\n(публикация событий в платформу данных)" fillcolor="#d9c3e8"];<br /> transaction_lifecycle [label="transaction-lifecycle\n(Жизненный цикл финансовых инструкций)"];<br /> payment_instruction_lifecycle [label="payment-instruction-lifecycle\n(Жизненный цикл платёжных инструкций)"];<br /> accounting_instruction_lifecycle [label="accountig-instruction-lifecycle\n(Жизненный цикл учётных инструкций)"];<br /> contract_event_dp [label="contract-event-dp\n(события смарт-контрактов)"];<br /> accounting [label="accounting"];<br /> payment [label="payment"];<br /> data_platform_core [label="Платформа данных\n(Стриминг в платформу данных)"];<br /> report_service [label="report_service"];<br /> spravochniki [label="Справочники"];<br /><br /> scheduler -&gt; data_platform [label="2 раза в сутки (вкл и выкл)"];<br /> data_platform -&gt; transaction_lifecycle [label="читает"];<br /> data_platform -&gt; payment_instruction_lifecycle [label="читает"];<br /> data_platform -&gt; accounting_instruction_lifecycle [label="читает"];<br /> data_platform -&gt; contract_event_dp [label="читает по запросу"];<br /> data_platform -&gt; accounting [label="публикация"];<br /> data_platform -&gt; payment [label="публикация"];<br /> data_platform -&gt; data_platform_core [label="объекты"];<br /> data_platform -&gt; report_service [label="enrich"];<br /> data_platform -&gt; spravochniki [label="No Name"];<br />}	</blockquote><img src="https://static.tildacdn.com/tild3366-6533-4031-a439-393763613863/image.png"><h2  class="t-redactor__h2">PlantUML</h2><blockquote class="t-redactor__quote">@startuml<br />title #C4 Data Platform Containers<br />caption Публикация / Стриминг в платформу данных<br /><br />skinparam componentStyle rectangle<br />skinparam shadowing false<br />skinparam arrowColor #646D83<br />skinparam nodeFontColor black<br />skinparam nodeFontSize 12<br /><br />rectangle "scheduler\n(периодический запуск REST сервисов)" as scheduler<br />rectangle "data-platform\n(Микросервис публикации событий в платформу данных)" as data_platform #d9c3e8<br />rectangle "transaction-lifecycle\n(Жизненный цикл финансовых инструкций)" as transaction_lifecycle<br />rectangle "payment-instruction-lifecycle\n(Жизненный цикл платёжных инструкций)" as payment_instruction_lifecycle<br />rectangle "accountig-instruction-lifecycle\n(Жизненный цикл учётных инструкций)" as accounting_instruction_lifecycle<br />rectangle "contract-event-dp\n(События смарт-контрактов)" as contract_event_dp<br />rectangle "accounting" as accounting #b0e6b2<br />rectangle "payment" as payment #b0e6b2<br />rectangle "Платформа данных\n(Стриминг в платформу данных)" as data_platform_core #ff7b8c<br />rectangle "report_service" as report_service #b0e6b2<br />rectangle "Справочники" as spravochniki #ffbdc6<br /><br />scheduler --&gt; data_platform : 2 раза в сутки (вкл и выкл)<br />data_platform --&gt; transaction_lifecycle : читает<br />data_platform --&gt; payment_instruction_lifecycle : читает<br />data_platform --&gt; accounting_instruction_lifecycle : читает<br />data_platform --&gt; contract_event_dp : читает по запросу<br />data_platform --&gt; accounting : публикация<br />data_platform --&gt; payment : публикация<br />data_platform --&gt; data_platform_core : объекты<br />data_platform --&gt; report_service : enrich<br />data_platform --&gt; spravochniki : No Name<br /><br />@enduml<br /><br /></blockquote><img src="https://static.tildacdn.com/tild3966-6161-4664-b337-613232346634/image.png"><h3  class="t-redactor__h3">JSON</h3><div class="t-redactor__text">{<br />	"diagram": {<br />		"id": "8c4843c5-20d4-4495-b54e-d768b501cc61",<br />		"name": "#C4 Data Platform Containers",<br />		"summary": "Публикация / Стриминг в платформу данных"<br />	},<br />	"nodes": [<br />		{<br />			"id": "scheduler",<br />			"label": "scheduler",<br />			"comment": "периодический запуск REST сервисов"<br />		},<br />		{<br />			"id": "data-platform",<br />			"label": "data-platform",<br />			"comment": "Микросервис публикации событий в платформу данных"<br />		},<br />		{<br />			"id": "transaction-lifecycle",<br />			"label": "transaction-lifecycle",<br />			"comment": "Жизненный цикл финансовых инструкций"<br />		},<br />		{<br />			"id": "payment-instruction-lifecycle",<br />			"label": "payment-instruction-lifecycle",<br />			"comment": "Жизненный цикл платёжных инструкций"<br />		},<br />		{<br />			"id": "accountig-instruction-lifecycle",<br />			"label": "accountig-instruction-lifecycle",<br />			"comment": "Жизненный цикл учётных инструкций"<br />		},<br />		{<br />			"id": "contract-event-dp",<br />			"label": "contract-event-dp",<br />			"comment": "События смарт-контрактов"<br />		},<br />		{<br />			"id": "accounting",<br />			"label": "accounting"<br />		},<br />		{<br />			"id": "payment",<br />			"label": "payment"<br />		},<br />		{<br />			"id": "Платформа данных",<br />			"label": "Платформа данных",<br />			"comment": "Стриминг в платформу данных"<br />		},<br />		{<br />			"id": "report_service",<br />			"label": "report_service"<br />		},<br />		{<br />			"id": "Справочники",<br />			"label": "Справочники"<br />		}<br />	],<br />	"links": [<br />		{<br />			"from": "scheduler",<br />			"to": "data-platform",<br />			"type": "2 раза в сутки (вкл и выкл)"<br />		},<br />		{<br />			"from": "data-platform",<br />			"to": "transaction-lifecycle",<br />			"type": "читает"<br />		},<br />		{<br />			"from": "data-platform",<br />			"to": "payment-instruction-lifecycle",<br />			"type": "читает"<br />		},<br />		{<br />			"from": "data-platform",<br />			"to": "accountig-instruction-lifecycle",<br />			"type": "читает"<br />		},<br />		{<br />			"from": "data-platform",<br />			"to": "contract-event-dp",<br />			"type": "читает по запросу"<br />		},<br />		{<br />			"from": "data-platform",<br />			"to": "accounting",<br />			"type": "публикация"<br />		},<br />		{<br />			"from": "data-platform",<br />			"to": "payment",<br />			"type": "публикация"<br />		},<br />		{<br />			"from": "data-platform",<br />			"to": "Платформа данных",<br />			"type": "объекты"<br />		},<br />		{<br />			"from": "data-platform",<br />			"to": "report_service",<br />			"type": "enrich"<br />		},<br />		{<br />			"from": "data-platform",<br />			"to": "Справочники",<br />			"type": "No Name"<br />		}<br />	]<br />}</div><h3  class="t-redactor__h3">CSV</h3><h4  class="t-redactor__h4">Объекты</h4><blockquote class="t-redactor__quote">id,label,comment<br />scheduler,scheduler,периодический запуск REST сервисов<br />data-platform,data-platform,Микросервис публикации событий в платформу данных<br />transaction-lifecycle,transaction-lifecycle,Жизненный цикл финансовых инструкций<br />payment-instruction-lifecycle,payment-instruction-lifecycle,Жизненный цикл платёжных инструкций<br />accountig-instruction-lifecycle,accountig-instruction-lifecycle,Жизненный цикл учётных инструкций<br />contract-event-dp,contract-event-dp,События смарт-контрактов<br />accounting,accounting,<br />payment,payment,<br />Платформа данных,Платформа данных,Стриминг в платформу данных<br />report_service,report_service,<br />Справочники,Справочники,</blockquote><h4  class="t-redactor__h4">Связи</h4><blockquote class="t-redactor__quote">from,to,type<br />scheduler,data-platform,2 раза в сутки (вкл и выкл)<br />data-platform,transaction-lifecycle,читает<br />data-platform,payment-instruction-lifecycle,читает<br />data-platform,accountig-instruction-lifecycle,читает<br />data-platform,contract-event-dp,читает по запросу<br />data-platform,accounting,публикация<br />data-platform,payment,публикация<br />data-platform,Платформа данных,объекты<br />data-platform,report_service,enrich<br />data-platform,Справочники,No Name</blockquote><h3  class="t-redactor__h3">DrawIO</h3><div class="t-redactor__text">Экспорт в <strong>DrawIO</strong> можно выполнить напрямую из интерфейса <strong>Onto</strong>, так же как и в форматы <strong>SVG</strong> или <strong>RDF/XML</strong>.<br /><br />Это позволяет сохранить диаграмму в редактируемом виде и использовать её в сторонних инструментах визуального моделирования — например, в <strong>diagrams.net (Draw.io)</strong>, <strong>Lucidchart</strong> или <strong>Miro</strong>.</div><img src="https://static.tildacdn.com/tild6661-6539-4236-a130-633531303762/image.png">]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Семантический ритуал: как я извлекаю смысл из документов  Часть 1 - &quot;Мотивация&quot;</title>
			<link>https://learning.ontonet.ru/tpost/pc3hp0at91-semanticheskii-ritual-kak-ya-izvlekayu-s</link>
			<amplink>https://learning.ontonet.ru/tpost/pc3hp0at91-semanticheskii-ritual-kak-ya-izvlekayu-s?amp=true</amplink>
			<pubDate>Sun, 07 Dec 2025 14:18:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>Knowledge Graphs</category>
			<category>Практика</category>
			<enclosure url="https://static.tildacdn.com/tild6464-6662-4831-b666-386236626335/freepik__a-dense-clu.png" type="image/png"/>
			<turbo:content>
<![CDATA[<header><h1>Семантический ритуал: как я извлекаю смысл из документов  Часть 1 - "Мотивация"</h1></header><figure><img src="https://static.tildacdn.com/tild6464-6662-4831-b666-386236626335/freepik__a-dense-clu.png"/></figure><div class="t-redactor__text">Иногда один документ скрывает в себе гораздо больше структуры, чем видно на первый взгляд. Со временем я заметил, что если разобрать его онтологически, он перестаёт быть текстом и превращается в сеть смыслов. Для меня это уже давно не эксперимент, а обычный рабочий процесс: беру документ, запускаю OntoLex — и провожу свой семантический ритуал. Презентация раскладывается на страницы, страницы — на термины, термины — на связи, и в итоге документ растворяется в графе, оставляя после себя живую модель знаний.</div><img src="https://static.tildacdn.com/tild3031-3136-4666-b763-393837343932/image.png"><h2  class="t-redactor__h2">Зачем мне живые онтологии в повседневной работе</h2><div class="t-redactor__text">В любой даже очень опытной команде есть невидимый слой работы — мы обмениваемся смыслами, притворяясь, что обмениваемся словами. Для одного «проект» — это инициатива, для другого — бюджет, для третьего — просто папка в Jira. «Клиент» в одном контуре — человек, в другом — юрлицо, в третьем — сегмент, в четвёртом — запись в CRM или вообще API. Пока команда маленькая, это живёт как фоновый шум. Но как только начинаются рост, интеграции и сложные изменения, этот шум превращается в системные ошибки.</div><div class="t-redactor__text">В цифровых моделях, особенно графовых, это ощущается болезненно. Каждый объект связан с десятками других, и от того, как именно мы назвали сущность и что под этим понимаем, напрямую зависит поведение AI-агентов и людей. Одно размазанное слово в одном месте даёт криво настроенный отчёт, неправильный вывод или лишнюю доработку где-то совсем в другом. В какой-то момент я поймал себя на простой, но неприятной мысли: главная слабость сложных систем — не столько архитектура и не только данные, а язык, на котором всё это описано.</div><div class="t-redactor__text">С этого момента у меня появилась рутинная практика: под любой серьёзный проект я поднимаю слой живой онтологии — словаря, встроенного прямо в модель. Не PDF с терминами на финальном слайде и не «где-то был глоссарий в Confluence», а отдельный смысловой слой, который живёт в том же графе, что и процессы, продукты, метрики, системы. Этот слой превращает хаос терминов в управляемую лексику, которую видят и люди, и AI. Модель начинает вести себя предсказуемо: меньше недопониманий, меньше дубликатов сущностей, меньше серых зон, где каждый «и так всё понимает».</div><div class="t-redactor__text">Практический эффект очень прозаичен:</div><div class="t-redactor__text">— постановка задач перестаёт превращаться в переписку «а что ты имел в виду под…»,</div><div class="t-redactor__text"> — моделирование процессов и продуктов ускоряется, потому что ключевые понятия уже разобраны,</div><div class="t-redactor__text"> — API проектируются на одном языке с бизнесом, а не на языке случайных полей,</div><div class="t-redactor__text"> — анализ изменений становится не гаданием, а разбором: видно, какие понятия задеты, а какие нет,</div><div class="t-redactor__text"> — навигация по графу превращается в осмысленное путешествие, а не в игру «найди нужный узел»,</div><div class="t-redactor__text"> — AI-агенты опираются на тот же словарь, что и команда, а не на собственные догадки.</div><div class="t-redactor__text">По сути, такой словарь — это единый языковой интерфейс к системе. Строгий, но живой, контекстный, меняющийся вместе с моделью.</div><div class="t-redactor__text">Если этот словарь поднят в Onto через OntoLex, он не просто хранит слова. Он знает связи между ними, контексты применения, источники определений, зависимости, синонимы и «родословные» понятий. Я ориентируюсь в предметной области быстрее, чем по любой документации: термины не лежат мёртвым списком, они вплетены в граф. Язык команды становится таким же объектом архитектуры, как сервисы и данные. И это уже не разовая «разработка глоссария», а регулярная практика, к которой хочется возвращаться на каждом новом документе.</div><div class="t-redactor__text">Собственно, ради этого текста я зафиксировал один из таких типовых ритуалов — как из обычной презентации сделать живую онтологию, встроить её в существующую модель и получить словарь, который наконец-то работает, а не лежит отдельно.<br /><br /></div><img src="https://static.tildacdn.com/tild6338-3161-4462-a234-363164306337/image.png"><h2  class="t-redactor__h2">Как отсутствие словаря ломает модели и команды</h2><div class="t-redactor__text">Если в обычной жизни разные трактовки слов заканчиваются максимум испорченной встречей, то в цифровых моделях цена ошибки совсем другая. Особенно в графовых, где каждый объект связан с десятками других. Любое размытое понятие в таком контексте становится не «мелкой неточностью», а конструктивным дефектом: оно расползается по узлам, порождает неверные зависимости и заражает смысл всей системы.</div><div class="t-redactor__text">На практике это выглядит очень приземлённо.</div><div class="t-redactor__text"> Ты создаёшь сущность «Клиент» — и уверен, что всё очевидно.</div><div class="t-redactor__text"> Но одна команда под «клиентом» понимает физлицо, другая — компанию, третья — договор, четвёртая — запись в биллинге. В графе это превращается в парадокс: узел называется одинаково, а описывает четыре разные сущности. Где-то это ещё терпимо, но как только нужно принимать решения, считать метрики или строить новые сервисы — всё начинает конфликтовать.</div><div class="t-redactor__text">С процессами ровно такая же история.</div><div class="t-redactor__text"> «Проект» — это проект разработки? Бизнес-инициатива? Проектная команда? Бюджет? План-факт?</div><div class="t-redactor__text"> Пока система живёт в голове одного архитектора и пары аналитиков — она держится.</div><div class="t-redactor__text"> Но как только начинаются изменения, интеграции, обмен моделями между командами, внедрение AI — скрытые расхождения вылезают на поверхность, и модели начинают буксовать.</div><div class="t-redactor__text">Ситуацию усугубляет то, что AI-агенты честно усиливают то, что им дают. Они не могут «интуитивно почувствовать», что под одним и тем же словом разные люди подразумевают разное. Они просто берут контекст: если термин плавает между смыслами, агент будет действовать непредсказуемо. Никакие «идеальные пайплайны» не спасут, если язык не определён.</div><div class="t-redactor__text">Поэтому <strong>отсутствие словаря </strong>— это не «у нас просто нет документа про термины». <strong>Это отсутствие опоры для всей онтологии.</strong></div><div class="t-redactor__text">Это проявляется очень конкретно:</div><div class="t-redactor__text">— появляются дублирующие сущности с похожими, но не совпадающими комментариями,</div><div class="t-redactor__text"> — связи между объектами становятся случайными и нерелевантными,</div><div class="t-redactor__text"> — команды смотрят на одну и ту же диаграмму и видят в ней разное,</div><div class="t-redactor__text"> — любые изменения начинают с обсуждения не сути, а терминов,</div><div class="t-redactor__text"> — AI большую часть времени занят тем, что «догадывается», а не понимает.</div><div class="t-redactor__text">В какой-то момент я честно сказал себе: "если я не управляю языком модели, то модель по определению неуправляема."</div><div class="t-redactor__text"> И с этого момента словарь перестал быть частью «документации» и занял своё настоящие место — фундамент живой онтологии.</div><h2  class="t-redactor__h2">Как я пришёл к идее OntoLex</h2><div class="t-redactor__text">У меня давно была одна устойчивая боль: каждый раз, когда мне попадался важный документ — презентация, исследование, концепция — я пытался вытащить из него главное. Не краткое саммари, не пересказ, а <strong>структуру знания</strong>, ту самую «внутреннюю карту смысла», по которой этот документ вообще создан.</div><div class="t-redactor__text">Мне всегда не хватало инструмента, который бы не просто сокращал текст, а показывал:</div><div class="t-redactor__text"> <em>какие идеи в нём живут, как они связаны и откуда взялись</em>.</div><div class="t-redactor__text">По сути, мне нужен был <strong>ключ</strong> — проводник в ту область знания, из которой этот документ вырос. И довольно быстро стало очевидно, что самым честным, формальным и переносимым таким ключом является <strong>словарь</strong>, но не в виде списка слов, а в виде сети понятий.</div><div class="t-redactor__text">Проблема была только в одном:</div><div class="t-redactor__text"> делать такой словарь вручную — тяжёлое ремесло.</div><div class="t-redactor__text"> Это бесконечное выписывание терминов, борьба с дубликатами, разбор формулировок, попытки держать в голове связь между страницами. Долго, утомительно и почти всегда недоделано.</div><div class="t-redactor__text">А потом у меня появился <strong>OntoAI</strong> — механизм, который позволил быстро собирать ассистентов под свои задачи.</div><div class="t-redactor__text"> И вдруг стало очевидно: если система уже умеет работать со связями, понятиями и классами, то почему бы не научить её помогать мне с документами?</div><div class="t-redactor__text">Так появился OntoLex.</div><div class="t-redactor__text"> Не как «продукт», не как «фича», а как <strong>контекстный инструмент для решения моей собственной боли</strong>:</div><div class="t-redactor__text"><ul><li data-list="bullet">взять документ,</li><li data-list="bullet">извлечь смысл,</li><li data-list="bullet">собрать словарь,</li><li data-list="bullet">перевести всё в онтологию,</li><li data-list="bullet">и сделать это не героическим усилием, а регулярной процедурой.</li></ul></div><div class="t-redactor__text">Шаг за шагом стало понятно, что создание ассистента «для извлечения знаний в виде связанного словаря» — это самое простое и естественное решение.</div><div class="t-redactor__text"> OntoLex просто занял своё место в моём ритуале:</div><div class="t-redactor__text"> я открываю документ, запускаю его — и дальше уже не думаю о механике, а работаю только со смыслом.</div><h2  class="t-redactor__h2">Почему я использую OntoLex: ассистент, который превращает рутину в смысл</h2><div class="t-redactor__text">Я смирился с тем, что разбор документа — это не озарение и не творческий подвиг, а довольно скучное ремесло. Открываешь PDF или страницу в Confluence, читаешь, выписываешь термины, ищешь дубли, решаешь, что есть сущность, что — атрибут, что — процесс, что — ценность. Если делать это вручную, каждый документ — маленький персональный ад исследователя. Полезный, но совершенно не масштабируемый.</div><div class="t-redactor__text">Чем OntoLex принципиально отличается от привычных «умных помощников» из мира текста?</div><div class="t-redactor__text"><ul><li data-list="bullet">Во-первых, он не работает «над документом», он работает <strong>внутри онтологии</strong>. Для него слово — это не просто токен, а потенциальный объект, который может занять своё место в графе.</li><li data-list="bullet">Во-вторых, он узнаёт термины, которые уже есть в словаре, и аккуратно встраивает их в контекст, а не плодит дубли под разными формулировками.</li><li data-list="bullet">В-третьих, он честно говорит: «здесь, кажется, новое понятие» — и предлагает создать сущность, а не просто выделить жирным.</li><li data-list="bullet">В-четвёртых, он сразу спрашивает: это ценность, концепция, ключевой термин, второстепенный термин? То есть подталкивает к онтологическому решению, а не к ещё одному списку слов.</li><li data-list="bullet">И, наконец, он умеет работать <strong>страница за страницей</strong>, превращая документ в карту смыслов, а не в очередной «подсвеченный текст».</li></ul></div><div class="t-redactor__text">Но главное — OntoLex делает процесс повторяемым.</div><div class="t-redactor__text">Не один храбрый подвиг в стиле «мы однажды провели онтологический анализ этой презентации».</div><div class="t-redactor__text"> А понятная, спокойная, воспроизводимая процедура:</div><div class="t-redactor__text"><ol><li data-list="ordered">Задали пространство.</li><li data-list="ordered">Подняли базовый словарь.</li><li data-list="ordered">Описали источник и его разделы.</li><li data-list="ordered">Прошли документ постранично.</li><li data-list="ordered">Получили живую онтологию, с которой можно работать дальше.</li></ol></div><div class="t-redactor__text">После этого словарь перестаёт быть артефактом, лежащим «где-то рядом».</div><div class="t-redactor__text"> Он становится центральным рабочим инструментом:</div><div class="t-redactor__text">— и для меня как моделирующего,</div><div class="t-redactor__text"> — и для команды, которая смотрит на одну и ту же систему,</div><div class="t-redactor__text"> — и для AI, который наконец-то начинает опираться на чётко очерченный язык, а не на догадки.</div><div class="t-redactor__text">Поэтому, когда ко мне попадает новый документ — презентация, концепция, регламент, исследование — у меня рефлекс один и тот же: открыть OntoLex и превратить эту штуку не в ещё один файл, а в кусок живой онтологии.</div><div class="t-redactor__text">продолжение статьи  <a href="https://ontonet.ru/learning/tpost/yslxcpzdk1-semanticheskii-ritual-kak-ya-izvlekayu-s">Семантический ритуал: как я извлекаю смысл из документов Часть 2 - "Практика"</a></div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Семантический ритуал: как я извлекаю смысл из документов  Часть 2 - &quot;Практика&quot;</title>
			<link>https://learning.ontonet.ru/tpost/yslxcpzdk1-semanticheskii-ritual-kak-ya-izvlekayu-s</link>
			<amplink>https://learning.ontonet.ru/tpost/yslxcpzdk1-semanticheskii-ritual-kak-ya-izvlekayu-s?amp=true</amplink>
			<pubDate>Sun, 07 Dec 2025 16:39:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>Практика</category>
			<category>Knowledge Graphs</category>
			<enclosure url="https://static.tildacdn.com/tild3664-3535-4965-b962-333563353032/freepik__a-dense-clu.png" type="image/png"/>
			<turbo:content>
<![CDATA[<header><h1>Семантический ритуал: как я извлекаю смысл из документов  Часть 2 - "Практика"</h1></header><figure><img src="https://static.tildacdn.com/tild3664-3535-4965-b962-333563353032/freepik__a-dense-clu.png"/></figure><h2  class="t-redactor__h2">Готовлю пространство: выбираю, где будет жить словарь</h2><div class="t-redactor__text">Перед тем как разобрать документ, я всегда отвечаю на один вопрос: <strong>где именно будет жить этот словарь</strong> — в новом пространстве или прямо в существующей модели.</div><div class="t-redactor__text">Если это новое исследование или отдельный кейс, мне часто важен «чистый эксперимент». В таком случае я создаю отдельное пространство. Это как завести новую тетрадь: никакой старой разметки, никаких случайных пересечений с тем, что уже было. Всё, что появится в словаре, будет происходить только из этого документа. Такое пространство удобно, когда нужно увидеть исходную структуру смыслов как она есть, без подсказок и искажений от предыдущих проектов.</div><img src="https://static.tildacdn.com/tild3366-3336-4766-a138-343563323230/image.png"><div class="t-redactor__text">Но иногда правильнее сделать наоборот.</div><div class="t-redactor__text"> Иногда словарь нужен не в новом контексте, а прямо внутри уже сложившейся модели. В живой, нагруженной онтологии, где и так много сущностей, связей, диаграмм. В таких случаях OntoLex позволяет аккуратно развернуть словарную модель прямо поверх текущего графа — и это работает как <strong>семантическая санация</strong>:</div><div class="t-redactor__text"><ul><li data-list="bullet">улучшается качество ссылочных данных (меньше «висячих» ссылок и разнородных формулировок);</li><li data-list="bullet">появляются однозначные определения там, где раньше была только коллективная интуиция;</li><li data-list="bullet">исчезают дубликаты сущностей, которые назывались похоже, но жили отдельно;</li><li data-list="bullet">связи между объектами становятся более строгими и осмысленными;</li><li data-list="bullet">AI-агенты перестают «угадывать по ситуации» и начинают опираться на формализованный язык.</li></ul></div><div class="t-redactor__text">В таком режиме словарь не просто фиксирует терминологию, а <strong>оздоравливает существующую модель</strong>: вытаскивает на свет всё, что раньше держалось на устных договорённостях.</div><div class="t-redactor__text">По сути, у меня есть два равноправных сценария:</div><div class="t-redactor__text"><ul><li data-list="bullet">новое исследование → новое пространство и словарь, который растёт из одного источника;</li><li data-list="bullet">укрепление текущей системы → словарь поверх существующего графа, который выпрямляет и связывает термины.</li></ul></div><div class="t-redactor__text">И ценность OntoLex как раз в том, что он делает оба сценария нормальными:</div><div class="t-redactor__text">он одинаково честно работает и в пустом контексте, и в зрелой онтологии. В одном случае мы формируем новую семантику, в другом — приводим в порядок и усиливаем ту, что уже есть.</div><h2  class="t-redactor__h2">Формирую модель классов: ключевые термины, принципы, ценности, концепции</h2><div class="t-redactor__text">Как только пространство определено, я перехожу к первому по-настоящему конструктивному шагу — <strong>формированию структуры словаря</strong>. Документ в этот момент ещё не «разобран», но будущий каркас смыслов уже начинает проступать.</div><div class="t-redactor__text">Первое, что делает OntoLex, — предлагает создать базовую сущность: <strong>«Словарная статья»</strong>.</div><div class="t-redactor__text"> Это тот самый корень, от которого будут наследоваться все остальные понятия. По сути, это договорённость: «всё, что мы дальше называем термином, будет жить в этом семействе».</div><img src="https://static.tildacdn.com/tild6465-6633-4437-a437-353937656463/image.png"><div class="t-redactor__text">Дальше начинается самое интересное: я читаю документ не как текст, а как поле будущей онтологии и пытаюсь почувствовать, какие типы знаний в нём вообще присутствуют. В презентациях, особенно продуктовых и архитектурных, почти всегда всплывает знакомый набор:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>ключевые термины</strong> — фундаментальные сущности предметной области («Онто», «AI-агент», «Живая модель», «пространство знаний» и т.п.);</li><li data-list="bullet"><strong>принципы</strong> — опорные идеи, на которых строится подход;</li><li data-list="bullet"><strong>концепции</strong> — сущности среднего уровня: процессы, шаблоны, механизмы, состояния;</li><li data-list="bullet"><strong>ценности</strong> — эффекты и обещания: «скорость изменений», «устойчивость системы», «дешёвые изменения», «контроль над изменениями»;</li><li data-list="bullet"><strong>второстепенные термины</strong> — полезные, но не несущие конструкцию понятия;</li><li data-list="bullet"><strong>синонимы</strong> — альтернативные названия, исторические ярлыки и разные языковые формы для одного смысла.</li></ul></div><div class="t-redactor__text">Я даю команду OntoLex, и он за секунды поднимает всю эту конструкцию: создаёт классы, наследует их от базовой «Словарной статьи» и готовит почву для наполнения. В этот момент очень отчётливо ощущается, как появляется <strong>скелет будущей онтологии</strong>: у модели появляется не просто список слов, а формат, в котором эти слова будут жить.</div><img src="https://static.tildacdn.com/tild3930-6439-4161-b637-306631303766/image.png"><div class="t-redactor__text">После этого я почти всегда дорабатываю структуру руками. В случае с презентацией Онто я ввёл разделение на:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>базовую онтологию</strong> — понятия платформы как системы (что такое Онто, OntoAI, что такое граф смыслов, живая модель и т.п.),</li><li data-list="bullet"><strong>прикладную онтологию</strong> — понятия внедрения и использования (какие ценности даёт платформа, какие процессы, какие эффекты и сценарии применения).</li></ul></div><div class="t-redactor__text">Это разделение помогает не смешивать «что это за сущность» и «как она помогает бизнесу», а словарю — не захламляться тем, что относится к разным уровням разговора.</div><img src="https://static.tildacdn.com/tild6535-3136-4338-a662-663961623030/image.png"><div class="t-redactor__text">Важно понимать: у OntoLex есть и свой <strong>стартовый минимум</strong>, он не бросает меня в пустое поле. Когда я запускаю ассистента в новом пространстве, он по умолчанию строит минимальную рабочую модель:</div><div class="t-redactor__text"><ul><li data-list="bullet">базовый класс «Словарная статья» как главный носитель смысла;</li><li data-list="bullet">класс «Синоним» как дочерний;</li><li data-list="bullet">набор системных связей вроде «Синоним → Статья», «Статья → Статья» (Includes, Dependency, Synonym) — тот минимум, который позволяет словарю жить как графу, а не как таблице.</li></ul></div><div class="t-redactor__text">Это немного похоже на то, как IDE генерирует каркас проекта: ничего лишнего, только фундамент, который точно пригодится.</div><div class="t-redactor__text">А вот всё остальное — категории терминов, уровни онтологии, дополнительные отношения — рождается уже из контекста документа и моего решения. OntoLex помогает, подсказывает, проверяет дубли, но не навязывает. Он даёт структурный старт, а я превращаю его в полноценную онтологию.</div><img src="https://static.tildacdn.com/tild3566-3138-4165-b337-303234346365/image.png"><div class="t-redactor__text">Формирование модели классов — это не подготовительный этап.</div><div class="t-redactor__text"> Это момент, когда словарь перестаёт быть кучей слов и становится <strong>каркасом смысла</strong>.</div><div class="t-redactor__text"> Дальше в этот каркас будут вешаться термины из документа, и структура начнёт нарастать почти автоматически.</div><h2  class="t-redactor__h2">Добавляю онтологию источников: документ становится частью модели</h2><img src="https://static.tildacdn.com/tild6433-3766-4363-a336-363361316366/image.png"><div class="t-redactor__text">Когда каркас словаря выстроен, я перехожу к следующему шагу — <strong>делаю сам документ полноправным объектом онтологии</strong>.</div><div class="t-redactor__text">Пока презентация существует только как PDF или набор слайдов, она — внешний артефакт. Она лежит рядом с моделью, но не внутри неё. Как только я переношу её в граф, она начинает подчиняться тем же правилам, что и любые другие сущности: у неё появляется тип, связи, контекст, происхождение и роль.</div><div class="t-redactor__text">Для этого я ввожу два класса:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>«Источник»</strong> — документ целиком: презентация, статья, отчёт, регламент, исследование. Всё то, на что мы ссылаемся, когда задаём вопрос «а где это написано?»</li><li data-list="bullet"><strong>«Раздел источника»</strong> — логический кусок документа: слайд, страница, секция, фрагмент.</li></ul></div><div class="t-redactor__text">Это важно, потому что единица знания почти никогда не «во всём документе», она всегда живёт в конкретном месте: на втором слайде, в третьем разделе, в конкретном абзаце.</div><img src="https://static.tildacdn.com/tild6561-6662-4132-a231-326631386337/image.png"><div class="t-redactor__text">OntoLex умеет работать с такой схемой и тут же предлагает завести нужные связи:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>«Содержит»</strong> — Источник → Раздел источника;</li><li data-list="bullet"><strong>«Следующий/предыдущий раздел»</strong> — навигация между частями документа;</li><li data-list="bullet"><strong>«Ссылается на»</strong> — Раздел источника → Словарная статья;</li><li data-list="bullet"><strong>«Относится к источнику»</strong> — Словарная статья → Источник (обратная связь).</li></ul></div><div class="t-redactor__text">В этот момент документ перестаёт быть просто входным материалом и становится <strong>элементом онтологии</strong>. У него есть:</div><div class="t-redactor__text"><ul><li data-list="bullet">структура,</li><li data-list="bullet">разделы,</li><li data-list="bullet">связи,</li><li data-list="bullet">роль в модели.</li></ul></div><div class="t-redactor__text">Дальше каждый термин, который мы извлечём, будет иметь не только определение и класс, но и:</div><div class="t-redactor__text"><ul><li data-list="bullet">своё <strong>происхождение</strong> (из какого источника),</li><li data-list="bullet">свой <strong>контекст появления</strong> (на какой странице/слайде),</li><li data-list="bullet">свой <strong>маршрут</strong> внутри документа.</li></ul></div><div class="t-redactor__text">Это даёт очень сильный эффект: словарь становится <strong>трассируемым</strong>.</div><div class="t-redactor__text"> Я в любой момент могу открыть термин и увидеть: он появился на Странице 2, связан с такими-то соседними понятиями, а их корень — вот там, на Странице 1.</div><div class="t-redactor__text">По сути, это уже не просто структурирование — это маленькая эпистемология.</div><img src="https://static.tildacdn.com/tild3463-3761-4537-b335-363530663461/image.png"><div class="t-redactor__text"> Модель начинает помнить не только <em>что</em> она знает, но и <em>откуда</em> это знание взялось.</div><div class="t-redactor__text">И каждый раз, когда я делаю этот шаг, я думаю:</div><div class="t-redactor__text"> если бы я пытался держать всё это в Excel, я бы уже давно возненавидел и словари, и документы.</div><div class="t-redactor__text"> В связке с OntoLex это превращается в спокойный, повторяемый ритуал:</div><div class="t-redactor__text"> создал Источник, нарезал его на Разделы — и документ плавно растворился в графе, став его частью.</div><img src="https://static.tildacdn.com/tild3539-6132-4135-b735-626635306436/image.png"><h2  class="t-redactor__h2">Строю структуру презентации: создаю 16 страниц и связи «Содержит»</h2><div class="t-redactor__text">Когда классы «Источник» и «Раздел источника» готовы, начинается одна из самых зрелищных фаз — я <strong>превращаю сам документ в граф</strong>.</div><div class="t-redactor__text">Я создаю объект <strong>«Презентация Онто»</strong> — это и есть наш Источник.</div><div class="t-redactor__text"> Дальше OntoLex делает за меня ту часть работы, которую раньше приходилось выполнять вручную, лениво и с ошибками:</div><div class="t-redactor__text"><ul><li data-list="bullet">создаёт <strong>16 объектов класса «Раздел источника»</strong> — по одному на каждый слайд;</li><li data-list="bullet">аккуратно нумерует их и даёт имена, привязанные к содержанию;</li><li data-list="bullet">заполняет комментарии, если это нужно;</li><li data-list="bullet">строит структурные связи.</li></ul></div><img src="https://static.tildacdn.com/tild3533-3035-4661-b938-376434316663/image.png"><div class="t-redactor__text">На уровне графа это выглядит так:</div><div class="t-redactor__text"><ul><li data-list="bullet">«Презентация Онто → содержит → Страница 1»</li><li data-list="bullet">«Презентация Онто → содержит → Страница 2»</li><li data-list="bullet">…</li><li data-list="bullet">«Презентация Онто → содержит → Страница 16»</li></ul></div><div class="t-redactor__text">То есть весь документ получает очевидную иерархию: один Источник, множество Разделов.</div><div class="t-redactor__text">На этом OntoLex не останавливается.</div><div class="t-redactor__text"> Он предлагает создать связи <strong>«следующий раздел» / «предыдущий раздел»</strong>, чтобы модель документа была не просто деревом, а ещё и последовательностью. Появляется цепочка:</div><div class="t-redactor__text"><strong>Страница 1 → Страница 2 → Страница 3 → … → Страница 16</strong></div><div class="t-redactor__text">В итоге у меня в модели — не просто набор страниц, а <strong>онтологическая карта документа</strong>:</div><div class="t-redactor__text"><ul><li data-list="bullet">я вижу, сколько у него разделов;</li><li data-list="bullet">как они связаны;</li><li data-list="bullet">в каком порядке идут;</li><li data-list="bullet">как к ним можно перейти из других частей графа.</li></ul></div><div class="t-redactor__text">В этот момент я открываю диаграмму <strong>«Структура презентации»</strong> и впервые смотрю на знакомый документ не как на стопку слайдов, а как на <strong>живую структуру смысловых фрагментов</strong>. Там, где раньше было «ну вот презентация», теперь есть:</div><div class="t-redactor__text"><ul><li data-list="bullet">узел Источника,</li><li data-list="bullet">гроздь из 16 разделов,</li><li data-list="bullet">цепочка последовательности,</li><li data-list="bullet">готовые точки, к которым позже пристегнутся термины.</li></ul></div><div class="t-redactor__text">И каждый раз этот жест простой, почти механический шаг — «создать страницы и связи» — даёт одно и то же ощущение:</div><div class="t-redactor__text"> обычный PDF вдруг начинает вести себя как часть системы знаний, а не как файл, который лежит где-то сбоку.</div><h2  class="t-redactor__h2">Главное волшебство: OntoLex читает каждую страницу и извлекает термины</h2><div class="t-redactor__text">Когда структура документа готова — 16 страниц на своих местах, каждая связана с Источником и с соседями — начинается самая вкусная часть процесса.</div><div class="t-redactor__text">Я открываю <strong>Страницу 1</strong> презентации.</div><div class="t-redactor__text"> OntoLex — тоже.</div><div class="t-redactor__text">И вот здесь каждый раз срабатывает одинаковое ощущение:</div><div class="t-redactor__text"> ассистент начинает читать страницу не как текст, а как <strong>пространство смыслов</strong>.</div><div class="t-redactor__text">Он не пытается просто найти «ключевые слова» и подсветить их жёлтым.</div><div class="t-redactor__text"> Он ищет <strong>понятия</strong>. Разбирает, что на странице является сущностью, что — ценностью, что — эффектом, а что — просто обвязкой.</div><img src="https://static.tildacdn.com/tild3135-3035-4562-a531-626366326237/image.png"><div class="t-redactor__text">На заглавном слайде он сразу выделяет:</div><div class="t-redactor__text"><ul><li data-list="bullet">«Онто» — уже существующий ключевой термин;</li><li data-list="bullet">«Живая модель» — тоже ключевой термин;</li><li data-list="bullet">«AI-агент» — новый объект, для которого стоит создать статью;</li><li data-list="bullet">«Ценность в темпе» — формулировку, которую разумно оформить как отдельную «ценность».</li></ul></div><div class="t-redactor__text">И делает не просто список. Он спрашивает меня:</div><div class="t-redactor__text">«Создаём новый термин <em>AI-агент</em>?</div><div class="t-redactor__text"> К какому классу отнесём?</div><div class="t-redactor__text"> Свяжем Страницу 1 с этим термином?»</div><div class="t-redactor__text">То есть он ведёт себя не как парсер, а как <strong>онтологический собеседник</strong>.</div><div class="t-redactor__text"> Я отвечаю «да» — и в этот момент появляются:</div><div class="t-redactor__text"><ul><li data-list="bullet">новая словарная статья «AI-агент»;</li><li data-list="bullet">связь «Страница 1 → Ссылается на → AI-агент»;</li><li data-list="bullet">принадлежность к классу (ключевой термин или участник модели);</li><li data-list="bullet">первичный комментарий, который я сразу могу уточнить.</li></ul></div><div class="t-redactor__text">Страница 2 — другая картина.</div><div class="t-redactor__text"> Там концентрат ценностей и эффектов: «скорость изменений», «устойчивость системы», «контроль над изменениями», «конкурентное преимущество», «усиление людей AI-агентами». OntoLex раскладывает это по полочкам:</div><div class="t-redactor__text"><ul><li data-list="bullet">вот список ценностей,</li><li data-list="bullet">вот процессы и эффекты,</li><li data-list="bullet">вот новые понятия,</li><li data-list="bullet">вот уточнение уже существующих.</li></ul></div><div class="t-redactor__text">Если термин уже живёт в словаре (например, «скорость изменений»), ассистент не создаёт дубликат — он предлагает связать раздел с существующей сущностью. Если понятие новое — предлагает завести статью и сразу вставить её в правильное место онтологии.</div><div class="t-redactor__text">Каждый раз, когда я подтверждаю его предложения:</div><div class="t-redactor__text"><ul><li data-list="bullet">создаём новую статью или используем старую;</li><li data-list="bullet">фиксируем связь «Страница N → Ссылается на → Термин»;</li><li data-list="bullet">уточняем класс и контекст;</li><li data-list="bullet">наращиваем сетку смысловых отношений.</li></ul></div><div class="t-redactor__text">В этот момент словарь перестаёт быть набором карточек и становится <strong>структурным контекстом</strong>, вплетённым в общий граф.</div><div class="t-redactor__text">Третья страница, четвёртая, пятая…</div><div class="t-redactor__text"> Ритуал повторяется, но ощущение меняется:</div><div class="t-redactor__text"> документ буквально «распаковывается» в виде сети.</div><div class="t-redactor__text"><ul><li data-list="bullet">новые связи появляются как ветки и корни;</li><li data-list="bullet">старые понятия обретают глубину, когда для них добавляются новые контексты;</li><li data-list="bullet">страницы становятся не картинками, а логическими блоками происхождения знания;</li><li data-list="bullet">презентация шаг за шагом растворяется в онтологии.</li></ul></div><div class="t-redactor__text">Это тот самый момент, который я для себя однажды сформулировал так — и специально оставляю эту фразу в тексте:</div><div class="t-redactor__text"><strong>«Это один из самых красивых шагов, потому что именно здесь OntoLex начинает работать как семантический сканер документа…»</strong></div><div class="t-redactor__text">И это действительно так:</div><div class="t-redactor__text"> ты видишь, как ассистент проходит по документу, слой за слоем, и превращает его из линейной последовательности слайдов в распределённое поле смыслов.</div><img src="https://static.tildacdn.com/tild3466-3564-4636-b333-313939306531/image.png"><h2  class="t-redactor__h2">Постепенное нарастание структуры: категории, ценности, концепции, процессы</h2><div class="t-redactor__text">После нескольких страниц становится видно, что документ больше не живёт как линейная лента слайдов.</div><div class="t-redactor__text"> Он уже ведёт себя как <strong>фрагмент живой онтологии</strong>.</div><img src="https://static.tildacdn.com/tild3365-6164-4930-a537-663666303230/image.png"><div class="t-redactor__text">На этом этапе лучше всего подходит слово «нарастание».</div><div class="t-redactor__text">Каждый новый термин, каждая связь «Страница → Термин», каждое уточнение класса и контекста — это маленькое действие. Само по себе оно выглядит скромно. Но в сумме эти микро-шаги дают лавинообразный эффект:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>ключевые термины</strong> превращаются в узлы высокой связности — к ним тянутся ценности, процессы, контексты;</li><li data-list="bullet"><strong>ценности</strong> собираются в отдельный слой, показывая, за что вообще стоит бороться и что система обещает бизнесу;</li><li data-list="bullet"><strong>концепции</strong> становятся центрами объяснений: вокруг них группируются процессы, состояния, механизмы;</li><li data-list="bullet"><strong>процессы</strong> связывают принципы и результаты: «почему мы так делаем» → «какого эффекта достигаем»;</li><li data-list="bullet"><strong>второстепенные термины</strong> заполняют нюансы, чтобы между крупными блоками не оставалось провалов;</li><li data-list="bullet"><strong>страницы</strong> закрепляют происхождение: видно, из какого фрагмента документа взялся каждый кусочек смысла.</li></ul></div><div class="t-redactor__text">Сначала структура напоминает набор отдельных деревьев.</div><div class="t-redactor__text"> Через несколько страниц — уже кусты, где ветви начинают переплетаться.</div><div class="t-redactor__text"> К концу презентации это выглядит как полноценный граф, в котором каждая ветка связана с другими, а смысл не обрывается на границе слайда.</div><div class="t-redactor__text">Важно, что это не просто «красиво нарисованная картинка».</div><div class="t-redactor__text"> Это <strong>качественное изменение модели</strong>: документ перестаёт быть источником данных и становится частью логики системы.</div><div class="t-redactor__text">Я при этом не пишу ни одной строки кода, не руками протягиваю линии между узлами и не сижу ночами в графовом редакторе. Я всего лишь:</div><div class="t-redactor__text"><ul><li data-list="bullet">подтверждаю создание нужных статей,</li><li data-list="bullet">уточняю классы,</li><li data-list="bullet">соглашаюсь или не соглашаюсь на предлагаемые связи,</li><li data-list="bullet">иногда добавляю комментарий по смыслу.</li></ul></div><div class="t-redactor__text">Все эти «да» и «так точнее» постепенно вытягивают структуру, и в какой-то момент OntoLex начинает заниматься уже не только извлечением, но и <strong>содержательной гигиеной</strong>.</div><div class="t-redactor__text">И тут раскрывается вторая половина его силы:</div><div class="t-redactor__text"><ul><li data-list="bullet">если появляется повторяющееся понятие под другой формулировкой — он предложит связать его с уже существующим;</li><li data-list="bullet">если термин похож на существующий, но отличается оттенком смысла — задаст вопрос, в чём именно различие, и поможет развести их аккуратно;</li><li data-list="bullet">если термин одновременно тянется к нескольким концепциям — покажет, как это отразить в связях, не потеряв ясности;</li><li data-list="bullet">если в документе начинают появляться новые эффекты или процессы, которые не вписываются в текущую сетку — предложит расширить онтологию.</li></ul></div><div class="t-redactor__text">Это уже не просто «анализ документа».</div><div class="t-redactor__text"> Это <strong>эволюция модели знаний</strong>, которая происходит в ритме текста: страница за страницей, без отдельных «эпических задач по рефакторингу».</div><div class="t-redactor__text">В какой-то момент ловишь себя на том, что структура, которую ты бы вручную строил днями, выросла сама — потому что каждый крошечный шаг был сделан в правильной онтологической рамке.</div><blockquote class="t-redactor__preface">Продолжение <a href="https://ontonet.ru/learning/tpost/8kuhkp5s01-semanticheskii-ritual-kak-ya-izvlekayu-s">Семантический ритуал: как я извлекаю смысл из документов Часть 3 - "Заключение"</a></blockquote>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Семантический ритуал: как я извлекаю смысл из документов Часть 3 - &quot;Заключение&quot;</title>
			<link>https://learning.ontonet.ru/tpost/8kuhkp5s01-semanticheskii-ritual-kak-ya-izvlekayu-s</link>
			<amplink>https://learning.ontonet.ru/tpost/8kuhkp5s01-semanticheskii-ritual-kak-ya-izvlekayu-s?amp=true</amplink>
			<pubDate>Sun, 07 Dec 2025 16:44:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>Практика</category>
			<category>Knowledge Graphs</category>
			<category>AI</category>
			<enclosure url="https://static.tildacdn.com/tild6631-3333-4531-a363-333332316365/freepik__a-dense-clu.png" type="image/png"/>
			<turbo:content>
<![CDATA[<header><h1>Семантический ритуал: как я извлекаю смысл из документов Часть 3 - "Заключение"</h1></header><figure><img src="https://static.tildacdn.com/tild6631-3333-4531-a363-333332316365/freepik__a-dense-clu.png"/></figure><blockquote class="t-redactor__preface">начало  <a href="https://ontonet.ru/learning/tpost/yslxcpzdk1-semanticheskii-ritual-kak-ya-izvlekayu-s">Семантический ритуал: как я извлекаю смысл из документов Часть 2 - "Практика"</a></blockquote><h2  class="t-redactor__h2">Презентация растворяется в живой модели: как выглядит финальный граф</h2><div class="t-redactor__text">Когда OntoLex проходит последнюю страницу документа, случается довольно странное ощущение: <strong>презентации больше нет</strong>.</div><div class="t-redactor__text">PDF, с которого всё начиналось, перестаёт быть главным объектом.</div><div class="t-redactor__text"> Он как будто растворяется внутри модели, оставляя после себя:</div><div class="t-redactor__text"><ul><li data-list="bullet">словарь — набор терминов с чёткими определениями и классами,</li><li data-list="bullet">онтологию понятий — кто с кем связан и почему,</li><li data-list="bullet">онтологию источников — откуда каждое из этих понятий взялось,</li><li data-list="bullet">сеть отношений — как термины, страницы, ценности и процессы переплетены друг с другом,</li><li data-list="bullet">граф смыслов, который можно читать, дополнять, использовать — независимо от исходного файла.</li></ul></div><div class="t-redactor__text">Каждая страница презентации теперь — не слайд, а <strong>онтологический узел</strong>.</div><div class="t-redactor__text"> Каждый термин — не слово, а сущность с происхождением, связями, классом и контекстами.</div><div class="t-redactor__text"> Каждая ценность, каждый процесс, каждый принцип — часть смысловой инфраструктуры, на которой можно строить аналитику, архитектуру, обучение, решения.</div><div class="t-redactor__text">Самое сильное чувство приходит, когда я открываю диаграмму презентации уже после окончания работы. На ней больше не видно привычных «16 слайдов». Вместо этого я вижу:</div><div class="t-redactor__text"><ul><li data-list="bullet">один узел Источника — «Презентация Онто»,</li><li data-list="bullet">от него — веер из Страниц 1–16,</li><li data-list="bullet">от каждой страницы — набор связей «Ссылается на → термин»,</li><li data-list="bullet">а дальше — слои онтологии: ключевые термины, ценности, процессы, концепции.</li></ul></div><div class="t-redactor__text">Визуально это больше похоже не на документ, а на <strong>нейронную карту</strong>.</div><div class="t-redactor__text"> Каждый узел — смысл.</div><div class="t-redactor__text"> Каждая линия — отношение.</div><div class="t-redactor__text"> Группы узлов — логические блоки знания, которые можно анализировать и перестраивать.</div><div class="t-redactor__text">И вот в этот момент становится очень очевидно:</div><div class="t-redactor__text">документ — это всего лишь упаковка.</div><div class="t-redactor__text"> Смысл должен жить не в слайдах, а в модели.</div><div class="t-redactor__text">Я вижу, как:</div><div class="t-redactor__text"><ul><li data-list="bullet">ценности связаны с принципами,</li><li data-list="bullet">принципы — с ключевыми терминами,</li><li data-list="bullet">ключевые термины — с процессами,</li><li data-list="bullet">процессы — с эффектами,</li><li data-list="bullet">эффекты — с контекстами,</li><li data-list="bullet">а все они — с конкретными страницами, откуда были извлечены.</li></ul></div><div class="t-redactor__text">Нет больше «на втором слайде была важная мысль, надо ещё раз посмотреть».</div><div class="t-redactor__text"> Теперь эта мысль — узел в онтологии. Она встроена в граф, имеет связи, историю и влияние.</div><div class="t-redactor__text">Каждый раз, когда я прохожу такой цикл, я думаю одно и то же:</div><div class="t-redactor__text"> <strong>я только что получил живую модель знаний из обычного документа, за один осмысленный проход.</strong></div><div class="t-redactor__text">И именно так, на мой взгляд, должна работать онтология в реальной жизни:</div><div class="t-redactor__text"> конечный результат — не красиво оформленный PDF, а <strong>структура смыслов</strong>, которая продолжает жить, расти, дополняться и служить точкой опоры для решений.</div><h2  class="t-redactor__h2">Что это даёт: скорость, меньше ошибок, яснее коммуникация и адекватный AI</h2><div class="t-redactor__text">Когда презентация превращается в онтологию, я получаю не просто аккуратно разобранный документ.</div><div class="t-redactor__text"> Я получаю <strong>рабочий инструмент</strong>, который начинает влиять на скорость, качество и предсказуемость решений.</div><div class="t-redactor__text"><strong>1. Скорость работы растёт в разы</strong></div><div class="t-redactor__text">Мне больше не нужно листать документ туда-сюда.</div><div class="t-redactor__text"> Если нужно вспомнить, где впервые появилось понятие «скорость изменений», я не пробегаю глазами по PDF. Я открываю соответствующий узел в онтологии — и сразу вижу:</div><div class="t-redactor__text"><ul><li data-list="bullet">страницу происхождения,</li><li data-list="bullet">связанные ценности,</li><li data-list="bullet">связанные процессы,</li><li data-list="bullet">все соседние понятия, которые с этим связаны.</li></ul></div><div class="t-redactor__text">То, что раньше занимало минуты (иногда десятки минут с отвлечениями), превращается в пару кликов.</div><div class="t-redactor__text"><strong>2. Исчезают смысловые ошибки</strong></div><div class="t-redactor__text">Большинство дорогих ошибок рождается не из «плохой архитектуры», а из <strong>разного понимания одного и того же слова</strong>.</div><div class="t-redactor__text"> Когда термин в онтологии:</div><div class="t-redactor__text"><ul><li data-list="bullet">имеет класс (кто он — сущность, процесс, ценность, роль?),</li><li data-list="bullet">живёт в контексте (где используется, с чем связан),</li><li data-list="bullet">обладает явными связями,</li><li data-list="bullet">знает своё происхождение,</li></ul></div><div class="t-redactor__text">путать его с соседними просто не получается.</div><div class="t-redactor__text"> Это реально ощущается как <strong>семантическая безопасность системы</strong>.</div><div class="t-redactor__text"><strong>3. Коммуникация внутри команды становится чище</strong></div><div class="t-redactor__text">Когда я показываю онтологию команде, вопрос «а что ты имеешь в виду под этим словом?» возникает гораздо реже.</div><div class="t-redactor__text"> Ответ уже есть в модели:</div><div class="t-redactor__text"><ul><li data-list="bullet">определение,</li><li data-list="bullet">класс,</li><li data-list="bullet">где термин родился,</li><li data-list="bullet">что от него зависит.</li></ul></div><div class="t-redactor__text">Мы начинаем говорить <strong>одним языком</strong>, а не шестью слегка разными диалектами.</div><div class="t-redactor__text"><strong>4. Вычищаются дубли, противоречия и «серые зоны»</strong></div><div class="t-redactor__text">Это один из самых приятных побочных эффектов.</div><div class="t-redactor__text"> OntoLex сам обращает внимание на похожие термины:</div><div class="t-redactor__text">«Вот здесь “скорость изменений”, а вот здесь “быстрота внедрения” — это одно и то же или нет?»</div><div class="t-redactor__text">Иногда я сам впервые замечаю, что в голове смешивал два разных уровня смысла.</div><div class="t-redactor__text"> После онтологизации документа:</div><div class="t-redactor__text"><ul><li data-list="bullet">дубли уходят или аккуратно сливаются,</li><li data-list="bullet">различия становятся явными,</li><li data-list="bullet">структура выравнивается,</li><li data-list="bullet">модель ведёт себя спокойнее и предсказуемее.</li></ul></div><div class="t-redactor__text"><strong>5. AI начинает работать по делу, а не по догадкам</strong></div><div class="t-redactor__text">AI — не маг. Он не может «догадаться», что под одним и тем же словом разные люди подразумевают разные вещи. Но если:</div><div class="t-redactor__text"><ul><li data-list="bullet">каждое ключевое понятие определено,</li><li data-list="bullet">встроено в онтологию,</li><li data-list="bullet">связано с источником,</li><li data-list="bullet">имеет контекст и связи,</li></ul></div><div class="t-redactor__text">AI-агенты перестают галлюцинировать и начинают <strong>рассуждать в рамках общей модели</strong>.</div><div class="t-redactor__text"> В какой-то момент я поймал себя на мысли:</div><div class="t-redactor__text"> «Я наконец-то перестал обучать AI догадкам. Я дал ему язык, и он работает на этом языке».</div><div class="t-redactor__text"><strong>6. Модель становится дополненной памятью команды</strong></div><div class="t-redactor__text">Словарь и онтология вместе хранят:</div><div class="t-redactor__text"><ul><li data-list="bullet">что это за сущность,</li><li data-list="bullet">зачем она вообще нужна,</li><li data-list="bullet">откуда она появилась,</li><li data-list="bullet">как она связана с другими вещами,</li><li data-list="bullet">где о ней впервые было сказано,</li><li data-list="bullet">какие части системы зависят от её изменений.</li></ul></div><div class="t-redactor__text">Обычно всё это существует в виде «коллективной памяти» опытных людей.</div><div class="t-redactor__text"> Онтология делает эту память <strong>частью системы</strong>, доступной любому, кто подключается к проекту.</div><div class="t-redactor__text">В итоге превращение документа в онтологию — это не про «красивый граф».</div><div class="t-redactor__text"> Это про <strong>усилитель</strong>:</div><div class="t-redactor__text"><ul><li data-list="bullet">скорости,</li><li data-list="bullet">качества решений,</li><li data-list="bullet">стабильности изменений,</li><li data-list="bullet">эффективности AI,</li><li data-list="bullet">и ясности коммуникации внутри команды.</li></ul></div><h2  class="t-redactor__h2">Как повторить метод: короткий рецепт, который работает на любом документе</h2><div class="t-redactor__text">Если вся эта история звучит как что-то сложное или «одноразово героическое», то это обманчивое впечатление. На практике метод довольно простой, и я использую его каждый раз, когда ко мне попадает новый документ — от презентации до внутреннего регламента.</div><div class="t-redactor__text">Вот минимальный рабочий рецепт.</div><div class="t-redactor__text"><strong>Шаг 1. Определите, где будет жить словарь</strong></div><div class="t-redactor__text">Сначала отвечаю себе на вопрос: в каком контексте этот словарь будет полезнее.</div><div class="t-redactor__text"><ul><li data-list="bullet">Если это <strong>новое исследование</strong> или пилот — создаю отдельное пространство, чтобы увидеть «чистую» семантику документа.</li><li data-list="bullet">Если это <strong>доработка существующей системы</strong> — поднимаю словарь прямо внутри действующего пространства, чтобы выпрямить и усилить текущий граф.</li></ul></div><div class="t-redactor__text"><strong>Шаг 2. Сформируйте базовую структуру словаря</strong></div><div class="t-redactor__text">OntoLex берёт на себя стартовую работу:</div><div class="t-redactor__text"><ul><li data-list="bullet">создаёт базовый класс «Словарная статья»,</li><li data-list="bullet">поднимает класс «Синоним»,</li><li data-list="bullet">заводит минимальные служебные связи между статьями.</li></ul></div><div class="t-redactor__text">Я добавляю своё:</div><div class="t-redactor__text"><ul><li data-list="bullet">выделяю ключевые термины,</li><li data-list="bullet">формирую классы «Принцип», «Концепция», «Ценность», «Второстепенный термин»,</li><li data-list="bullet">при необходимости разделяю онтологию на базовую и прикладную.</li></ul></div><div class="t-redactor__text"><strong>Шаг 3. Сделайте документ частью модели</strong></div><div class="t-redactor__text">Дальше я завожу:</div><div class="t-redactor__text"><ul><li data-list="bullet">объект <strong>Источник</strong> — сам документ (презентация, отчёт, статья),</li><li data-list="bullet">объекты <strong>Раздел источника</strong> — страницы, слайды, секции,</li><li data-list="bullet">связи «Содержит» (Источник → Раздел) и связи последовательности между разделами.</li></ul></div><div class="t-redactor__text">На этом шаге документ становится <strong>картой</strong> внутри модели.</div><div class="t-redactor__text"><strong>Шаг 4. Пройдите документ постранично</strong></div><div class="t-redactor__text">Это основная рутина — но именно её OntoLex сильно облегчает.</div><div class="t-redactor__text">Для каждой страницы:</div><div class="t-redactor__text"><ul><li data-list="bullet">открываю раздел в Onto,</li><li data-list="bullet">даю OntoLex прочитать текст,</li><li data-list="bullet">смотрю, какие понятия он предлагает извлечь,</li><li data-list="bullet">подтверждаю создание новых статей или связывание с существующими,</li><li data-list="bullet">утверждаю связи «Страница N → Ссылается на → Термин».</li></ul></div><div class="t-redactor__text">Каждое такое подтверждение — маленькая порция структурированного смысла, который больше не потеряется.</div><div class="t-redactor__text"><strong>Шаг 5. Дождитесь, пока онтология начнёт расти сама</strong></div><div class="t-redactor__text">После 5–6 страниц контур становится виден:</div><div class="t-redactor__text"><ul><li data-list="bullet">появляются центры смыслов — узлы, к которым тянется множество связей;</li><li data-list="bullet">ценности начинают группироваться, показывая, вокруг чего строится история;</li><li data-list="bullet">процессы связываются с принципами и эффектами;</li><li data-list="bullet">видно, какие вещи повторяются, а какие появляются впервые.</li></ul></div><div class="t-redactor__text">В этот момент ты перестаёшь «разбирать документ» и начинаешь <strong>наблюдать за эволюцией модели</strong>.</div><div class="t-redactor__text"><strong>Шаг 6. Используйте граф вместо документа</strong></div><div class="t-redactor__text">На этом этапе документ перестаёт быть главным объектом.</div><div class="t-redactor__text"> Работа идёт уже с:</div><div class="t-redactor__text"><ul><li data-list="bullet">страницами как онтологическими разделами,</li><li data-list="bullet">терминами как объектами системы,</li><li data-list="bullet">связями как объяснениями,</li><li data-list="bullet">диаграммами как визуальными проекциями смысла.</li></ul></div><div class="t-redactor__text">Нужно вспомнить, что именно обещали под «скоростью изменений»?</div><div class="t-redactor__text"> Я больше не ищу глазами по слайдам. Я открываю узел и смотрю: откуда он, с чем связан, какие ценности и процессы к нему привязаны.</div><div class="t-redactor__text">И самое важное:</div><div class="t-redactor__text"><strong>Этот метод переносим куда угодно</strong></div><div class="t-redactor__text">Теоретически всё то же самое можно сделать:</div><div class="t-redactor__text"><ul><li data-list="bullet">в Excel,</li><li data-list="bullet">в Notion или Confluence,</li><li data-list="bullet">на стикерах и Miro,</li><li data-list="bullet">хоть на бумаге.</li></ul></div><div class="t-redactor__text">Разница только в том, <strong>какой ценой</strong>.</div><div class="t-redactor__text">В табличках и заметках вы будете бороться с дубликатами, путаницей и отсутствием структуры.</div><div class="t-redactor__text"> В связке Onto + OntoLex рутинная часть — извлечение, связывание, проверка консистентности — ложится на ассистента, а вам остаётся самое интересное: думать о смыслах.</div><div class="t-redactor__text">Лично для меня эта процедура уже давно перестала быть «разовой задачей» и превратилась в рабочий рефлекс:</div><h2  class="t-redactor__h2"> Новый важный документ — значит, впереди ещё одна живая онтология.</h2><blockquote class="t-redactor__quote">Документ здесь — только проводник. Настоящее открытие начинается в тот момент, когда структура знаний проступает из привычного текста. Смысл там ваш, внутренний, просто рассыпанный по формулировкам. И когда он собирается в структуру, это каждый раз удивляет.<br /><br />Попробуйте применить этот метод к любому своему материалу — не ради разбора текста, а чтобы посмотреть на собственные знания со стороны. Важнее не документ, а то, какая структура смысла встанет за ним. Если вы заметите что-то новое о собственной системе понятий — напишите.</blockquote><h2  class="t-redactor__h2">Материалы</h2><h3  class="t-redactor__h3">📄 Исходный документ</h3><div class="t-redactor__text"><strong>Презентация Онто (<a href="https://drive.google.com/file/d/1-WyXCJsJ54byoifkq5qORQsbjD83yXpp/view">PDF</a>)</strong></div><h3  class="t-redactor__h3">🧠 RDF-модель результата</h3><div class="t-redactor__text"><strong>Экспорт онтологии (<a href="https://drive.google.com/file/d/1AxkaZmSxy0tcqoxFFqbDUHBP25x7lCGf/view">RDF</a>)</strong></div><h3  class="t-redactor__h3">🗺️ Диаграммы, созданные в Onto</h3><div class="t-redactor__text"><strong>Структура онтологии</strong></div><div class="t-redactor__text"> <a href="https://app.ontonet.ru/ru/context/736757bf-6d6a-4c64-82fa-0affe2dd3c59/diagram/93e7ed61-d68b-4c78-8981-af8ca80cbe77">https://app.ontonet.ru/ru/context/736757bf-6d6a-4c64-82fa-0affe2dd3c59/diagram/93e7ed61-d68b-4c78-8981-af8ca80cbe77</a></div><div class="t-redactor__text"><strong>От словаря к структурному контексту</strong></div><div class="t-redactor__text"> <a href="https://app.ontonet.ru/ru/context/736757bf-6d6a-4c64-82fa-0affe2dd3c59/diagram/3b48f70c-b44e-47c1-9bba-6e353ac44898">https://app.ontonet.ru/ru/context/736757bf-6d6a-4c64-82fa-0affe2dd3c59/diagram/3b48f70c-b44e-47c1-9bba-6e353ac44898</a></div><div class="t-redactor__text"><strong>Структура презентации</strong></div><div class="t-redactor__text"> <a href="https://app.ontonet.ru/ru/context/736757bf-6d6a-4c64-82fa-0affe2dd3c59/diagram/e15d453b-4413-414b-b0cf-3df47155a72a">https://app.ontonet.ru/ru/context/736757bf-6d6a-4c64-82fa-0affe2dd3c59/diagram/e15d453b-4413-414b-b0cf-3df47155a72a</a></div><div class="t-redactor__text"><strong>Страницы 1–3 (первый смысловой кластер)</strong></div><div class="t-redactor__text"> <a href="https://app.ontonet.ru/ru/context/736757bf-6d6a-4c64-82fa-0affe2dd3c59/diagram/0a59502b-1688-4e07-bef3-abdf05de06fb">https://app.ontonet.ru/ru/context/736757bf-6d6a-4c64-82fa-0affe2dd3c59/diagram/0a59502b-1688-4e07-bef3-abdf05de06fb</a></div><h3  class="t-redactor__h3">💬 Процесс работы</h3><div class="t-redactor__text"><strong>Диалог с OntoLex (<a href="https://chatgpt.com/share/69332bab-2580-8007-b173-4db89d07fa82">частичный протокол разбора презентации</a>)</strong></div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>Живая онтология процессов: от смысловой модели к автоматизации</title>
			<link>https://learning.ontonet.ru/tpost/7fxav0j7l1-zhivaya-ontologiya-protsessov-ot-smislov</link>
			<amplink>https://learning.ontonet.ru/tpost/7fxav0j7l1-zhivaya-ontologiya-protsessov-ot-smislov?amp=true</amplink>
			<pubDate>Mon, 15 Dec 2025 13:53:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>Knowledge Graphs</category>
			<category>Практика</category>
			<enclosure url="https://static.tildacdn.com/tild6130-3961-4433-b236-646638636530/Snipaste_2025-12-16_.jpg" type="image/jpeg"/>
			<turbo:content>
<![CDATA[<header><h1>Живая онтология процессов: от смысловой модели к автоматизации</h1></header><figure><img src="https://static.tildacdn.com/tild6130-3961-4433-b236-646638636530/Snipaste_2025-12-16_.jpg"/></figure><h2  class="t-redactor__h2">Введение</h2><div class="t-redactor__text">В <a href="https://ontonet.ru/learning/tpost/pc3hp0at91-semanticheskii-ritual-kak-ya-izvlekayu-s">предыдущей статье</a> я показал, как документ можно <strong>превратить в сеть смыслов</strong> и получить «живую» онтологию знаний. С помощью своего семантического ритуала я разбираю текст на термины и связи, и документ <strong>растворяется в графе</strong>, оставляя после себя осмысленную модель. Такой подход к знаниям убирает двусмысленность: ключевые понятия вынесены в онтологию, язык проекта становится частью архитектуры, и команда работает в едином контексте. В итоге сложные системы перестают зависеть от «шума» неверно понятых слов и начинают вести себя предсказуемо.</div><div class="t-redactor__text">Теперь я иду дальше и <strong>развиваю концепцию живых онтологий</strong> – на этот раз применяя её к управлению процессами. Что, если <strong>моделировать процессы так же, как семантику текста</strong>? Могу ли я описать процесс как совокупность понятий, связей и состояний – и сделать так, чтобы эта модель не лежала мёртвым грузом в документации, а реально исполнялась? Обычно процессы умирают в момент, когда их нарисовали: диаграмма живёт отдельно, реальность — отдельно, а смысл расползается между людьми и системами. <strong>Мне стало интересно: а что если процесс тоже представить как живую модель — в виде объектов, связей и состояний — и дальше исполнять именно модель, а не “сценарий в коде”?</strong></div><div class="t-redactor__text">В этой статье я покажу, как я реализовал идею: описал процесс как онтологическую модель и подключил n8n как движок, который исполняет эту модель. Внутри: минимальная метамодель, разбор реального workflow и короткий эпизод “как выполнение одной задачи активирует следующий этап”</div><img src="https://static.tildacdn.com/tild3361-6637-4237-b630-383065623036/_1.jpg"><h2  class="t-redactor__h2">Проблема: «мёртвые» процессы без смысла</h2><div class="t-redactor__text">Почему вообще возникла потребность переосмыслить моделирование процессов? Дело в том, что <strong>типичное описание бизнес-процесса мертво</strong> – диаграммы BPMN и регламенты быстро устаревают и мало связаны с реальностью. Мы рисуем красивые схемы, но они существуют отдельно от данных и смыслов, которыми живёт система. Термины на таких схемах трактуются по-разному: один считает, что «Проект» – это разработка нового продукта, другой – что это просто бюджетная статья, третий – что так называется команда исполнителей<a href="https://habr.com/ru/articles/974286/#:~:text=%D0%A1%20%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%B0%D0%BC%D0%B8%20%D1%80%D0%BE%D0%B2%D0%BD%D0%BE%20%D1%82%D0%B0%D0%BA%D0%B0%D1%8F%20%D0%B6%D0%B5,%D0%B8%D1%81%D1%82%D0%BE%D1%80%D0%B8%D1%8F">[2]</a>. В итоге каждый читает процессную диаграмму по-своему, и <strong>общего понимания нет</strong>.</div><div class="t-redactor__text">Есть и вторая боль — <strong>процессы почти никогда не связаны с данными</strong>. Схема описывает шаги и переходы, но система не может ответить на вопросы уровня инженера:</div><div class="t-redactor__text">🔹какой объект считается “готовым”?</div><div class="t-redactor__text">🔹какое состояние считается “выполнено”?</div><div class="t-redactor__text">🔹какие зависимости реально блокируют следующий этап?</div><div class="t-redactor__text">🔹какие артефакты должны появиться в системах после шага?</div><div class="t-redactor__text">Когда ответы живут “в головах” и в переписках, моделирование превращается в ритуал рисования. Процесс вроде есть, но система его “не чувствует”, а значит он бесполезен для автоматизации, наблюдаемости и — да — для AI-агентов (они наследуют всю неоднозначность).</div><div class="t-redactor__text">Кроме того, классические модели процессов не несут формального знания о предметной области. Они описывают <strong>шаги и условные переходы</strong>, но не отвечают на вопросы: <em>что значат эти шаги? почему именно такой порядок? какие понятия стоят за ролями и действиями?</em> Поэтому моделирование процессов часто превращается в рутинное рисование графиков, не влияющее на ежедневные решения. </div><div class="t-redactor__text">Процесс как бы есть на бумаге, но система его «не чувствует». Это и называется «мёртвым» процессом – он <strong>не встроен в живую модель знаний</strong>, а значит, бесполезен для AI-агентов и сложной аналитики.</div><div class="t-redactor__text">Наконец, есть практическая боль разработки: при изменениях приходится переписывать сразу <strong>код, интеграции и документацию</strong>, причём несоответствия выявляются поздно. Диаграмма может обещать одно, а сервисы в реальности реализуют другое — потому что диаграмма не является источником истины и никак не участвует в исполнении.</div><div class="t-redactor__text">Отсюда и требование, которое меня интересует: нужен процесс, который <strong>живёт в данных</strong>, а не “описан где-то”. Идеально — чтобы его можно было представить как модель, которая одновременно:</div><div class="t-redactor__text">🔹однозначно задаёт смысл (термины и связи),</div><div class="t-redactor__text">🔹отражает текущее состояние мира,</div><div class="t-redactor__text">🔹может быть исполнена/проверена автоматически.</div><div class="t-redactor__text">Дальше я покажу, как именно я попробовал это сделать через «живую онтологию процесса».</div><h2  class="t-redactor__h2">А что если процесс – это онтология?</h2><div class="t-redactor__text">Чтобы решить описанные проблемы, я попробовал сделать простой ход: <strong>вынести процесс из документов в модель</strong>, как я раньше выносил смысл из текста. То есть описывать процесс не как схему шагов, а как <strong>граф объектов и отношений</strong>, который живёт рядом с данными и обновляется вместе с ними.</div><div class="t-redactor__text">На практике это значит следующее:</div><div class="t-redactor__text">🔹Есть объект <strong>«Процесс»</strong> — как контейнер контекста.</div><div class="t-redactor__text">🔹Есть объекты <strong>«Задачи»</strong> — как атомы работы внутри процесса.</div><div class="t-redactor__text">🔹Есть связь <strong>включает</strong> (Процесс → Задача): какие задачи принадлежат процессу.</div><div class="t-redactor__text">🔹Есть связь <strong>Ход</strong> (Задача — Задача): логическая зависимость “рядом в процессе”.</div><div class="t-redactor__text">Самое важное (и это ключевой поворот): <strong>состояние задачи у меня — не поле</strong> status.</div><div class="t-redactor__text"> Состояние — это <strong>шаблон (тип объекта)</strong>.</div><div class="t-redactor__text"> То есть “Не назначена”, “Назначена”, “Выполнена” — это разные шаблоны задач, и переход между состояниями — это буквально <em>операция смены шаблона у объекта</em>.</div><blockquote class="t-redactor__quote">Почему это важно? Потому что тогда состояние становится частью онтологии:</blockquote><div class="t-redactor__text"> его можно типизировать, наследовать, связывать с другими понятиями, и — главное — <strong>его можно интерпретировать машиной одинаково каждый раз</strong>, без “чтения между строк”.</div><div class="t-redactor__text">Отдельная деталь: у связи Ход в Онто нет направления. “Направление” появляется из правила интерпретации: следующей считается та задача, которая <strong>становится доступной</strong> при выполнении соседей. В прототипе правило очень простое:</div><div class="t-redactor__text">если у задачи B есть сосед по Ход, который находится в состоянии “Выполнена”, то B можно активировать (перевести в “Назначена”).</div><div class="t-redactor__text">Это и делает модель “живой”: процесс перестаёт быть картинкой и превращается в структуру, по которой можно:</div><div class="t-redactor__text">🔹проверять консистентность (есть ли тупики/висячие задачи),</div><div class="t-redactor__text">🔹понимать текущее состояние,</div><div class="t-redactor__text">🔹и самое интересное — <strong>исполнять</strong>: менять состояния задач не руками в таблице, а автоматически по правилам модели.</div><div class="t-redactor__text">В следующих разделах я покажу минимальную метамодель (буквально 3 сущности и 2 связи) и то, как n8n выступает интерпретатором: читает граф задач и применяет переходы, меняя шаблон объектов.</div><h2  class="t-redactor__h2">Архитектура исполнения: где тут n8n</h2><div class="t-redactor__text">Идея идеей, но как сделать так, чтобы онтологический процесс <strong>действительно двигался</strong>, а не оставался “умной диаграммой”? В прототипе роль исполнителя модели у меня берёт на себя <strong>n8n</strong> — open-source платформа автоматизации. Но важная оговорка: n8n здесь не “хранит процесс” и не содержит его сценарий. Он работает как <strong>интерпретатор модели</strong>: читает текущий граф задач и применяет к нему переходы.</div><div class="t-redactor__text">У меня есть <strong>Процесс</strong>, внутри которого есть набор <strong>Задач</strong>. Каждая задача в каждый момент времени находится в одном из состояний:</div><div class="t-redactor__text">🔹<strong>Не назначена</strong> — задача существует в модели, но её ещё рано делать (она ждёт предусловий).</div><div class="t-redactor__text">🔹<strong>Назначена</strong> — задачу уже можно выполнять: она “активирована” и видна исполнителю.</div><div class="t-redactor__text">🔹<strong>Выполнена</strong> — исполнитель завершил задачу и зафиксировал это в системе.</div><div class="t-redactor__text">🔹(опционально) <strong>Финализирована</strong> — задача обработана движком и больше не участвует в продвижении. Зачем я это делаю? Что бы задачи не попадали в выборку многократно.</div><img src="https://static.tildacdn.com/tild3261-6237-4432-b135-303931346363/_2.jpg"><div class="t-redactor__text">Исполнитель в этой схеме не принципиален: это может быть человек, форма, внешний сервис — кто угодно. Важно другое: как только какая-то задача становится <strong>Выполнена</strong>, у процесса появляется шанс продвинуться дальше. Движок смотрит на связи “Ход” и переводит следующие задачи из “Не назначена” в “Назначена”. Так процесс продвигается “волной”: выполненная задача активирует следующий этап, следующий этап — следующий, и так далее.</div><div class="t-redactor__text">Технически у меня это реализовано двумя workflow.</div><div class="t-redactor__text"><strong>Workflow 1: ProcessExecutedTask — «собрать выполненные и обработать»</strong></div><div class="t-redactor__text">Этот workflow делает цикл по задачам, которые находятся в состоянии “Выполнена”.</div><div class="t-redactor__text"><ol><li data-list="ordered">Он выполняет поиск задач через Onto API: POST /entity/find/v2 с фильтром metaEntityRequest.uuid по шаблону “Выполнена” и пагинацией.</li><li data-list="ordered">Затем проходит по найденным задачам батчами.</li><li data-list="ordered">Для каждой выполненной задачи делает <strong>смену шаблона</strong>: PATCH /entity/{id}/meta → metaEntityId = на шаблон “Финализирована”.</li><li data-list="ordered">Вызывает второй workflow, передавая id текущей задачи.</li></ol></div><img src="https://static.tildacdn.com/tild3164-3264-4230-a262-326439353332/_4.jpg"><h3  class="t-redactor__h3">1) Сканируем «выполненные задачи» (ProcessExecutedTask)</h3><pre class="t-redactor__highlightcode"><code data-lang="{$la}">{
  &quot;method&quot;: &quot;POST&quot;,
  &quot;url&quot;: &quot;https://app.ontonet.ru/api/v2/core/realm/&lt;realmId&gt;/entity/find/v2&quot;,
  &quot;body&quot;: {
    &quot;name&quot;: &quot;&quot;,
    &quot;comment&quot;: &quot;&quot;,
    &quot;metaEntityRequest&quot;: {
      &quot;uuid&quot;: &quot;45c30420-8b5b-4435-8bdc-930c72abc19f&quot;
    },
    &quot;metaFieldFilters&quot;: [],
    &quot;pagination&quot;: {
      &quot;first&quot;: 0,
      &quot;offset&quot;: 100
    }
  }
}</code></pre><div class="t-redactor__text"><strong>Workflow 2: AssignTask — «активировать соседей по связи “Ход”»</strong><br /><br />Это тот кусок, где проявляется “движок процесса”.<br /><br /><ol><li data-list="ordered">Workflow принимает id задачи (из первого workflow) и запрашивает её детали вместе со связанными сущностями: GET /entity/{id}?relatedEntities=true&amp;relatedDiagrams=false.</li><li data-list="ordered">Он берёт related_entities и фильтрует соседей по двум условиям: связь должна иметь имя relationName == "Ход" + соседняя сущность должна быть в определённом шаблоне-состоянии: metaEntity.uuid по шаблону “Не назначена”.</li><li data-list="ordered">Для каждого подходящего соседа выполняется переход состояния как <strong>смена шаблона</strong>: PATCH /entity/{neighborId}/meta → metaEntityId = на шаблон “Назначена”.</li></ol></div><h3  class="t-redactor__h3">2) Активируем соседей по связи «Ход» (AssignTask)</h3><img src="https://static.tildacdn.com/tild3363-6566-4265-b462-376437383038/_5.jpg"><h4  class="t-redactor__h4">2.1 Получаем окружение задачи (связанные сущности):</h4><pre class="t-redactor__highlightcode"><code data-lang="{$la}">{
  &quot;method&quot;: &quot;GET&quot;,
  &quot;url&quot;: &quot;https://app.ontonet.ru/api/v2/core/realm/&lt;realmId&gt;/entity/{{ $json.id }}?relatedEntities=true&amp;relatedDiagrams=false&quot;
}
</code></pre><h4  class="t-redactor__h4">2.2 Фильтруем соседей: берём только Ход и только задачи в “неактивном” состоянии (UUID 1bbe…):</h4><pre class="t-redactor__highlightcode"><code data-lang="{$la}">// псевдокод фильтра в n8n (узел If)
relationName == &quot;Ход&quot; &amp;&amp;
entity.metaEntity.uuid == &quot;1bbec7ad-6373-4bcb-b085-...&quot;</code></pre><h4  class="t-redactor__h4"><strong>2.3 Переводим выбранную соседнюю задачу в состояние “Назначена” через смену шаблона:</strong></h4><pre class="t-redactor__highlightcode"><code data-lang="{$la}">{
  &quot;method&quot;: &quot;PATCH&quot;,
  &quot;url&quot;: &quot;https://app.ontonet.ru/api/v2/core/realm/&lt;realmId&gt;/entity/{{ $json.entity.id }}/meta&quot;,
  &quot;body&quot;: {
    &quot;metaEntityId&quot;: &quot;a885220e-f5bd-4cc3-8ff2-...&quot;
  }
}
</code></pre><img src="https://static.tildacdn.com/tild3630-6135-4137-b332-316631636532/_6.jpg"><div class="t-redactor__text">Если перевести это на язык модели, то получается простое правило:</div><div class="t-redactor__text">🔹выполненная задача “подсвечивает” соседей по Ход,</div><div class="t-redactor__text">🔹если сосед сейчас в “неактивном” состоянии, движок переводит его в “Назначена”.</div><div class="t-redactor__text">Это и есть ключевой момент: состояние хранится не в поле, а в выбранном шаблоне, а n8n выполняет переходы, меняя шаблон объектов через API.</div><h2  class="t-redactor__h2">Мини-кейс из прототипа: как одна выполненная задача «зажигает» следующий этап</h2><div class="t-redactor__text">Чтобы не уходить в абстракции, покажу один реальный эпизод из прототипа (он же в видео).</div><iframe width="100%" height="100%" src="https://vk.com/video_ext.php?oid=-234652823&id=456239017" frameborder="0" webkitallowfullscreen="" mozallowfullscreen="" allowfullscreen=""></iframe><div class="t-redactor__text">У меня есть процесс, внутри которого задачи связаны отношением <strong>Ход</strong> — это “логика продвижения”. Связь не направленная, поэтому “что дальше” определяется правилом интерпретации: следующими считаются те задачи, которые можно активировать после выполнения соседей.<br /><br /><strong>Сценарий</strong><br /><br /><ol><li data-list="ordered">Исполнитель (человек/форма/внешняя система — не важно) переводит <strong>одну задачу</strong> в состояние <strong>«Выполнена»</strong>.</li><li data-list="ordered">Движок (n8n) периодически/по запуску смотрит список выполненных задач и берёт одну из них в обработку.</li><li data-list="ordered">Для этой выполненной задачи он загружает окружение: все связанные сущности (related_entities).</li><li data-list="ordered">Из окружения он выбирает только связи relationName == "Ход", и только тех соседей, кто находится в “неактивном” состоянии (например, “Не назначена”).</li><li data-list="ordered">Эти соседние задачи переводятся в состояние <strong>«Назначена»</strong> — то есть становятся доступными для исполнения.</li></ol><br /><strong>Что видно в примере</strong></div><img src="https://static.tildacdn.com/tild3033-3831-4661-b530-326266626263/_3-1.jpg"><div class="t-redactor__text">В моём видео это выглядит так: после того как <strong>“Задача 3”</strong> становится выполненной, <strong>задачи 4.1–4.3</strong> (связанные с ней по Ход) автоматически переходят в <strong>“Назначена”</strong>.<br /><br />Никаких “если/то” в коде под конкретный процесс: правило одно и то же, оно просто применено к текущему графу.</div><img src="https://static.tildacdn.com/tild3138-3932-4530-b631-376161373635/_3-2.jpg"><div class="t-redactor__text"><strong>Почему это важно</strong></div><div class="t-redactor__text">Это маленький эпизод, но он показывает главное отличие подхода:</div><div class="t-redactor__text">🔹процесс задаётся <strong>моделью в графе</strong> (объекты + связи + состояния как шаблоны),</div><div class="t-redactor__text">🔹а n8n выступает <strong>интерпретатором</strong>, который делает допустимые переходы (смена шаблона у объектов) на основании текущего состояния модели.</div><div class="t-redactor__text">Именно этот разрыв — «модель первична, исполнение вторично» — и есть точка, в которой мой прототип начинает быть похожим на MBSE.</div><h2  class="t-redactor__h2">Почему это MBSE?</h2><div class="t-redactor__text">Небольшая вставка для тех, кто не сталкивался с термином. <strong>MBSE (Model-Based Systems Engineering)</strong> — это подход в инженерии сложных систем, где <strong>модель становится главным рабочим артефактом</strong>. Не “картинкой для отчёта”, а тем, вокруг чего реально строится работа: обсуждения, проверки, изменения, а иногда и генерация кода/тестов. В противоположность этому, в привычном мире у нас обычно есть разрозненные документы: требования в одном месте, схема процесса в другом, код — в третьем, и все они расходятся со временем.</div><div class="t-redactor__text">Суть MBSE можно объяснить одной фразой: <strong>“сначала формальная модель, потом всё остальное”</strong>. В хорошей MBSE-системе модель не просто описывает, как “должно быть”, а помогает проверять консистентность, находить ошибки на ранней стадии и поддерживать трассируемость (что связано с чем и почему).</div><div class="t-redactor__text">Теперь к моему кейсу. Я не использую SysML как стандарт, но принцип тот же: процесс описан как <strong>модель в графе</strong> (объекты + связи + состояния), и дальше машина работает <strong>по модели</strong>, а не по захардкоженному сценарию.</div><img src="https://static.tildacdn.com/tild3462-6465-4138-a439-313835376630/_7.jpg"><div class="t-redactor__text">В моём прототипе:</div><div class="t-redactor__text">🔹<strong>модель процесса</strong> — это граф “Процесс → задачи”, связь Ход между задачами и состояния, заданные шаблонами;</div><div class="t-redactor__text">🔹<strong>исполнение</strong> — интерпретатор (n8n), который читает текущий граф и выполняет переходы, меняя состояние задач через смену шаблона объекта.</div><div class="t-redactor__text">Отсюда следует важное: когда меняется модель (связи, типы, состояния), меняется и поведение — без переписывания сценариев. Это сокращает семантический разрыв между “как задумано” и “как работает”, и делает процесс проверяемым: можно анализировать граф, искать тупики и наблюдать реальное продвижение.</div><div class="t-redactor__text">Оговорка честно: это прототип. До “взрослого” MBSE в методологическом смысле тут ещё много шагов (валидация модели, правила для нескольких предусловий, идемпотентность/гонки). Но идея <strong>исполняемой модели</strong> уже проявилась.</div><h2  class="t-redactor__h2">Заключение: исполняемый смысл как новая норма</h2><div class="t-redactor__text">Опыт с живыми онтологиями процессов показывает, что процессы не обязательно должны быть «немыми» схемами в документации. Их можно сделать полноценными носителями смысла, которые к тому же выполняются машиной. Это шаг к новой инженерной культуре, где смысл становится исполняемым. Знания больше не пылятся в wiki или в головах отдельных экспертов — они встроены в систему и непосредственно влияют на её работу.</div><div class="t-redactor__text">Такой подход требует менять мышление. Архитектору мало нарисовать красивую диаграмму — нужно сформулировать онтологию: определить понятия, их отношения, ограничения. Зато наградой будет система, которая говорит с вами на одном языке. Когда знание превращается в активный элемент инфраструктуры (вспомним: в связке Онто + n8n я реально применяю правило модели и делаю переходы состояний задач, меняя их тип/шаблон), уходит привычный барьер между идеей и её реализацией. Решение, однажды зафиксированное в модели, сразу становится частью живого процесса.</div><div class="t-redactor__text">Мне хочется верить, что за такими исполняемыми моделями будущее — по крайней мере в тех местах, где процессы постоянно меняются, а цена семантического разрыва высока. Представьте команды, где обсуждение требований напрямую формирует онтологию, и тут же автоматика берёт её в работу. Минимум ручной рутины, максимум отслеживаемости и единый язык для людей и AI. Живые онтологии процессов — это приглашение к новой культуре разработки, где мы проектируем не набор несвязанных артефактов, а цельную систему знаний и действий. Приглашаю инженеров и разработчиков поэкспериментировать с этим подходом: возможно, он подтолкнёт нас всех к более осмысленной и управляемой автоматизации.</div><div class="t-redactor__text">P.S. Подробности реализации и наглядный эпизод “как выполнение одной задачи активирует следующий этап” — в видео в тексте статьи. Также рекомендую ознакомиться с предыдущим материалом «Семантический ритуал: как я извлекаю смысл из документов» для понимания концепции живых онтологий</div>]]>
			</turbo:content>
		</item>
		<item turbo="true">
			<title>от онтологии оливье к онтологии Деда Мороза</title>
			<link>https://learning.ontonet.ru/tpost/gjfufct731-ot-ontologii-olive-k-ontologii-deda-moro</link>
			<amplink>https://learning.ontonet.ru/tpost/gjfufct731-ot-ontologii-olive-k-ontologii-deda-moro?amp=true</amplink>
			<pubDate>Tue, 30 Dec 2025 03:23:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>AI</category>
			<category>Knowledge Graphs</category>
			<category>LLM</category>
			<category>Практика</category>
			<enclosure url="https://static.tildacdn.com/tild6331-3634-4137-a533-356135393133/image.png" type="image/png"/>
			<turbo:content>
<![CDATA[<header><h1>от онтологии оливье к онтологии Деда Мороза</h1></header><figure><img src="https://static.tildacdn.com/tild6331-3634-4137-a533-356135393133/image.png"/></figure><h2  class="t-redactor__h2">То не присказка, то сказка</h2><div class="t-redactor__text">В полночь холодильник превращается в портал.</div><div class="t-redactor__text">Не в сказку — в <strong>инвентарную реальность</strong>, где за банкой горошка живёт недоеденная надежда, а за пакетом майонеза прячется вопрос, который не задают вслух: <em>«А точно ли мы всё купили?»</em></div><div class="t-redactor__text">У нас было всё как у людей: идея «сделаем по‑простому», семейная традиция «оливье обязательно» и тайный план «в этот раз без хаоса». Но Новый год — хитрый инженер по отказам. Он знает, где у вас слабые места: в 18:40, когда уже пришли гости, внезапно выясняется, что хлеба нет, шампанское “было где‑то”, а огурцы солёные есть, но… не те. И вот вы стоите, смотрите на стол, и ощущаете себя человеком, который пытается <strong>скомпилировать праздник</strong> без зависимостей.</div><div class="t-redactor__text">Я решил сыграть иначе.</div><div class="t-redactor__text">Представьте, что новогодний стол — это фэнтези‑квест.</div><div class="t-redactor__text"> Меню — королевство.</div><div class="t-redactor__text"> Блюда — герои.</div><div class="t-redactor__text"> Ингредиенты — артефакты.</div><div class="t-redactor__text"> Остатки — древние сокровища в разных подземельях (морозилка, шкаф, ящик для овощей).</div><div class="t-redactor__text"> А закупка — список предметов, без которых финальный босс «Салат‑и‑Гости‑в‑Прихожей» не проходится.</div><div class="t-redactor__text">В обычной сказке всё держится на чуде. В нашей — на графе.</div><div class="t-redactor__text">Мы завели в Onto маленькую онтологию, чтобы она выполняла роль <strong>мапа мира</strong>, а OntoAI — роль придворного архивариуса, который не просто помнит “что надо”, а умеет связать “что надо” с “почему надо” и “где это лежит”.</div><div class="t-redactor__text">С тех пор любой объект получил паспорт:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Меню</strong> говорит: «Я включаю блюда».</li><li data-list="bullet"><strong>Блюдо</strong> говорит: «Я либо готовлюсь по рецепту, либо покупаюсь как продукт».</li><li data-list="bullet"><strong>Рецепт</strong> признаётся: «Во мне живут компоненты».</li><li data-list="bullet"><strong>Компонент</strong> честно показывает: «Мне требуется продукт».</li><li data-list="bullet"><strong>Остаток</strong> шепчет: «Я — не абстрактный “майонез”, я конкретные 100 граммов, и я хранюсь в холодильнике».</li><li data-list="bullet"><strong>Закупка</strong> сурово фиксирует: «Эти продукты нужны, потому что они требуются блюдам меню и не закрываются остатками».</li></ul></div><div class="t-redactor__text">И случилось странное: подготовка к празднику перестала быть шаманством.</div><div class="t-redactor__text">Оливье Даши с авокадо перестало быть просто “рецептом в голове” и стало узлом в сети причинности: от блюда — к рецепту — к ингредиентам — к продуктам — к остаткам — к закупке.</div><div class="t-redactor__text"> Хлеб и шампанское перестали быть “ну купим потом” и стали покупными позициями меню, которые нельзя забыть, потому что они теперь тоже часть королевства.</div><div class="t-redactor__text"> А холодильник впервые перестал быть мистическим объектом с памятью на 5 секунд — потому что память переехала в модель.</div><div class="t-redactor__text">И когда в какой-то момент граф показал:</div><div class="t-redactor__text"> «Всё для оливье есть, кроме…» —</div><div class="t-redactor__text"> я понял, что это и есть новогодняя магия нового времени: <strong>не предсказывать хаос, а моделировать его так, чтобы он не случился.</strong></div><div class="t-redactor__text">Дальше в статье я покажу:</div><div class="t-redactor__text">как мы собрали минимальную онтологию “праздничного стола”, почему без сущности “Блюдо меню” всё ломается, как отделение “Продукта” от “Остатка” спасает психику, и как из этого графа получается закупка, которую не стыдно открыть в магазине — даже когда уже играет «В лесу родилась ёлочка», а очередь напоминает DLC к Dark Souls.</div><h2  class="t-redactor__h2">Карта королевства</h2><h3  class="t-redactor__h3">0) Сначала — не «шаблоны», а вопросы к реальности</h3><div class="t-redactor__text">Любая онтология, если её не держать в ежовых рукавицах, быстро превращается в «энциклопедию всего». Поэтому мы начали не с сущностей, а с трёх вопросов, на которые модель <strong>обязана</strong> отвечать:</div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Что будет на столе?</strong> (меню: список позиций, включая “купить” и “приготовить”)</li><li data-list="ordered"><strong>Что уже есть?</strong> (остатки + где лежит)</li><li data-list="ordered"><strong>Что нужно докупить — и ради какого блюда?</strong> (закупка с объяснимостью)</li></ol></div><div class="t-redactor__text">Всё остальное (калории, нутриенты, любимые бренды и философия майонеза) — потом, если останутся силы и трезвость.</div><h3  class="t-redactor__h3">1) Самый важный поворот: «Меню ≠ список рецептов»</h3><div class="t-redactor__text">Наивная схема выглядит так:</div><div class="t-redactor__text">Меню → Рецепты → Ингредиенты → Продукты</div><div class="t-redactor__text">И она ломается ровно в тот момент, когда в меню появляется <strong>шампанское</strong> или <strong>хлеб</strong>.</div><div class="t-redactor__text"> У них нет рецепта (и не нужен), но они <strong>часть меню</strong> и должны попадать в закупку.</div><div class="t-redactor__text">Поэтому мы ввели промежуточный слой:</div><div class="t-redactor__text"><strong>Блюдо меню</strong> — сущность “позиция на столе”, которая может быть:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>приготовлена по рецепту</strong>, или</li><li data-list="bullet"><strong>куплена как готовый продукт</strong>.</li></ul></div><div class="t-redactor__text">Это маленькая вставка, которая спасает модель от странного “Рецепт: Шампанское полусладкое”.</div><h3  class="t-redactor__h3">2) Итоговый «скелет» модели: 8 шаблонов и понятные связи</h3><div class="t-redactor__text">Мы специально держали набор минимальным — ровно то, что нужно для трёх вопросов.</div><div class="t-redactor__text"><strong>Шаблоны (meta entities):</strong></div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Меню</strong></li><li data-list="bullet"><strong>Блюдо меню</strong></li><li data-list="bullet"><strong>Рецепт</strong></li><li data-list="bullet"><strong>Компонент</strong> (ингредиент <em>как объект</em>, с количеством и заметками)</li><li data-list="bullet"><strong>Продукт</strong> (тип продукта: “Авокадо”, “Майонез”, “Шоколад”…)</li><li data-list="bullet"><strong>Остаток</strong> (факт наличия конкретного количества продукта)</li><li data-list="bullet"><strong>Хранилище</strong> (холодильник/шкаф/морозилка…)</li><li data-list="bullet"><strong>Закупка</strong></li></ul></div><div class="t-redactor__text"><strong>Связи (meta relations):</strong></div><div class="t-redactor__text"><ul><li data-list="bullet">Меню → Блюдо меню: <strong>включает</strong></li><li data-list="bullet">Блюдо меню → Рецепт: <strong>приготовлено по</strong></li><li data-list="bullet">Блюдо меню → Продукт: <strong>покупается как</strong> (для “купить готовое”: хлеб, шампанское)</li><li data-list="bullet">Рецепт → Компонент: <strong>содержит</strong></li><li data-list="bullet">Компонент → Продукт: <strong>требует</strong></li><li data-list="bullet">Блюдо меню → Продукт: <strong>требуется</strong> (логистический слой: что нужно для этого блюда)</li><li data-list="bullet">Остаток → Продукт: <strong>относится к</strong></li><li data-list="bullet">Остаток → Хранилище: <strong>хранится в</strong></li><li data-list="bullet">Закупка → Продукт: <strong>требуется</strong></li><li data-list="bullet">Закупка → Меню/Блюдо меню: <strong>назначена для</strong></li></ul></div><div class="t-redactor__text">Если хочется одной картинкой, то логика такая:</div><div class="t-redactor__text">Меню ─включает→ Блюдо меню ─приготовлено по→ Рецепт ─содержит→ Компонент ─требует→ Продукт</div><div class="t-redactor__text">  │               ├─покупается как→ Продукт</div><div class="t-redactor__text">  │               └─требуется→ Продукт</div><div class="t-redactor__text">Остаток ─относится к→ Продукт</div><div class="t-redactor__text">Остаток ─хранится в→ Хранилище</div><div class="t-redactor__text">Закупка ─требуется→ Продукт</div><div class="t-redactor__text">Закупка ─назначена для→ Меню / Блюдо меню</div><img src="https://static.tildacdn.com/tild3837-3031-4634-b836-306230366338/image.png"><h3  class="t-redactor__h3">3) Что именно делали в Onto, чтобы модель стала «живой»</h3><div class="t-redactor__text">Дальше — не теория, а сборка “по месту”.</div><div class="t-redactor__text"><strong>Шаг 1. Создали объект Меню</strong></div><div class="t-redactor__text">Объект “Меню: Новогодний стол 2025” — это корневой узел, который просто <strong>перечисляет</strong> блюда.</div><div class="t-redactor__text"><strong>Шаг 2. Создали объекты Блюдо меню (позиции стола)</strong></div><div class="t-redactor__text">В меню завели 7 позиций:</div><div class="t-redactor__text"><ul><li data-list="bullet">Оливье Даши с авокадо</li><li data-list="bullet">Запечённая курица с картофелем и травами</li><li data-list="bullet">Сырные рулетики с вяленой уткой</li><li data-list="bullet">Шоколадный мусс с авокадо</li><li data-list="bullet">Канапе с красной икрой</li><li data-list="bullet">Шампанское</li><li data-list="bullet">Хлеб</li></ul></div><div class="t-redactor__text">И связали их с меню через включает.</div><img src="https://static.tildacdn.com/tild3038-3932-4739-a663-666239623235/image_2025-12-29_19-.png"><div class="t-redactor__text"><strong>Зачем так:</strong> меню — это план, а план всегда оперирует “позициями”, а не только рецептами.</div><img src="https://static.tildacdn.com/tild3639-3762-4635-b335-353938343437/image.png"><div class="t-redactor__text"><strong>Шаг 3. Отделили «готовим» от «покупаем»</strong></div><div class="t-redactor__text"><ul><li data-list="bullet">Для <strong>Хлеб</strong> и <strong>Шампанское</strong> сделали Блюдо меню → Продукт связью <strong>покупается как</strong>.</li><li data-list="bullet">Для <strong>Канапе с красной икрой</strong> тоже использовали “покупается как” (как упрощение: купили красную икру — канапе случились).</li></ul></div><div class="t-redactor__text"><strong>Зачем так:</strong> купленные позиции попадают в ту же систему, что и приготовляемые, и не требуют “фейковых рецептов”.</div><div class="t-redactor__text"><strong>Шаг 4. Для уникального блюда сделали полноценный Рецепт</strong></div><div class="t-redactor__text">Мы детально описали только один рецепт: <strong>«Оливье Даши с авокадо»</strong> — потому что он нестандартный и там важны детали.</div><div class="t-redactor__text">Создали Рецепт и связали блюдо с рецептом: приготовлено по.</div><img src="https://static.tildacdn.com/tild3666-6239-4834-b330-633137663235/image.png"><div class="t-redactor__text"><strong>Шаг 5. Сделали ингредиенты не строками, а узлами: Компонент</strong></div><div class="t-redactor__text">Вместо “майонез” текстом в поле мы завели компоненты как отдельные объекты:</div><div class="t-redactor__text"><ul><li data-list="bullet">Яйцо 4 шт</li><li data-list="bullet">Авокадо 1 шт</li><li data-list="bullet">Горошек 200 г</li><li data-list="bullet">Картофель 3 шт</li><li data-list="bullet">Майонез 150 г</li><li data-list="bullet">Морковь 2 шт</li><li data-list="bullet">Огурцы солёные 150 г</li><li data-list="bullet">Перец чёрный по вкусу</li><li data-list="bullet">Соль по вкусу</li></ul></div><div class="t-redactor__text">И связали:</div><div class="t-redactor__text"><ul><li data-list="bullet">Рецепт → Компонент (<strong>содержит</strong>)</li><li data-list="bullet">Компонент → Продукт (<strong>требует</strong>)</li></ul></div><div class="t-redactor__text"><strong>Почему так, а не “Рецепт → Продукт”:</strong></div><div class="t-redactor__text"> потому что количество (“150 г”) и пояснения (“по вкусу”) — это свойства ингредиента в контексте рецепта. Проще хранить это в узле “Компонент”, чем пытаться приклеить атрибуты к связи или городить отдельную таблицу.</div><div class="t-redactor__text"><strong>Шаг 6. Ввели Продукты как справочник типов</strong></div><div class="t-redactor__text">“Авокадо”, “Майонез”, “Шоколад”, “Сливки”, “Курица”, “Зелень”… — это <strong>типы</strong>, к которым могут относиться:</div><div class="t-redactor__text"><ul><li data-list="bullet">компоненты рецептов,</li><li data-list="bullet">остатки,</li><li data-list="bullet">закупка,</li><li data-list="bullet">покупные позиции меню.</li></ul></div><div class="t-redactor__text">Один продукт — много контекстов. И это нормально.</div><div class="t-redactor__text"><strong>Шаг 7. Собрали «инвентарь»: Хранилища и Остатки</strong></div><div class="t-redactor__text">Создали хранилища:</div><div class="t-redactor__text"><ul><li data-list="bullet">Холодильник</li><li data-list="bullet">Морозилка</li><li data-list="bullet">Шкаф</li><li data-list="bullet">Ящик для овощей</li><li data-list="bullet">Хлебница</li></ul></div><div class="t-redactor__text">И внесли остатки отдельными объектами, например:</div><div class="t-redactor__text"><ul><li data-list="bullet">Остаток: Авокадо 1 шт → (относится к Авокадо) → (хранится в Холодильник)</li><li data-list="bullet">Остаток: Картофель 5 шт → … → (хранится в Ящик для овощей)</li><li data-list="bullet">Остаток: Хлеб 1 батон → … → (хранится в Хлебница)</li><li data-list="bullet">Остаток: Перец чёрный ½ баночки → … → (хранится в Шкаф)</li></ul></div><div class="t-redactor__text"><strong>Почему “Остаток” отдельной сущностью:</strong></div><div class="t-redactor__text"> потому что “Продукт” — это тип, а “Остаток” — это <strong>факт наличия с количеством и местом</strong>. Один и тот же продукт может существовать в нескольких остатках (или партиях), а также исчезать/появляться со временем.</div><div class="t-redactor__text"><strong>Шаг 8. Собрали Закупку и сделали её объяснимой</strong></div><div class="t-redactor__text">Создали объект “Закупка Новый год 2025” и связали:</div><div class="t-redactor__text"><ul><li data-list="bullet">Закупка → Меню: <strong>назначена для</strong></li><li data-list="bullet">Закупка → Блюда меню: <strong>назначена для</strong> (чтобы видно было, какие блюда обслуживаем)</li></ul></div><div class="t-redactor__text">Дальше добавили продукты, которые надо купить:</div><div class="t-redactor__text"> сыр, мёд, курица, зелень, шоколад, сливки, красная икра, огурцы солёные…</div><div class="t-redactor__text">И вот тут важный UX-ход:</div><div class="t-redactor__text"> мы добавили <strong>прямую связь</strong> Блюдо меню → Продукт (<strong>требуется</strong>).</div><div class="t-redactor__text">То есть теперь можно открыть блюдо и сразу увидеть его “логистическую ведомость”, не бегая по рецептам (которые могут быть детализированы не для всех блюд).</div><h3  class="t-redactor__h3">4) Почему модель получилась именно такой (а не “ещё одной таблицей”)</h3><div class="t-redactor__text"><strong>1) Разделение уровней: план / знание / действие</strong></div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Блюдо меню</strong> — план (“что будет на столе”)</li><li data-list="bullet"><strong>Рецепт</strong> — знание (“как это готовить”)</li><li data-list="bullet"><strong>Закупка</strong> — действие (“что покупаем и ради чего”)</li></ul></div><div class="t-redactor__text">Это снимает вечную боль: <em>не всё, что в меню, обязано быть рецептом</em>.</div><div class="t-redactor__text"><strong>2) Два слоя ингредиентов: кулинарный и логистический</strong></div><div class="t-redactor__text"><ul><li data-list="bullet">Кулинарный: Рецепт → Компонент → Продукт (с количествами, нюансами)</li><li data-list="bullet">Логистический: Блюдо → Продукт (что надо обеспечить)</li></ul></div><div class="t-redactor__text">Так можно начинать грубо (“для мусса нужны шоколад и сливки”), а потом углублять рецепт, когда появится желание.</div><div class="t-redactor__text"><strong>3) Продукт не хранит “сколько”</strong></div><div class="t-redactor__text"> Количество живёт:</div><div class="t-redactor__text"><ul><li data-list="bullet">в <strong>Компоненте</strong> (сколько надо по рецепту),</li><li data-list="bullet">в <strong>Остатке</strong> (сколько есть и где лежит).</li></ul></div><div class="t-redactor__text">Продукт — это идентичность/тип. Благодаря этому граф не разъезжается в кашу из “майонез_100г”, “майонез_150г”, “майонез_ещё_чуть-чуть”.</div><div class="t-redactor__text"><strong>4) Трассируемость</strong></div><div class="t-redactor__text"> В закупке видно:</div><div class="t-redactor__text"><ul><li data-list="bullet">какие продукты покупаем,</li><li data-list="bullet">и для какого меню/блюд это всё.</li></ul></div><div class="t-redactor__text">Это резко снижает шанс купить “просто на всякий случай” ещё одну банку горошка, пока в шкафу уже живёт предыдущая (она просто ждала своего часа).</div><h2  class="t-redactor__h2">И вот наш верный Ланселот идёт за провизией</h2><h3  class="t-redactor__h3">1) Инструкция как контракт: что именно мы заставили OntoAI сделать</h3><div class="t-redactor__text">Ключевая идея: относиться к OntoAI не как к “чату”, а как к <strong>оператору данных</strong>, которому выдали протокол.</div><div class="t-redactor__text">В протоколе было два важных технических требования:</div><div class="t-redactor__text"><strong>A. Полная выгрузка данных по шаблонам (meta entities)</strong></div><div class="t-redactor__text"> Для каждого шаблона (“Меню”, “Блюдо меню”, “Рецепт”, “Компонент”, “Продукт”, “Остаток”, “Хранилище”, “Закупка”) — пройтись find/v2 постранично, пока не выгрузим всё.</div><div class="t-redactor__text"><strong>B. Для каждого объекта — выгрузить связи и поля</strong></div><div class="t-redactor__text"> Для каждого entity — дернуть GET ... entity/{id}?relatedEntities=true&amp;relatedDiagrams=true и вытащить:</div><div class="t-redactor__text"><ul><li data-list="bullet">fields (количество, комментарии, “способ получения” и т.д.)</li><li data-list="bullet">related_entities (включает/приготовлено по/требует/покупается как/относится к/хранится в).</li></ul></div><div class="t-redactor__text">Это важно: без “relatedEntities=true” вы получаете “мешок объектов”, а нам нужен <strong>граф</strong>.</div><h3  class="t-redactor__h3">2) Шаг нулевой: OntoAI нашёл UUID всех шаблонов</h3><div class="t-redactor__text">Первое, что сделал OntoAI — по именам нашёл UUID всех meta entities в пространстве “Кейс Новый год” (realmId указан в инструкции). Это техническая деталь, но она позволяет дальше работать через API детерминированно: любой объект можно точно адресовать.</div><h3  class="t-redactor__h3">3) Меню как план: что будет на столе</h3><div class="t-redactor__text">Дальше OntoAI выгрузил объект:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Меню: “Новогодний стол 2025”</strong></li></ul></div><div class="t-redactor__text">И вытащил из него все связи включает → <strong>Блюдо меню</strong>. Получилось 6 позиций:</div><div class="t-redactor__text"><ol><li data-list="ordered">Хлеб</li><li data-list="ordered">Шампанское</li><li data-list="ordered">Шоколадный мусс с авокадо</li><li data-list="ordered">Сырные рулетики с вяленой уткой</li><li data-list="ordered">Запечённая курица с картофелем и травами</li><li data-list="ordered">Оливье Даши с авокадо</li></ol></div><div class="t-redactor__text">Дальше — важная классификация:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>“Хлеб”</strong> и <strong>“Шампанское”</strong> помечены как <em>покупаются как продукт</em> (то есть без рецепта).</li><li data-list="bullet"><strong>“Оливье Даши с авокадо”</strong> — <em>приготовлено по рецепту</em>.</li><li data-list="bullet">Остальные три — “домашние” блюда (в этом прогоне без подробных рецептов).</li></ul></div><div class="t-redactor__text">Это как раз демонстрирует, почему в модели нужен слой <strong>“Блюдо меню”</strong>: он одинаково хорошо держит и приготовляемые, и покупные позиции.</div><h3  class="t-redactor__h3">4) Рецепт и ингредиенты: раскрутка цепочки “Рецепт → Компонент → Продукт”</h3><div class="t-redactor__text">В пространстве был один детализированный рецепт:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Рецепт: “Оливье Даши с авокадо”</strong></li></ul></div><div class="t-redactor__text">OntoAI выгрузил его компоненты и для каждого компонента показал, какой <strong>Продукт</strong> он “требует”. Получилось 9 продуктовых типов:</div><div class="t-redactor__text"><ul><li data-list="bullet">Авокадо</li><li data-list="bullet">Горошек зелёный</li><li data-list="bullet">Картофель</li><li data-list="bullet">Майонез</li><li data-list="bullet">Морковь</li><li data-list="bullet">Огурцы солёные</li><li data-list="bullet">Перец чёрный</li><li data-list="bullet">Соль</li><li data-list="bullet">Яйцо куриное</li></ul></div><div class="t-redactor__text">То есть “рецепт” в графе перестал быть текстом и стал <strong>структурой</strong>, по которой можно ходить и делать выводы.</div><h3  class="t-redactor__h3">5) Остатки как факты: что уже есть и где оно лежит</h3><div class="t-redactor__text">После этого OntoAI выгрузил все сущности типа <strong>Остаток</strong> и собрал нормальную “инвентарную таблицу” (продукт, количество, хранилище, комментарий). В текущих остатках оказалось 12 позиций:</div><div class="t-redactor__text">Шампанское</div><img src="https://static.tildacdn.com/tild6361-3338-4836-b830-323231396232/image.png"><img src="https://static.tildacdn.com/tild3834-3536-4834-a563-383666636562/image.png"><h3  class="t-redactor__h3">6) Сопоставление меню и остатков: чего не хватает</h3><div class="t-redactor__text">Дальше OntoAI сделал то, ради чего всё это затевалось: сверил потребности блюд (по рецептам и “логистическим” продуктам) с остатками.</div><div class="t-redactor__text">По итогам сравнения в закупку ушло следующее:</div><div class="t-redactor__text"><strong>Недостающее по блюдам:</strong></div><div class="t-redactor__text"><ul><li data-list="bullet">Оливье Даши с авокадо → <strong>Огурцы солёные</strong></li><li data-list="bullet">Запечённая курица с картофелем и травами → <strong>Курица</strong>, <strong>Зелень</strong></li><li data-list="bullet">Сырные рулетики с вяленой уткой → <strong>Сыр</strong>, <strong>Мёд</strong></li><li data-list="bullet">Шоколадный мусс с авокадо → <strong>Шоколад</strong>, <strong>Сливки</strong></li></ul></div><div class="t-redactor__text">И тут случилась реальность: ты напомнил про красную икру.</div><div class="t-redactor__text">OntoAI:</div><div class="t-redactor__text"><ul><li data-list="bullet">создал <strong>Продукт “Красная икра”</strong></li><li data-list="bullet">добавил <strong>Блюдо меню “Канапе с красной икрой”</strong></li><li data-list="bullet">связал блюдо с продуктом через <strong>покупается как</strong></li><li data-list="bullet">и так как остатков нет — автоматически включил икру в закупку.</li></ul></div><div class="t-redactor__text">В результате финальный список покупок стал таким:</div><img src="https://static.tildacdn.com/tild3237-3962-4632-b564-386132306662/image.png"><div class="t-redactor__text">И вот почему</div><img src="https://static.tildacdn.com/tild6134-3538-4933-b032-383664343837/image.png"><div class="t-redactor__text">(Это уже тот вид, который не стыдно показывать человеку в магазине: “что купить” + “зачем”, ну или настроить интеграцию с сетью магазинов.)</div><h3  class="t-redactor__h3">7) Главное: закупка стала объектом в Onto, а не просто текстом</h3><div class="t-redactor__text">После отчёта OntoAI <strong>создал</strong> сущность:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>“Закупка Новый год 2025”</strong></li></ul></div><div class="t-redactor__text">И добавил в граф сразу три слоя связей:</div><div class="t-redactor__text"><ol><li data-list="ordered">Закупка → Продукт связью <strong>требуется</strong></li><li data-list="ordered">Закупка → Блюдо меню связью <strong>назначена для</strong> (это “объяснимость” закупки)</li><li data-list="ordered">по твоему требованию: Блюдо меню → Продукт связью <strong>требуется</strong> (это “локальная ведомость” прямо на карточке блюда)</li></ol></div><div class="t-redactor__text">Почему пункт 3 важен: иначе закупка “всё знает”, но блюдо “само по себе” — нет.</div><div class="t-redactor__text"> А так открываешь “Шоколадный мусс” и сразу видишь: <em>шоколад и сливки требуются</em>, без прыжков через сущность “Закупка”.</div><div class="t-redactor__text">В процессе можно и фантазировать </div><img src="https://static.tildacdn.com/tild6263-6638-4934-a330-633837613636/image.png"><div class="t-redactor__text">И все равно получить нужный результат</div><img src="https://static.tildacdn.com/tild3030-6536-4634-a263-636530343231/image.png"><h3  class="t-redactor__h3">8) Полезная честность: текущая логика сравнения пока “булевая”</h3><div class="t-redactor__text">В этом прогоне сравнение работало по принципу <strong>есть/нет</strong>.</div><div class="t-redactor__text"> То есть “100 г майонеза” считается как “майонез есть”, даже если в рецепте “150 г”. Аналогично “утка 100 г — впритык” пока не превращается автоматически в “докупи ещё 100 г”.</div><div class="t-redactor__text">Это не баг онтологии — это просто следующий уровень: <strong>парсинг количеств + сравнение чисел + пороги (“впритык”)</strong>. Хорошая новость: структура уже готова, добавляется только вычислительный слой.</div><h2  class="t-redactor__h2">Заключение: от онтологии оливье к онтологии Деда Мороза</h2><div class="t-redactor__text">В какой-то момент я поймал себя на мысли: мы не «готовили Новый год». Мы <strong>компилировали</strong> его.</div><div class="t-redactor__text">Сначала была простая цель — чтобы оливье не стало лотереей «угадай, чего не хватит». Потом появился граф, и внезапно выяснилось, что праздничный стол — это не хаос, а очень даже приличная система с зависимостями, типами сущностей и причинно‑следственными связями.</div><div class="t-redactor__text">И вот тут случился главный сюжетный твист этой предпраздничной сказки:</div><div class="t-redactor__text"> <strong>онтология оливье</strong> оказалась gateway‑drug.</div><div class="t-redactor__text">Потому что если вы однажды честно смоделировали:</div><div class="t-redactor__text"><ul><li data-list="bullet">что меню <em>включает</em> блюда,</li><li data-list="bullet">блюдо <em>готовится по рецепту</em> или <em>покупается как продукт</em>,</li><li data-list="bullet">рецепт <em>содержит</em> компоненты,</li><li data-list="bullet">компоненты <em>требуют</em> продукты,</li><li data-list="bullet">остатки <em>хранятся в</em> шкафу (и это тоже важно!),</li><li data-list="bullet">а закупка <em>требуется потому что</em>…</li></ul></div><div class="t-redactor__text">…то остановиться уже сложно.</div><div class="t-redactor__text">Следующий уровень — <strong>онтология Деда Мороза</strong>.</div><div class="t-redactor__text">Представьте, как оно ложится:</div><div class="t-redactor__text"><ul><li data-list="bullet"><strong>Дед Мороз</strong> — актор, который <em>доставляет</em> <strong>Подарки</strong></li><li data-list="bullet"><strong>Подарок</strong> <em>назначен для</em> <strong>Получателя</strong></li><li data-list="bullet"><strong>Получатель</strong> <em>имеет ограничения</em> (возраст, интересы, «не дарить снова носки»)</li><li data-list="bullet"><strong>Подарок</strong> <em>требует</em> <strong>Бюджет</strong> и <em>хранится в</em> <strong>Шкафу</strong>, пока не настало 00:00</li><li data-list="bullet"><strong>Событие “Новый год”</strong> <em>включает</em> тосты, салаты и обязательное «ой, мы забыли батарейки»</li><li data-list="bullet"><strong>Батарейки</strong> — вечный архетип недостающей зависимости, которая рушит магию на ровном месте</li></ul></div><div class="t-redactor__text">И где-то там, в правом верхнем углу диаграммы, будет красным мигать узел:</div><div class="t-redactor__text">«Подарок: радиоуправляемая штука» → <em>требует</em> → «AA батарейки»</div><div class="t-redactor__text"> Остаток: батарейки → <strong>нет</strong></div><div class="t-redactor__text"> Закупка → <strong>срочно</strong></div><div class="t-redactor__text">Праздник спасён. Граф не врёт.</div><div class="t-redactor__text"><strong>Что я понял по итогам</strong></div><div class="t-redactor__text"><ol><li data-list="ordered"><strong>Онтология — адов труд, конечно</strong>, если пытаться “описать мир”.</li><li data-list="ordered"> Но если описывать <strong>сценарий</strong> (меню/остатки/закупка), она становится удивительно прикладной.</li><li data-list="ordered">Минимальная модель выигрывает у “идеальной”.</li><li data-list="ordered"> Мы не строили «вселенную еды». Мы построили систему, которая отвечает на конкретные вопросы и помогает не бегать по магазину как NPC в панике.</li><li data-list="ordered">“Объяснимость” важнее “автоматизации”.</li><li data-list="ordered"> Список покупок без «зачем» — это просто список.</li><li data-list="ordered"> Закупка, привязанная к блюдам — это уже план, а плану доверяют.</li></ol></div><div class="t-redactor__text"><strong>Финальное волшебство</strong></div><div class="t-redactor__text">В прошлой реальности перед праздником было два состояния:</div><div class="t-redactor__text"><ul><li data-list="bullet">«вроде всё купили»</li><li data-list="bullet">«почему нет огурцов?»</li></ul></div><div class="t-redactor__text">В новой реальности появился третий режим — <strong>спокойствие</strong>, потому что теперь:</div><div class="t-redactor__text"><ul><li data-list="bullet">холодильник перестал быть тайной комнатой,</li><li data-list="bullet">шкаф перестал быть архивом забытых банок,</li><li data-list="bullet">а закупка стала не “набором хотелок”, а выводом из модели.</li></ul></div><div class="t-redactor__text">И да — если кто-то скажет, что онтология оливье звучит странно, вы можете ответить максимально научно:</div><div class="t-redactor__text">«Странно не то, что мы сделали онтологию оливье.</div><div class="t-redactor__text"> Странно, что до сих пор никто не сделал онтологию мандаринов».</div><h2  class="t-redactor__h2">Поздравление</h2><div class="t-redactor__text">Пусть в новом году у вас:</div><div class="t-redactor__text"><ul><li data-list="bullet">не будет циклических зависимостей типа «праздник требует настроения, настроение требует праздника»,</li><li data-list="bullet">остатки всегда будут консистентны,</li><li data-list="bullet">закупка — минимальна, но достаточна,</li><li data-list="bullet">а Дед Мороз приносит подарки без missing‑dependencies.</li></ul></div><div class="t-redactor__text">С наступающим!</div><div class="t-redactor__text"> Пусть ваш Новый год будет как хороший граф: связный, красивый и без неожиданных “огурцов не найдено”. 🎄🥂</div><iframe width="100%" height="100%" src="https://vk.com/video_ext.php?oid=-234652823&id=456239018" frameborder="0" webkitallowfullscreen="" mozallowfullscreen="" allowfullscreen=""></iframe>]]>
			</turbo:content>
		</item>
		<item turbo="false">
			<link>https://learning.ontonet.ru/tpost/co7nsgdxg1-tsifrovoe-solntse-chast-1</link>
		</item>
		<item turbo="true">
			<title>Инженерное знание как код: зачем я связываю MCP, агентов и модель изменений</title>
			<link>https://learning.ontonet.ru/tpost/r8dlesip81-inzhenernoe-znanie-kak-kod-zachem-ya-svy</link>
			<amplink>https://learning.ontonet.ru/tpost/r8dlesip81-inzhenernoe-znanie-kak-kod-zachem-ya-svy?amp=true</amplink>
			<pubDate>Thu, 07 May 2026 14:37:00 +0300</pubDate>
			<author>Артём Варкулевич</author>
			<category>AI</category>
			<category>Knowledge Graphs</category>
			<category>LLM</category>
			<enclosure url="https://static.tildacdn.com/tild6239-3539-4936-b330-383534613864/magnific__wide-heade.jpg" type="image/jpeg"/>
			<description>На примере разработки агентской памяти показываю, как User Story превращается в граф ролей, целей, мотивов, API и зависимостей, а агент перестаёт быть «чатиком сбоку» и становится участником инженерного процесса.</description>
			<turbo:content>
<![CDATA[<header><h1>Инженерное знание как код: зачем я связываю MCP, агентов и модель изменений</h1></header><figure><img src="https://static.tildacdn.com/tild6239-3539-4936-b330-383534613864/magnific__wide-heade.jpg"/></figure><h2  class="t-redactor__h2">От чата с агентом к графу изменений: как я перестроил проектирование фич</h2><div class="t-redactor__text">В какой-то момент мой процесс разработки начал упираться не в код, а в проектирование изменений.</div><div class="t-redactor__text">Код тоже сопротивляется, конечно. Он вообще не подарок: положишь одно поле не туда — и через неделю у тебя уже маленький архитектурный цирк с пони и грустным API. Но главная сложность оказалась раньше — в моменте, когда изменение ещё только формулируется.</div><div class="t-redactor__text">Фича звучит просто, пока её не начинают реализовывать.</div><div class="t-redactor__text">Пользовательская история кажется очевидной, пока не появляются роли, состояния, исключения, интерфейсы, API, ограничения, тесты и зависимости.</div><div class="t-redactor__text">Задача выглядит маленькой, пока не выясняется, что она затрагивает сразу несколько слоёв системы.</div><div class="t-redactor__text">Именно для этого я изначально и делал <strong>Онто</strong> — как инструмент управления сложностью при проектировании изменений.</div><div class="t-redactor__text">Не как канбан.</div><div class="t-redactor__text">Не как очередную доску.</div><div class="t-redactor__text">Не как трекер задач с красивыми связями.</div><div class="t-redactor__text">Мне нужна была среда, в которой изменение можно сначала сделать видимым: через объекты, связи, роли, состояния, сценарии и контекст. А уже потом отдавать его в реализацию — человеку, команде или агенту.</div><h3  class="t-redactor__h3">Это не канбан и не процессный трекер</h3><div class="t-redactor__text">Важно сразу развести понятия.</div><div class="t-redactor__text">Онто — это среда свободного моделирования. В ней можно описывать предметную область: объекты, связи, роли, состояния, контексты и правила работы с ними. А уже поверх такой модели можно собирать разные сценарии: управление изменениями, цифровой двойник, исследовательскую базу знаний, структуру компании, продуктовую линейку или автоматизацию сбора данных.</div><div class="t-redactor__text">В этой статье я показываю только один конкретный кейс: как я использую платформу для проектирования изменений в разработке ПО.</div><div class="t-redactor__text">Не потому что она предназначена только для этого.</div><div class="t-redactor__text">А потому что проектирование изменений — хороший пример сложной задачи, где быстро становится видно ценность модели.</div><div class="t-redactor__text">Канбан показывает движение карточек.</div><div class="t-redactor__text">Модель показывает устройство смысла.</div><div class="t-redactor__text">И это разные сущности. Одна помогает понять, <em>что едет дальше</em>. Другая — <em>почему оно вообще существует, с чем связано и что сломает по дороге</em>.</div><img src="https://static.tildacdn.com/tild3730-3435-4939-a564-346165376536/b244b0ba2fc1ebbbc31f.png"><div class="t-redactor__text">мы моделируем не карточки, а смысл изменения</div><h3  class="t-redactor__h3">От модели данных к модели действий</h3><div class="t-redactor__text">Идея связывать данные, модель, действия и агентов уже становится заметной архитектурной линией в индустрии.</div><div class="t-redactor__text">Например, в <a href="https://www.palantir.com/docs/foundry/ontology/overview/" target="_blank" rel="nofollow noreferrer noopener">документации Palantir Foundry Ontology</a> онтология описывается не как обычный каталог данных или схема, а как операционный слой организации. Она связывает цифровые активы платформы с объектами реального мира — оборудованием, продуктами, заказами, транзакциями и другими сущностями. Внутри этой рамки есть не только семантические элементы — объекты, свойства и связи, — но и «кинетические» элементы: действия, функции и динамическая безопасность. (<a href="https://www.palantir.com/docs/foundry/ontology/overview/" target="_blank" rel="nofollow noreferrer noopener">Palantir</a>)</div><div class="t-redactor__text">Это важный сдвиг.</div><div class="t-redactor__text">Модель перестаёт быть справочником и становится средой, через которую можно действовать.</div><div class="t-redactor__text">В архитектурном описании Palantir эта мысль формулируется ещё шире: онтологическая система объединяет данные, логику, действия и безопасность в представление, пригодное для принятия решений, а язык онтологии моделирует «существительные» и «глаголы» операционных процессов так, чтобы они были понятны людям и агентам. (<a href="https://palantir.com/docs/foundry/architecture-center/aip-architecture/" target="_blank" rel="nofollow noreferrer noopener">Palantir</a>)</div><div class="t-redactor__text">Мне близка именно эта рамка: инженерная модель должна описывать не только то, <strong>что есть</strong>, но и то, <strong>что с этим можно делать</strong>.</div><div class="t-redactor__text">В моём случае я двигаюсь к этой логике через свободное моделирование, агентский бутстрап, MCP и собственный техпроцесс разработки.</div><h3  class="t-redactor__h3">Что изменилось после появления MCP</h3><div class="t-redactor__text">Раньше агент был для меня в основном собеседником. Он мог рассуждать, предлагать варианты, помогать формулировать решения, но всё равно оставался где-то рядом с системой.</div><div class="t-redactor__text">После появления полноценного MCP ситуация изменилась.</div><div class="t-redactor__text">Агент получил доступ не только к текстовому контексту, но и к самой модели: объектам, связям, шаблонам, полям, состояниям и метауровню. Теперь он может не просто обсуждать изменение, а работать с его структурой: находить связанные элементы, предлагать новые связи, проверять недостающие части модели и фиксировать результат в графе.</div><div class="t-redactor__text">Это резко изменило мою продуктивность при проектировании изменений.</div><div class="t-redactor__text">Но MCP сам по себе не делает процесс управляемым. Он только открывает доступ к возможностям. Если дать агенту доступ к хаосу, он будет очень бодро автоматизировать хаос. Маленький цифровой енот с гаечным ключом и полной уверенностью в глазах.</div><div class="t-redactor__text">Предсказуемость появляется только в связке:</div><div class="t-redactor__text">— модель удерживает сложность;</div><div class="t-redactor__text">— MCP даёт агенту доступ к этой структуре;</div><div class="t-redactor__text">— агентский бутстрап задаёт правила анализа;</div><div class="t-redactor__text">— техпроцесс определяет, когда результат можно считать готовым.</div><div class="t-redactor__text">Именно последнего пункта часто не хватает в разговорах про агентную разработку.</div><h3  class="t-redactor__h3">Реальная работа идёт в чате с агентом</h3><div class="t-redactor__text">В этом кейсе реальная работа с изменением велась не на диаграмме и не в абстрактном списке задач.</div><div class="t-redactor__text">Она велась в чате с агентом бизнес-аналитиком.</div><div class="t-redactor__text">Чат здесь — не просто место для разговора. Это рабочая поверхность проектирования изменения.</div><div class="t-redactor__text">Я формулирую идею.</div><div class="t-redactor__text">Агент уточняет смысл.</div><div class="t-redactor__text">Проверяет термины.</div><div class="t-redactor__text">Предлагает варианты связей.</div><div class="t-redactor__text">Задаёт вопросы про роли, цели, мотивы и зависимости.</div><div class="t-redactor__text">Выявляет места, где смысл ещё не разобран.</div><div class="t-redactor__text">И только после этого помогает зафиксировать результат в модели.</div><div class="t-redactor__text">Но агент делает это не свободно «как получится», а в рамках принципов работы с изменениями, которые заложены в агентский бутстрап.</div><div class="t-redactor__text">Бутстрап задаёт ему рамку:</div><div class="t-redactor__text">— как разбирать изменение;</div><div class="t-redactor__text">— какие сущности искать;</div><div class="t-redactor__text">— какие вопросы задавать;</div><div class="t-redactor__text">— какие связи фиксировать;</div><div class="t-redactor__text">— когда считать смысл недостаточно прояснённым;</div><div class="t-redactor__text">— что можно передавать дальше в разработку;</div><div class="t-redactor__text">— какие артефакты должны быть подготовлены.</div><div class="t-redactor__text">Поэтому агент не просто общается. Он ведёт изменение через заданный аналитический сценарий.</div><div class="t-redactor__text">Именно здесь появляется предсказуемость. Не потому что LLM стала безошибочной, а потому что её действия ограничены структурой, словарём, правилами и техпроцессом.</div><img src="https://static.tildacdn.com/tild3061-3565-4939-b563-393966643237/5d30472d1b790fc04802.png"><h3  class="t-redactor__h3">Диаграмма — это не место работы, а след работы</h3><div class="t-redactor__text">Диаграмма в этом процессе важна, но не как место, где происходит основная работа.</div><div class="t-redactor__text">Она становится способом увидеть уже собранную структуру: какие сущности появились, как они связаны и где ещё остались смысловые разрывы.</div><div class="t-redactor__text">Цепочка выглядит так:</div><div class="t-redactor__text"><strong>разговор → уточнение смысла → структурирование → создание объектов и связей → визуализация графа.</strong></div><div class="t-redactor__text">Это важное отличие.</div><div class="t-redactor__text">Если сказать, что мы «работаем на диаграмме», читатель легко решит, что речь про визуальную доску для проектирования фич. Но это не так.</div><div class="t-redactor__text">Мы работаем с изменением через агента.</div><div class="t-redactor__text">А граф становится памятью, моделью и визуальным представлением результата.</div><h3  class="t-redactor__h3">Пример: агентская память</h3><div class="t-redactor__text">Хороший пример — наша работа с Claude над одной из фич: агентской памятью.</div><div class="t-redactor__text">На первый взгляд идея простая: агент должен не терять контекст между сессиями и уметь восстанавливать рабочее состояние.</div><div class="t-redactor__text">Но как только начинаешь проектировать это всерьёз, появляются вопросы:</div><div class="t-redactor__text">— что именно считать памятью;</div><div class="t-redactor__text">— где хранится контекст;</div><div class="t-redactor__text">— какая часть памяти относится к объекту;</div><div class="t-redactor__text">— какая — к сессии;</div><div class="t-redactor__text">— как отличать актуальное знание от устаревшего;</div><div class="t-redactor__text">— как агент должен искать по памяти;</div><div class="t-redactor__text">— как не превратить память в свалку красиво оформленного мусора.</div><div class="t-redactor__text">И вот здесь работа с агентом бизнес-аналитиком оказалась особенно полезной.</div><div class="t-redactor__text">Мы начали не с реализации. Мы начали с разговора о смысле.</div><div class="t-redactor__text">Что должен помнить агент?</div><div class="t-redactor__text">Почему это важно пользователю?</div><div class="t-redactor__text">Какая сущность является центром истории?</div><div class="t-redactor__text">Что является мотивом?</div><div class="t-redactor__text">Что является целью?</div><div class="t-redactor__text">Какая роль действует в сценарии?</div><div class="t-redactor__text">Какие связи должны появиться в графе?</div><div class="t-redactor__text">Агент помог разложить изменение на элементы модели и не потерять смысл в комментариях к задаче.</div><h3  class="t-redactor__h3">Мотив нельзя оставлять в комментарии</h3><div class="t-redactor__text">Один из показательных моментов — обсуждение мотива User Story.</div><div class="t-redactor__text">Можно было оставить мотив в текстовом описании. Но если мотив является смысловым центром истории, его нельзя терять в комментарии.</div><div class="t-redactor__text">В графе он должен стать отдельной сущностью или явно выраженной связью. Иначе агент, разработчик или тестировщик каждый раз будут заново восстанавливать его из текста.</div><div class="t-redactor__text">Это кажется мелочью, но именно из таких мелочей и складывается качество проектирования.</div><div class="t-redactor__text">В формуле User Story «я как X хочу Y, чтобы Z» элемент Z часто называют целью, выгодой, потребностью или мотивом. Эти понятия близкие, но не одинаковые.</div><div class="t-redactor__text">Цель — к чему стремится персона.</div><div class="t-redactor__text">Выгода — что она получает.</div><div class="t-redactor__text">Потребность — чего ей не хватает.</div><div class="t-redactor__text">Мотив — почему она вообще действует.</div><div class="t-redactor__text">Если смешать их в одну сущность, модель быстро станет мутной. А мутная модель — это когда агент вроде бы всё понял, но почему-то делает не то. Классика жанра: маленький семантический енот уже снова в проводке.</div><img src="https://static.tildacdn.com/tild6362-6338-4532-b936-386139313931/b85342427f3248dffffa.png"><h3  class="t-redactor__h3">User Story как граф, а не строка текста</h3><div class="t-redactor__text">В онтологическом подходе User Story перестаёт быть просто строкой вида «я как X хочу Y, чтобы Z».</div><div class="t-redactor__text">Она раскладывается на граф:</div><div class="t-redactor__text">— роль пользователя;</div><div class="t-redactor__text">— персона;</div><div class="t-redactor__text">— мотив;</div><div class="t-redactor__text">— цель;</div><div class="t-redactor__text">— фича;</div><div class="t-redactor__text">— сценарий;</div><div class="t-redactor__text">— шаги;</div><div class="t-redactor__text">— архитектурные элементы;</div><div class="t-redactor__text">— API;</div><div class="t-redactor__text">— задачи разработки;</div><div class="t-redactor__text">— тестовые ожидания.</div><div class="t-redactor__text">Текст остаётся удобным интерфейсом для человека. Но рабочим носителем смысла становится граф.</div><div class="t-redactor__text">Это важно, потому что текст сложно проверять автоматически. Граф можно анализировать.</div><div class="t-redactor__text">Можно увидеть, у каких историй нет мотива.</div><div class="t-redactor__text">Какие фичи не связаны с пользовательской потребностью.</div><div class="t-redactor__text">Какие задачи не привязаны к сценарию.</div><div class="t-redactor__text">Какие изменения затрагивают один и тот же API.</div><div class="t-redactor__text">Какие элементы модели давно не пересматривались.</div><div class="t-redactor__text">Где возникла блокирующая зависимость.</div><div class="t-redactor__text">Для пользователя это означает меньше хаоса в развитии продукта.</div><div class="t-redactor__text">Для команды — меньше ситуаций, когда задача выглядит понятной только тому, кто её придумал.</div><img src="https://static.tildacdn.com/tild3566-3932-4265-b534-643831353662/b85342427f3248dffffa.png"><h3  class="t-redactor__h3">Почему агентная разработка стала возможной</h3><div class="t-redactor__text">Я не считаю, что агенты полезны потому, что LLM внезапно научились идеально писать код.</div><div class="t-redactor__text">Они не научились.</div><div class="t-redactor__text">Люди, кстати, тоже не научились.</div><div class="t-redactor__text">Агентная разработка стала для меня рабочей не из-за безошибочности моделей, а из-за того, что вокруг разработки уже был выстроен достаточно зрелый техпроцесс.</div><div class="t-redactor__text">У нас изменение не уходит в работу сразу после идеи. Сначала оно проходит через разбор смысла: зачем это нужно, кому это нужно, какие сценарии затрагиваются, какие сущности меняются, какие связи появляются, какие ограничения есть, как это будет проверяться.</div><div class="t-redactor__text">Агент в этом процессе не заменяет инженера. Он становится участником технологической цепочки.</div><div class="t-redactor__text">Он может работать как аналитик.</div><div class="t-redactor__text">Может проверять связность модели.</div><div class="t-redactor__text">Может готовить документацию.</div><div class="t-redactor__text">Может смотреть на изменение с позиции разработки.</div><div class="t-redactor__text">Может помогать QA-агенту понять, что именно нужно проверять.</div><div class="t-redactor__text">Может сформировать дайджест изменений.</div><div class="t-redactor__text">Но он делает это не из пустоты. Он действует в рамках бутстрапа и модели.</div><div class="t-redactor__text">Именно поэтому результат становится воспроизводимым.</div><h3  class="t-redactor__h3">Где здесь пользовательская выгода</h3><div class="t-redactor__text">На поверхности может показаться, что это внутренняя история разработки платформы.</div><div class="t-redactor__text">Ну подумаешь, автор научился дружить модель, MCP и агентов. Милый инженерный зоопарк.</div><div class="t-redactor__text">Но пользовательская польза здесь прямая.</div><div class="t-redactor__text">Если продукт развивается через модель, а не через набор несвязанных фич, пользователь получает более устойчивую систему.</div><div class="t-redactor__text">Новые возможности не появляются как случайные кнопки.</div><div class="t-redactor__text">Они встраиваются в общую логику.</div><div class="t-redactor__text">Интерфейс, API, MCP, OntoAI, OntoGPTs и внутренний ассистент начинают опираться на одни и те же сущности.</div><div class="t-redactor__text">Документация меньше расходится с реальностью.</div><div class="t-redactor__text">Рефакторинг становится безопаснее, потому что зависимости видны заранее.</div><div class="t-redactor__text">Агентная работа становится предсказуемее, потому что агент действует не в пустоте, а в модели.</div><div class="t-redactor__text">Для меня это и есть главный эффект: <strong>изменение становится понятным до реализации</strong>.</div><div class="t-redactor__text">Мы не отдаём в работу сырой смысл.</div><div class="t-redactor__text">Сначала он проходит через разговор, агентский разбор и модель.</div><div class="t-redactor__text">И только потом становится задачей, сценарием, API, интерфейсом или тестом.</div><h3  class="t-redactor__h3">Что даёт MCP именно в этой связке</h3><div class="t-redactor__text">MCP дал агентам доступ к модели. Но предсказуемость появилась не из-за MCP самого по себе.</div><div class="t-redactor__text">MCP — это интерфейс к возможностям.</div><div class="t-redactor__text">Техпроцесс — это ограничитель и направляющая.</div><div class="t-redactor__text">Граф показывает, где агент находится.</div><div class="t-redactor__text">Шаблоны задают типы объектов.</div><div class="t-redactor__text">Связи задают грамматику.</div><div class="t-redactor__text">Состояния задают допустимые переходы.</div><div class="t-redactor__text">Критерии качества задают проверку результата.</div><div class="t-redactor__text">В итоге агентная разработка становится не «поговорили с моделью и надеемся», а воспроизводимым инженерным циклом.</div><div class="t-redactor__text">И здесь появляется главный сдвиг: агент перестаёт быть отдельным чатиком сбоку от процесса. Он становится участником технологической цепочки.</div><div class="t-redactor__text"><strong>Разговор → семантика → модель → документация → реализация → проверка.</strong></div><div class="t-redactor__text">Каждый шаг становится менее ручным и менее хрупким.</div><div class="t-redactor__text">Похожая архитектурная логика видна в <a href="https://www.palantir.com/docs/foundry/ontology-mcp/overview" target="_blank" rel="nofollow noreferrer noopener">Palantir Ontology MCP</a>: ресурсы онтологии — типы объектов, типы действий и query functions — становятся MCP-инструментами для внешних AI-агентов. Такие агенты могут читать объекты, выполнять заранее определённые действия и запрашивать данные, при этом доступ ограничивается scopes и permissions. (<a href="https://www.palantir.com/docs/foundry/ontology-mcp/overview" target="_blank" rel="nofollow noreferrer noopener">Palantir</a>)</div><div class="t-redactor__text">Для меня здесь важен не конкретный продуктовый подход Palantir, а архитектурный принцип: агенту мало дать промпт. Ему нужен управляемый доступ к модели и допустимым действиям.</div><h3  class="t-redactor__h3">Почему это важно именно сейчас</h3><div class="t-redactor__text">Чем дальше развивается продукт, тем сложнее становится синхронизировать разные способы взаимодействия с ним:</div><div class="t-redactor__text">— UX;</div><div class="t-redactor__text">— API;</div><div class="t-redactor__text">— MCP;</div><div class="t-redactor__text">— OntoAI;</div><div class="t-redactor__text">— OntoGPTs;</div><div class="t-redactor__text">— агент в чате;</div><div class="t-redactor__text">— метауровень;</div><div class="t-redactor__text">— пользовательские пространства.</div><div class="t-redactor__text">Все эти слои должны работать с одними и теми же сущностями. Если сущности расходятся, система начинает распадаться на набор интерфейсов.</div><div class="t-redactor__text">Поэтому соотнесение метамодели с API стало для меня важным шагом. Оно позволило свести разные уровни взаимодействия в единую структуру и дать агентам возможность работать не только с текстом, но и с реальной моделью платформы.</div><div class="t-redactor__text">В итоге изменение перестаёт быть локальной правкой. Оно становится частью единой структуры: от пользовательского смысла до интерфейса, API, документации, тестов и агентных сценариев.</div><h3  class="t-redactor__h3">Почему это не просто «ИИ помогает писать код»</h3><div class="t-redactor__text">История про «ИИ пишет код» выглядит слишком узкой.</div><div class="t-redactor__text">Код — это уже поздний этап. До него есть более важный слой: понимание изменения.</div><div class="t-redactor__text">Что именно мы делаем?</div><div class="t-redactor__text">Зачем?</div><div class="t-redactor__text">Для кого?</div><div class="t-redactor__text">Какие сценарии затрагиваем?</div><div class="t-redactor__text">Какие сущности меняются?</div><div class="t-redactor__text">Какие связи появляются?</div><div class="t-redactor__text">Какие старые допущения ломаются?</div><div class="t-redactor__text">Как это проверить?</div><div class="t-redactor__text">Как это потом переиспользовать?</div><div class="t-redactor__text">Именно здесь агенты становятся особенно полезны.</div><div class="t-redactor__text">Они помогают смотреть на модель с разных сторон: как аналитик, как разработчик, как тестировщик, как архитектор, как документатор. Но результат становится надёжным не потому, что агент «всё понял», а потому что его работа проходит через жёсткий контур: модель, связи, состояния, критерии качества и техпроцесс.</div><div class="t-redactor__text">Для меня вывод простой: агенту мало дать инструкцию. Ему нужна среда, правила и доступ к структурированному знанию.</div><h3  class="t-redactor__h3">Финал</h3><div class="t-redactor__text">Для меня это не история про то, что «ИИ пишет код».</div><div class="t-redactor__text">Гораздо интереснее другой вопрос: <strong>может ли инженерное знание работать как код?</strong></div><div class="t-redactor__text">То есть быть структурированным, проверяемым, трассируемым, воспроизводимым и пригодным для автоматизации.</div><div class="t-redactor__text">С появлением полноразмерного MCP я стал гораздо ближе к этому состоянию. Агенты получили доступ к модели, но результат стал предсказуемым не из-за магии LLM, а из-за связки модели, агентского бутстрапа и техпроцесса.</div><div class="t-redactor__text">Модель удерживает сложность.</div><div class="t-redactor__text">MCP открывает к ней доступ агентам.</div><div class="t-redactor__text">Бутстрап задаёт правила мышления и действия.</div><div class="t-redactor__text">Техпроцесс делает результат проверяемым.</div><div class="t-redactor__text">Именно эта комбинация позволяет проектировать изменения не как поток переписок, догадок и героического удержания контекста в голове, а как инженерный процесс, где смысл становится рабочим артефактом.</div><div class="t-redactor__text">Инженерное знание должно работать как код.</div><div class="t-redactor__text">Но жить оно будет не в одной плоскости, а на пересечении нескольких графов:</div><div class="t-redactor__text">— семантики;</div><div class="t-redactor__text">— контекста;</div><div class="t-redactor__text">— классификации;</div><div class="t-redactor__text">— топологии.</div><div class="t-redactor__text">И, кажется, именно там начинается самое интересное.</div><h3  class="t-redactor__h3">Ссылки</h3><div class="t-redactor__text"><ol><li data-list="ordered"><a href="https://www.palantir.com/docs/foundry/ontology/overview/" target="_blank" rel="nofollow noreferrer noopener">Palantir Foundry Ontology overview</a></li><li data-list="ordered"><a href="https://www.palantir.com/docs/foundry/architecture-center/ontology-system/" target="_blank" rel="nofollow noreferrer noopener">Palantir Architecture Center: Ontology system</a></li><li data-list="ordered"><a href="https://www.palantir.com/docs/foundry/architecture-center/aip-architecture/" target="_blank" rel="nofollow noreferrer noopener">Palantir AIP architecture overview</a></li><li data-list="ordered"><a href="https://www.palantir.com/docs/foundry/ontology-mcp/overview" target="_blank" rel="nofollow noreferrer noopener">Palantir Ontology MCP overview</a></li></ol></div>]]>
			</turbo:content>
		</item>
		</channel>
</rss>