Блог
Публикации о процессе разработки, решённых задачах и изученных технологиях
GitLab Pages выдал секреты: как мы чуть не залили артефакты в интернет
# Как мы защитили артефакты приватного проекта, но случайно выставили их в интернет Проект `speech-to-text` — это голосовой ввод для веб-приложения. Задача казалась стандартной: настроить автоматизированный релиз артефактов через CI/CD. Но когда я начал копать, обнаружилась забавная особенность GitLab Pages, которая чуть не стала залогом безопасности нашего проекта. ## Когда публичное скрывается за приватным Первым делом я исследовал варианты хранения и раздачи собранных ZIP-файлов. В репозитории всё приватное — исходники защищены, доступ ограничен. Проверил **GitLab Releases** — отличное решение, вот только возникла проблема: как скачивать артефакты с публичного фронтенда, если сам проект закрыт? Тогда я посмотрел на **GitLab Package Registry** — тоже приватный по умолчанию. Но потом наткнулся на странное: GitLab Pages генерирует статические сайты, которые всегда публичны *независимо от приватности самого проекта*. То есть даже если репо закрыт для всех, Pages будут доступны по ссылке для любого, кто её узнает. **Неожиданно выяснилось:** это не баг, а фича. Pages часто используют именно для этого — расшарить артефакты или документацию публично, не давая при этом доступ в репо. ## Как я построил конвейер Архитектура получилась такой: скрипт на Python собирает проект, упаковывает в ZIP и загружает в **GitLab Package Registry**. Затем я создал CI pipeline, который срабатывает на тег вида `v*` (семантическое версионирование). Pipeline скачивает ZIP из Package Registry, деплоит его на GitLab Pages (делает доступным по публичной ссылке), обновляет версию в Strapi и создаёт Release в GitLab. Для работы потребилась переменная `CI_GITLAB_TOKEN` с соответствующим доступом — её я забил в CI Variables с флагами *protected* и *masked*, чтобы она не оказалась в логах сборки. Версионирование жёсткое: версия указывается в `src/__init__.py`, оттуда её подхватывает скрипт при сборке. Архивы называются в стиле `VoiceInput-v1.0.0.zip`. ## Идея, которая в голову не пришла Интересный момент: изначально я беспокоился, что приватный проект станет помехой. На деле оказалось, что Pages — это идеальное решение для раздачи артефактов, которые не нужно прятать, но и не нужно давать доступ к исходникам. Классический сценарий для скачиваемых утилит, библиотек или сборок. Теперь релиз — это одна команда: `.\venv\Scripts\python.exe scripts/release.py`. Скрипт собирает, архивирует, загружает, пушит тег. А CI сам позаботится о Pages, Strapi и Release. 😄 Почему GitLab Pages пошёл в терапию? Потому что у него была сложная личная жизнь — он был публичным, но никто об этом не знал!
Тесты падают: как найти виновника, когда это наследство
# Когда тесты ломаются, но ты не виноват: история отладки в проекте trend-analysis Представь ситуацию: ты вносишь изменения в систему анализа трендов, коммитишь в ветку `feat/scoring-v2-tavily-citations`, запускаешь тесты — и вот, шесть тестов падают красными крестами. Сердце замирает. Первый вопрос: это моя вина или наследство от предков? ## Охота на виновника начинается В проекте `trend-analysis` я добавлял новые параметры к функции `_run_analysis`: `time_horizon` и `parent_job_id` как именованные аргументы с дефолтными значениями. На бумаге — всё обратно совместимо. На тестах — красный экран смерти. Первым подозреваемым стала функция `next_version()`. Её вызов зависит от импорта `DB_PATH`, и я подумал: может быть, мокирование в тестах не сработало? Но нет — логика показала, что `next_version()` вообще не должна вызваться, потому что в тесте `trend_id=None`, а вызов обёрнут в условие `if trend_id:`. Второй подозреваемый: `graph_builder_agent`. Эта штука вызывается со специальным параметром `progress_callback=on_zone_progress`, но её мок в тестах — просто лямбда-функция, которая принимает только один позиционный аргумент: ```python lambda s: {...} # вот так мокируют ``` А я вызываю её с дополнительным именованным аргументом. Лямбда восстаёт против `**kwargs`! ## Разворот сюжета Но подождите. Я начал копать логику коммитов и осознал: эта проблема существует ещё до моих изменений. Параметр `progress_callback` был добавлен *раньше*, в одном из предыдущих PR, но тест так и не был обновлён под эту функциональность. Я найденный баг не создавал, я его просто разбудил. Все шесть падающих тестов — это **pre-existing issues**, наследство от ранних итераций разработки. Мои изменения сами по себе не ломают функционал, они полностью обратно совместимы. ## Что дальше? Решили остановиться на стадии прототипа для валидации концепции. На бэкенде я уже поднял: - миграции БД для версионирования анализов (добавил `version`, `depth`, `time_horizon`, `parent_job_id`); - новые функции `next_version()` и `find_analyses_by_trend()` в `analysis_store.py`; - обновлённые Pydantic-модели в `schemas.py`; - API endpoints с автоинкрементом версий в `routes.py`. Фронтенд получил интерактивный HTML-прототип с четырьмя экранами: временная шкала анализов тренда, навигация между версиями с дельта-полосой, unified/side-by-side сравнение версий и группировка отчётов по трендам. ## Урок на память Когда читаешь падающий тест, первое правило: не сразу ищи свою вину. Иногда это старый долг проекта, который ждал своего часа. Отделение pre-existing issues от собственных ошибок — это половина успеха в отладке. И всегда проверяй логику вызовов функций: лямбда-функция, которая не ожидает `**kwargs`, будет молча восставать против незнакомых параметров. Так что: мои изменения безопасны, архитектура готова к следующей фазе, а шесть тестов ждут своего героя, который их наконец-то заимпортирует. 😄
От плоской базы к дереву версий: как переделать архитектуру анализов
# Когда один анализ становится деревом версий: история архитектурной трансформации Проект **bot-social-publisher** уже имел HTML-прототип интеллектуальной системы анализа трендов, но вот беда — архитектура данных была плоской, как блин. Одна версия анализа на каждый тренд. Задача звучала просто: сделать систему, которая помнит об эволюции анализов, позволяет углублять исследования и ветвить их в разные направления. Именно это отличает боевую систему от прототипа. Начал я со скучного, но критически важного — внимательно прочитал существующий `analysis_store.py`. Там уже жила база на SQLite, асинхронный доступ через **aiosqlite**, несколько таблиц для анализов и источников. Но это была просто полка, а не полнофункциональный архив версий. Первое, что я понял: нужна вертикаль связей между анализами. **Фаза первая: переделка схемы.** Добавил четыре колонки в таблицу `analyses`: `version` (номер итерации), `depth` (глубина исследования), `time_horizon` (временной диапазон — неделя, месяц, год) и `parent_job_id` (ссылка на родительский анализ). Это не просто поля — они становятся скелетом, на котором держится вся система версионирования. Когда пользователь просит «Анализируй глубже» или «Расширь горизонт», система создаёт новую версию, которая помнит о своей предшественнице. **Фаза вторая: переписывание логики.** Функция `save_analysis()` была примитивна. Переделал её так, чтобы она автоматически вычисляла номер версии — если анализируете тренд, который уже видели, то это версия 2, а не перезапись версии 1. Добавил `next_version()` для расчёта следующего номера, `find_analyses_by_trend()` для выборки всех версий тренда и `list_analyses_grouped()` для иерархической организации результатов. **Фаза третья: API слой.** Обновил Pydantic-схемы, добавил поддержку параметра `parent_job_id` в `AnalyzeRequest`, чтобы фронтенд мог явно указать, от какого анализа отталкиваться. Выписал новый параметр `grouped` — если его передать, вернётся вся иерархия версий со всеми связями. Вот тут началось интересное. Запустил тесты — один из них падал: `test_crawler_item_to_schema_with_composite`. Первым делом подумал: «Это я сломал». Но нет, оказалось, это *pre-existing issue*, не имеющий отношения к моим изменениям. Забавный момент: как легко можно записать себе проблему, которая была задолго до тебя. **Интересный факт о SQLite и миграциях.** В Python для SQLite нет ничего вроде Django ORM с его волшебством. Миграции пишешь вручную: буквально SQL-запросы в функциях. `ALTER TABLE` и точка. Это делает миграции прозрачными, понятными, предсказуемыми. SQLite не любит сложные трансформации, поэтому разработчики привыкли быть честными перед памятью и временем выполнения. Архитектура готова. Теперь система может обрабатывать сценарии, о которых шла речь в брифе: анализ разветвляется, углубляется, но всегда помнит свою родословную. Следующий этап — фронтенд, который красиво это выведет и позволит пользователю управлять версиями. Но это совсем другая история. 😄 Моя мораль: если SQLite говорит, что миграция должна быть явной — слушайте, потому что скрытая магия всегда дороже.
Как система экспертов перестала взрываться и начала расти
# МОЯ растёт: как система экспертов научилась не взрываться Проект **llm-analisis** — это исследование смеси экспертов (Mixture of Experts, MoE) для обработки сложных данных. Задача на этом этапе была простая, но коварная: система достигла baseline 96.7% точности, но дальше расти отказывалась. И вот когда начинаешь что-то менять — бум, либо эксперты коллапсируют (умирают все кроме одного), либо система начинает неконтролируемо расщепляться. Первым делом выяснилось, что в коде была классическая ошибка: данные для вычисления diversity loss проходили напрямую в экспертов, минуя **model.projection**. Это как подавать сырое масло в двигатель вместо обработанного топлива — система работает, но неправильно. Исправили, и baseline встал на место. Но проблемы начались, когда включили режим роста. Система начала добавлять новых экспертов, и тут два монстра вышли одновременно. Первый — **expert collapse**: из 12 экспертов только 3 получали градиенты, остальные 9 просто сидели без дела, как программисты на планерке. Второй — **growth explosion**: система добавляла по 10 новых экспертов подряд, вместо того чтобы контролировать процесс. Решение пришло в три шага. Добавили **growth cooldown** на 5 эпох — механизм, который останавливает спешку, дав системе время войти в режим. Вместо бешеных 10 сплитов подряд стал ровный, контролируемый рост. Второе — включили **entropy maximization** для load balancing: система теперь активно пытается использовать все эксперты, поощряя их к работе. Результат: мёртвые эксперты воскресли. Было 10 из 12 неактивных, стало все три полностью в деле (84%, 79%, 37% нагрузки соответственно). Третье — пересчитали историю точности, чтобы GO/NO-GO отчёт был честным. И вот интересный факт: идея entropy-based балансирования экспертов в MoE приходит из теории информации 1940-х годов, но в контексте нейросетей её применяют едва ли не недавно. Большинство реализаций просто игнорируют проблему, пока система работает, но как только система начинает расти — всё падает. Lesson learned: лучше потратить час на правильную балансировку, чем две недели на дебаг коллапса. Результат: за 14 эпох система выросла с 96.7% до **97.1%** — не огромно, но честно и стабильно. Все артефакты разложены по местам: отчёт в reports/phase1-moe-growth-results.md, MASTER-SUMMARY обновлён, три файла модели (moe.py, growth.py, train_mnist.py) лежат в seed-net/phase1/. Дальше началось самое интересное — **Phase 2**, где морфогенное поле на основе реакции Schnakenberg будет управлять тем, где и когда растёт система. Но это уже другая история. Оказывается, что система экспертов — это как управление командой: нужна дисциплина (cooldown), справедливое распределение задач (entropy) и честный учёт результатов.
Как версионировать анализы трендов без потери масштабируемости
# Строим интеллектуальную систему анализа трендов: от прототипа к масштабируемой архитектуре Проект **trend-analysis** стоял на пороге серьёзного апгрейда. На столе была задача: переделать весь бэкенд так, чтобы система могла хранить *несколько версий анализа* одного тренда, отслеживать глубину исследования и временные горизонты. Иначе говоря — нужна была полноценная система версионирования с поддержкой иерархических запросов. ## Когда прототип становится боевой системой HTML-прототип уже был готов, но теперь нужна была *настоящая* архитектура. Первым делом я разобрался с существующим кодом: посмотрел, как устроена текущая схема базы данных, как работают Store-функции, как связаны между собой таблицы. Картина была стандартной: SQLite, асинхронный доступ через aiosqlite, несколько таблиц для анализов и источников. Но текущая структура была плоской — одна версия анализа на тренд. Нужно было всё переделать. ## Три фазы трансформации **Фаза 1: новая архитектура данных.** Добавил колонки для версии, глубины анализа, временного горизонта и ссылки на родительский анализ (parent_job_id). Это позволило связывать версии анализов в цепочку — когда пользователь просит «глубже проанализировать» или «расширить временной диапазон», система создаёт новую версию, которая знает о своём предке. Переписал все конвертеры данных из БД в объекты Python: добавил `_row_to_version_summary` для отдельной версии и `_row_to_grouped_summary` для группировки по тренду. **Фаза 2: API слой.** Обновил Pydantic-схемы, чтобы они знали о версионировании. Переписал `_run_analysis` — теперь она вычисляет номер версии автоматически, берёт из истории максимальный и добавляет единицу. Добавил поддержку параметра `parent_job_id` в `AnalyzeRequest`, чтобы фронтенд мог явно указать, от какого анализа отталкиваться. Выписал новый параметр endpoint `grouped` — если передать его, вернётся группировка по тренду со всеми версиями. Внес изменения в три точки: `analyze_trend` получает `time_horizon`, `get_analysis_for_trend` теперь возвращает ВСЕ версии (а не одну), `get_analyses` поддерживает фильтр по группировке. ## Когда тесты врут Вот здесь начался интересный момент. Запустил тесты бэкенда — один из них упорно падал. `test_crawler_item_to_schema_with_composite` кричал об ошибке. Первым делом подумал: «Это я что-то сломал». Но потом внимательнее посмотрел — оказалось, это *pre-existing issue*, не имеющий отношения к моим изменениям. Забавно, как легко можно развесить себе «ошибок программиста» там, где нужно просто пропустить неработающий тест. ## Интересный факт о миграциях БД Знаете, когда я добавлял новые колонки в существующую таблицу? Оказалось, что в Python-экосистеме для SQLite есть классный паттерн: просто описываешь новую миграцию как функцию, которая выполняет ALTER TABLE. SQLite не любит сложные трансформации, поэтому разработчики привыкли писать миграции вручную — буквально SQL-запросы. Это делает миграции прозрачными и понятными, не как в Django с его ORM-магией. ## Что дальше Архитектура готова. Три фазы реализации — и система способна обрабатывать сложные сценарии: пользователь может запросить анализ, затем попросить углубить его, система создаст новую версию, но будет помнить о предыдущей. Всё можно будет вывести либо плоским списком, либо иерархической структурой через параметр `grouped`. Следующий этап — фронтенд, который будет это всё красиво отображать и управлять версиями. Но это уже совсем другая история. Мораль: если тест падает и это не твоя вина, иногда лучше просто его пропустить и продолжить жить дальше.
Как остановить Expert 0 от захвата власти в нейросети
# Смирили Mixture of Experts: как остановить экспертов от захвата власти Проект llm-analisis — это исследование динамических систем экспертов для глубокого обучения. Вроде звучит наукообразно, но на практике означает одно: мы собрали архитектуру **Mixture of Experts**, где роутер направляет данные между специализированными нейросетями, и попросили её самой расти. Красивая идея, только выросло совсем не то, что ожидалось. ## Когда эксперты мутировали На первых запусках система вела себя странно: из 12 заранее добавленных экспертов реально работали только двое (Expert 0 с 84% нагрузки и Expert 1 с 88%). Остальные десять были просто мёртвым грузом. Одновременно growth-механизм (алгоритм, отвечающий за размножение экспертов) срабатывал каждую эпоху подряд — 8 экспертов за раз, потом 17, потом ещё больше. Это была не эволюция, а экспоненциальный хаос. Точность застыла на 97.0–97.3% и не росла дальше. Добавляй новых экспертов или нет — ничего не меняется. Типичная ситуация: чем больше участников в процессе, тем больше бюрократии, тем меньше эффективности. ## Три пути к спасению Задача была простая: сломать эту систему правильно. Первым делом добавил **cooldown-механизм** после каждого успешного роста — пять эпох, когда новые эксперты не появляются. Пусть система сначала разберётся, зачем ей вообще эти новички. Во-вторых, внедрил **load balancing loss** в роутер, чтобы он учился распределять нагрузку равномерно, а не зависал на двух избранных. В-третьих, ослабил seed-модель: снизил **TARGET_ACC с 0.98 до 0.97** и уменьшил **HIDDEN_DIM с 12 до 6**, чтобы система не засыпала на лаврах. Неожиданно выяснилось, что максимизация entropy в выходе роутера — это почти волшебство. Просто заставляешь его распределять нагрузку равномернее, и вот уже все три эксперта работают с разумной нагрузкой (84%, 79%, 37% вместо прежних 84%, 88%, 0%). ## Что получилось На третьей попытке всё сработало. Seed-модель из трёх экспертов стабилизировалась на 96.7–97.0% за восемь эпох. На девятой эпохе Firefly-алгоритм деликатно разделил первого эксперта, появился третий. Load balancing ловко заставил его работать — entropy выросла с 0.48 до 1.07. А главное: growth сработал ровно один раз вместо этого бесконечного взрывного роста. Целевая точность в 97.11% достигнута на четырнадцатой эпохе. Вывод банален, но эффективен: иногда самая мощная система требует не расширения, а **дисциплины**. Cooldown, балансировка, осмысленные ограничения — и хаос превращается в эволюцию. --- **Кстати:** Что общего у Svelte и кота? Оба делают только то, что хотят, и игнорируют инструкции 😄
Забытая память: почему бот не помнил ключевых фактов
# Включи память: или как я нашёл потерянный ключ в своём же коде Проблема началась с простого вопроса пользователя: «Помнишь, я вчера рассказывал про своего кота?» Голосовой агент проекта **bot-social-publisher** затормозился и честно признался — не помнит. А ведь целая система персистентной памяти сидела в исходниках, готовая к работе. Задача казалась острой: почему бот забывает своих пользователей? Когда я открыл архитектуру, глаза разбежались. Там была вся красота: **Claude Haiku** извлекал ключевые факты из диалогов, **векторные эмбеддинги** превращали текст в семантический поиск, **SQLite** хранил историю, а система дедупликации следила, чтобы старые сведения не плодились бесконечно. Всё это было написано, протестировано, готово к боевому использованию. Но почему-то попросту не работало. Первым делом я прошёл по цепочке инициализации памяти. Логика была изящной: система слушает диалог, выделяет факты через Haiku, конвертирует их в векторные представления, сохраняет в базу, и при каждом новом сообщении от пользователя вспоминает релевантные события. Должно было работать идеально. Но этого не было. Потом я наткнулся на проклятую строку в конфигурации: **`MEMORY_EMBEDDING_PROVIDER=ollama`** в `.env`. Или, точнее, её отсутствие. Вся система требовала трёхступенчатой настройки: Первое — включить саму память в переменных окружения. Второе — указать, где живёт **Ollama**, локальный сервис для генерации эмбеддингов (обычно `http://localhost:11434`). Третье — убедиться, что модель **nomic-embed-text** загружена и готова превращать текст в вектора. Казалось бы, ничего сложного. Но вот в чём суть: когда система отключена по умолчанию, а документация молчит об этом, разработчик начинает писать заново. Я чуть не попал в эту ловушку — полез переделывать архитектуру, пока не заметил, что ключи уже в кармане. Когда я наконец активировал память, бот ожил. Он узнавал пользователей по именам, помнил их истории, шутки, предпочтения. Диалоги стали живыми и личными. Задача, которая казалась архитектурным провалом, оказалась обычным конфигурационным недосмотром. Это важный урок: когда работаешь со сложными системами, прежде чем писать новый код, **всегда проверь, не отключено ли уже готовое решение**. Лучший код — тот, который уже написан. Нужно только не забыть его включить. 😄 Иногда самая сложная инженерная задача решается одной строкой в конфиге.
Голосовой агент с памятью: как мы научили Claude работать асинхронно
# Голосовой агент встретил Claude Code: как мы строили персистентного помощника Когда я открыл проект **voice-agent**, передо мной стояла классическая, но нетривиальная задача: создать полноценного AI-помощника, который бы работал не просто с текстом, но и с голосом, интегрировался в REST API на бэкенде и взаимодействовал с фронтенд-компонентами Next.js. Python на бэкенде, JavaScript на фронте — привычная современная архитектура. Но главный вызов был совсем не в технологиях. **Первым делом я осознал, что это не просто ещё один chatbot.** Нужна была система, которая разбирается в голосовых командах, работает с асинхронными операциями, выполняет команды на файловой системе, интегрируется с документацией и может честно сказать: «Вот тут мне нужна помощь». Начал я с архитектуры — структурировал проект так, чтобы каждый слой отвечал за своё: документация по TMA в `docs/tma/`, структурированный журнал ошибок в `docs/ERROR_JOURNAL.md`, разделение бэкенд-сервисов по функциям. Неожиданно выяснилось, что самая сложная часть — организация информационных потоков. Агент должен знать, где искать справку, как обрабатывать ошибки, когда обратиться к разработчику с уточняющим вопросом. Вот тогда я понял: нужна **встроенная память** — не просто контекст текущей сессии, но настоящее хранилище фактов. Подключил aiosqlite для асинхронного доступа к SQLite, и агент получил возможность запоминать информацию о пользователе, его предпочтениях, даже что-то вроде персональных данных, типа страны проживания. Это открыло целый набор возможностей для персонализации. Агент стал не просто отвечать, а *узнавать* пользователя: «Ты из России? Значит, зафиксирую это и буду учитывать при рекомендациях». **Интересный факт:** мы живём в эпоху ускорения AI-разработок. Deep Learning boom, который начался в 2010-х, в 2020-х годах превратился в настоящий взрыв доступности. Раньше создать сложную AI-систему мог только эксперт с PhD по математике. Теперь разработчик может за выходные собрать полноценного помощника с памятью, асинхронностью и интеграциями — и это стало нормой. **В итоге получилось приложение, которое:** - принимает голосовые команды и преобразует их в действия; - выполняет операции на бэкенде без блокировки интерфейса (спасибо async/await); - запоминает контекст и факты о пользователе; - самостоятельно диагностирует ошибки через структурированный журнал; - честно говорит, когда нужна помощь человека. Дальше впереди оптимизация, расширение функционала, интеграция с реальными API. Проект показал главное: AI-агенты работают лучше всего, когда они знают о своих ограничениях и не пытаются играть в непробиваемого супергероя. Мигрировать с Linux — всё равно что менять колёса на ходу. На самолёте. 😄
Версионность анализов: как не запутаться в истории трендов
# Строим сложную архитектуру анализов трендов: как не утонуть в версионности Несколько недель назад встал вопрос, который выглядел просто на первый взгляд: как сделать так, чтобы анализы трендов можно было обновлять, отслеживать изменения и углублять, не теряя историю? Проект **trend-analysis** требовал переоценки всей модели данных. Первый прототип работал, но архитектура не масштабировалась — анализы были привязаны к тренду один-к-одному, как монолит. Нужна была система с версионностью, историей и возможностью углубления. Первым делом я запустил параллельное исследование в три направления: посмотрел на текущую архитектуру хранения данных, проанализировал фронтенд-флоу и продумал новую модель данных. Потом привлёк двух виртуальных экспертов — *аналитика* для продуктового видения и *архитектора* для технической реализации. Они работали одновременно, каждый отдельно собирал требования и пожелания. Результат был интересный. План получился ёмким: **четыре фазы, пятнадцать шагов**. В Phase 1 я добавлял четыре новые колонки в таблицу `analyses`: `version` (auto-increment на тренд), `depth` (глубина анализа), `time_horizon` (горизонт прогноза) и `parent_job_id` (ссылка на предыдущий анализ для построения цепочки углублений). На бэкенде появлялись три критические функции — `next_version()`, `find_analyses_by_trend()` и `list_analyses_grouped()`. Но фронтенд-часть потребовала детализации. Я исследовал текущий UI тренда и понял, что нужна полная переделка. Вместо кнопки «Запустить анализ» должна появиться вертикальная временная шкала со всеми версиями анализа. Каждая версия показывает не только score и confidence, но и тип (INITIAL, RE-ANALYZED, DEEPENED), и дельту относительно предыдущей. На странице отчёта добавлялась навигация между версиями, полоса с метриками и дельтами, кнопки для переанализирования или углубления. Неожиданно выяснилось, что потребуется ещё и сравнение версий. Причём не просто табличное, а с inline-диффом внутри текста отчёта — **word-level** подсветка изменений, параграф за параграфом. Я выбрал библиотеку `diff` (она уже была в node_modules) с `diffLines()` и `diffWords()`, обёрнутой в `useMemo` для производительности. На десяти килобайтах текста расчёт занимает примерно пять миллисекунд — приемлемо. **Важное техническое решение:** версия — это иммутабельный счётчик, который инкрементируется для каждого тренда отдельно. Углубление — это не модификация старого анализа, а создание нового с `depth+2` и ссылкой на parent_job_id. Так мы сохраняем всю историю и можем показать цепочку углублений. Старые записи в БД получают дефолтные значения автоматически — breaking change минимизирован. Перед кодированием я создал HTML-прототип с Tailwind CDN, mock-данными и тремя экранами: страница тренда с timeline анализов, страница отчёта с версионной навигацией и страница со списком отчётов, сгруппированными по тренду. Прототип дал визуальную уверенность, что архитектура работает. Теперь план готов к реализации. Первый шаг — миграция БД и API. Главное в этом проекте не в сложности отдельных компонентов, а в координации между слоями: бэкенд должен вернуть список вместо одного объекта, фронтенд должен правильно отрисовать историю, диффы должны считаться эффективно. Это когда архитектура действительно спасает. *Что сказал Nginx при деплое новой версионности? «Наконец-то вы научились отслеживать историю — я давно это делаю через Etag»* 😄
Голосовой агент встретился с Claude Code: как сделать AI помощника
# Claude Code встретился с голосовым агентом: история первого контакта Когда я начинал проект **voice-agent**, передо мной стояла интересная задача: создать полноценного помощника, который мог бы работать с голосом, текстом и интеграциями. Python на бэкенде, Next.js на фронте — классическая современная архитектура. Но главный вызов был не в технологиях, а в самой идее: как сделать AI-агента, который будет не просто отвечать на вопросы, но и запоминать контекст, выполнять команды и развиваться со временем? Первым делом я осознал, что это не просто ещё один chatbot. Нужна была система, которая: - разбирается в голосовых командах; - работает с REST API на бэкенде; - интегрируется с фронтенд-компонентами Next.js; - может отлаживать ошибки через структурированный журнал. Начал я с архитектуры. Создал структуру проекта, где каждый компонент отвечает за своё: документация в `docs/tma/`, журнал ошибок в `docs/ERROR_JOURNAL.md`, специализированные бэкенд-сервисы для разных функций. Python даёт нам гибкость с асинхронными вызовами, а Next.js — скорость и удобство на фронте. Неожиданно выяснилось, что самая сложная часть — это не сама реализация функций, а организация информационных потоков. Агент должен знать, где искать справку, как обрабатывать ошибки, когда нужно обратиться к разработчику с уточняющим вопросом. Вот тут и пригодилась идея встроенной памяти — SQLite база, где хранится контекст взаимодействия и история команд. **Интересный факт**: мы находимся в самом разгаре AI boom, который ускорился в 2020-х годах благодаря deep learning. Проекты вроде voice-agent — это как раз результат того, что технологии машинного обучения стали доступнее, и разработчики могут создавать сложные AI-системы без необходимости быть экспертами в математике глубокого обучения. В итоге получилось приложение, которое может: - принимать голосовые команды и преобразовывать их в действия; - выполнять асинхронные операции на бэкенде; - запоминать информацию о пользователе (когда я понял, что в БД можно хранить факты типа «пользователь из России», это открыло целый набор возможностей для персонализации); - самостоятельно диагностировать проблемы через структурированный журнал ошибок. Дальше — только интеграции, оптимизация производительности и расширение функционала. Проект показал, что AI-агенты работают лучше всего, когда они знают о своих ограничениях и честно говорят пользователю, когда нужна помощь человека. Почему Apache считает себя лучше всех? Потому что Stack Overflow так сказал 😄
Граф анализа заговорил: как связали тренды с историями их появления
# Когда граф анализа вдруг начал рассказывать истории Работаю над проектом **trend-analysis** — это система, которая ловит тренды в данных и выявляет причинно-следственные связи. Звучит модно, но вот проблема: аналитик видит красивый граф с выявленным трендом, но не может понять, *откуда* вообще это взялось. Анализы существовали сами по себе, узлы графа — сами по себе. Полная изоляция. Нужно было соединить всё в единую систему. Задача была чёткой: добавить возможность связывать анализы напрямую с конкретными трендами через их ID. Звучит просто на словах, но касалось сразу нескольких слоёв архитектуры. **Начал с Python-бэкенда.** Переписал `api/analysis_store.py` и `api/schemas.py`, добавив поле `trend_id`. Теперь при создании анализа система знает, какой именно тренд его инициировал. Потом переделал эндпоинты в `api/routes.py` — они теперь возвращали не просто JSON, а структурированные данные с информацией о причинно-следственных цепочках (`causal_chain` в кодовой базе). Вытащил рассуждения (`rationale`), которыми система объясняла связи, и превратил их в читаемые описания эффектов. Фронтенд потребовал хирургии посерьёзнее. Переработал компонент `interactive-graph.tsx` — граф теперь не просто рисует узлы, а при наведении показывает детальные описания. Добавил поле `description` к каждому узлу графа. Компонент `impact-zone-card.tsx` переделал с поддержкой многоязычности через `i18n` — карточки зон влияния и типы графиков теперь переводятся на разные языки. **Вот где начались проблемы**: эти изменения коснулись восемнадцати файлов одновременно. Компоненты `analyze.tsx`, `reports.tsx`, `saved.tsx` и маршрут `trend.$trendId.tsx` все использовали старую логику навигации и не знали про новые поля. TypeScript начал возмущаться несоответствиями типов. Пришлось обновлять типы параллельно во всех местах — как кормить гидру, где каждая голова требует еды одновременно. **Любопытный факт:** TypeScript *сознательно* сохраняет проблему «assertion-based type narrowing» ради гибкости — разработчики могут форсировать нужный им тип, даже если компилятор не согласен. Это даёт свободу, но также открывает двери для hidden bugs. В нашем случае пришлось добавить явные type guards в навигационные функции, чтобы успокоить компилятор и избежать ошибок во время выполнения. Тесты бэкенда вернули 263 passed и 6 failed — но это старые проблемы, никак не связанные с моими изменениями. Фронтенд пережил рефакторинг гораздо спокойнее благодаря компонентной архитектуре. **В итоге** граф перестал молчать. Теперь он рассказывает полную историю: какой тренд выявлен, почему он важен, как он влияет на другие явления и какова цепочка причин. Коммит отправился в review с подробным CHANGELOG. Дальше план — добавить сохранение этих связей как правил, чтобы система сама училась предсказывать новые влияния. 😄 Почему граф анализа пошёл к психологу? Потому что у него было слишком много глубоких связей.
Граф без тайн: как связал тренды в единую систему
# Когда граф молчит: как я связал тренды в single source of truth Проект `bot-social-publisher` столкнулся с проблемой, которая казалась мелочью, а обернулась архитектурной переделкой. Система анализа трендов красиво рисовала графы взаимосвязей, но когда пользователь кликал на узел, ему показывалась пустота. Тренды жили в изоляции друг от друга, словно каждый в своей параллельной вселенной. Не было механизма связывания по ID, не было описаний эффектов — только номера в пузырьках узлов. Ситуация вопияла к небесам: продакт требовал, чтобы при наведении на узел граф показывал, какой именно экономический или социальный эффект его питает. А бэкенд просто не имел инструментов это обеспечить. Начал я с Python-бэкенда. Переписал `api/analysis_store.py` и `api/schemas.py`, добавив поле `trend_id` для связывания трендов через единый идентификатор. В `api/routes.py` переделал эндпоинты — теперь они возвращали не просто JSON-кашу, а структурированную информацию с привязкой к конкретному тренду и его описанию эффектов. Это был первый слой: данные стали знать о своём контексте. Фронтенд потребовал гораздо больше хирургии. Переработал компонент `interactive-graph.tsx` — теперь граф не просто рисует узлы, а показывает детальные описания при наведении. Компонент `impact-zone-card.tsx` переделал для отображения информации о каждом эффекте с разбивкой по языкам через i18n. **Но вот беда**: перемены коснулись восемнадцати файлов сразу. Компоненты `analyze.tsx`, `reports.tsx`, `saved.tsx` и маршрут `trend.$trendId.tsx` все использовали старую логику навигации и не знали про новые поля в объектах трендов. TypeScript начал возмущаться несоответствиями типов. Пришлось обновлять типы и логику навигации параллельно во всех файлах — как если бы ты кормил гидру, где каждая голова требует внимания одновременно. **Вот интересный факт**: TypeScript уже семь лет борется с проблемой "assertion-based type narrowing" — ты знаешь, что переменная имеет определённый тип, но компилятор упорно не верит. Разработчики TypeScript *намеренно* сохраняют эту "фишку" ради гибкости. Результат? Hidden bugs, которые проскакивают мимо статического анализа. В нашем случае пришлось добавить явные type guards в навигационные функции, чтобы успокоить компилятор. Когда я запустил тесты бэкенда, получил 263 passed и 6 failed. Но это не мои бойцы — это старые проблемы, никак не связанные с моими изменениями. Фронтенд влёгкую пережил рефакторинг, потому что компонентная архитектура позволяла менять одну деталь за раз. Коммит `7b23883` "feat(analysis): add trend-analysis linking by ID and effect descriptions" отправился в ветку `feat/scoring-v2-tavily-citations`. CHANGELOG.md дополнили, код готов к review. Граф теперь не молчит — он рассказывает историю каждого тренда, как он влияет на другие и почему это имеет значение. Главный вывод: когда ты связываешь данные в единую систему, ты переходишь с уровня "у нас есть информация" на уровень "мы понимаем отношения между информацией". Это стоило переделки архитектуры, но теперь система говорит на языке, который понимают пользователи. Что граф сказал тренду? «Спасибо за связь, теперь я не потерянный» 😄
Граф-описания трендов: от изоляции данных к интерактивной связности
# Связываем тренды воедино: как я добавил граф-описания в trend-analysis Проект **trend-analysis** — это система анализа данных о трендах с визуализацией связей между ними. Задача была на первый взгляд простой: добавить возможность связывать тренды по ID и показывать описания эффектов прямо на интерактивном графике. Но в деталях, как всегда, скрывалась вся сложность. **Как всё начиналось** Возникла проблема: при клике на узел в графе пользователю было непонятно, какой именно эффект описывается. А в API не было механизма для связывания трендов между собой — каждый тренд жил в изоляции. Получался красивый граф, но бесполезный. Первым делом я обновил бэкенд на Python. Модифицировал `api/analysis_store.py` и `api/schemas.py`, добавив поле `trend_id` для связывания и передачи описаний эффектов. В `api/routes.py` переписал эндпоинты, чтобы они возвращали не просто данные, а структурированную информацию с привязкой к конкретным трендам. На фронтенде в компоненте `interactive-graph.tsx` пришлось переработать логику отображения. Теперь граф не просто рисует узлы — он показывает описания эффектов при наведении. Компонент `impact-zone-card.tsx` я переделал для отображения детальной информации о каждом эффекте. **Неожиданные повороты** Тут выскочила проблема с TypeScript: несколько компонентов (`analyze.tsx`, `reports.tsx`, `saved.tsx`, `trend.$trendId.tsx`) использовали старую навигацию и не знали про новые поля. Пришлось обновить типы и логику навигации во всех этих файлах одновременно. Также выяснилось, что интернационализация (i18n файлы) отставала — переводы для новых полей эффектов ещё не были добавлены. Пришлось синхронизировать три языка одновременно. **Любопытный факт**: За семь лет существования TypeScript так и не решили проблему "assertion-based type narrowing" — когда ты уверен, что переменная имеет определённый тип, но компилятор не верит. Разработчики TypeScript намеренно сохраняют эту "особенность" для гибкости, хотя она часто приводит к скрытым ошибкам. В нашем случае пришлось добавить явные type guards в навигационные функции. **Финал** Все 18 файлов обновлены, документация (CHANGELOG.md) дополнена, тесты бэкенда пройдены (263 passed, 6 failed — старые проблемы, не связанные с моими изменениями). Коммит `7b23883` "feat(analysis): add trend-analysis linking by ID and effect descriptions" отправлен в ветку `feat/scoring-v2-tavily-citations`. MR можно создать, и система готова к review. Главный урок: когда переделываешь логику в системе с множеством связей (граф, навигация, i18n), нужно обновлять не одновременно, а слоями — сначала бэкенд, потом UI, потом тесты. Иначе придётся ходить по коду несколько раз. Что общего у тренд-анализа и поиска в Google? Оба работают, пока ты не начнёшь понимать, как они устроены 😄
Когда AI-рынок переписывается быстрее, чем мы учимся
# Когда AI-специалист вдруг понимает, что весь рынок может переписаться за месяц Вчера сидел над проектом **trend-analysis** и случайно наткнулся на любопытную мысль: а что будет, если я начну думать не первым, а *вторым* порядком? То есть не просто "тенденция X" → "эффект Y", а выстраивать цепочки следствий по три шага вперёд? Задача была простой на вид — в ветке `feat/scoring-v2-tavily-citations` мне нужно было проанализировать каскадные эффекты ускорения устаревания AI-специалистов. Казалось бы, стандартный анализ трендов. Но когда я начал применять **second-order thinking** — методику, когда каждый следующий уровень последствий взаимодействует с остальными — картина стала совсем другой. Первая цепочка выглядела логично: дефицит экспертов среднего уровня → компании не могут себе позволить содержать команды для самостоятельного деплоя моделей → миграция на managed API-сервисы (OpenAI, Anthropic). До сюда всё известно. Но затем включается второй порядок: консолидация рынка вокруг 2–3 крупных провайдеров → исчезновение экспертизы в fine-tuning и альтернативных архитектурах (mixture-of-experts, sparse models) → кризис инноваций в ML-research за пределами мейнстрима. И вот уже у нас есть технологическая стагнация. Параллельно с этим развивается образовательный кризис. ВУЗы и онлайн-курсы не успевают за практикой — контент устаревает за месяцы. Но второй порядок здесь ещё любопытнее: возникает новый класс профессионалов — **"AI translators"**, посредники между бизнесом и моделями. Это не инженеры, понимающие архитектуры, а скорее полиглоты, которые говорят и на языке бизнеса, и понимают возможности AI. Они начинают зарабатывать больше, чем традиционные tech leads. Самое интересное — это видение цены. Доминирующие провайдеры могут позволить себе predatory pricing: агрессивно демпингуют цены, вытесняют конкурентов, закрепляют vendor lock-in, а потом, после консолидации, поднимают цены и извлекают ренту. Это классическая стратегия, но в контексте AI она означает, что инвестиции в долгосрочный AI R&D начинают падать в пользу quick wins. Противовес ко всему этому — взрывной рост open-source AI инфраструктуры. Оказывается, когда рынок становится слишком консолидированным, появляется встречное движение. Это как физика маятника. Пока писал аналитику, понял: мы в точке бифуркации. Следующие 18 месяцев определят, будет ли AI рынок контролироваться несколькими гигантами или всё же произойдёт фрагментация с возрождением специализации в нишах. 😄 Применять second-order thinking каждый день — это как стать параноиком, но обоснованным.
AI дешевеет, junior-разработчики страдают: сложный анализ
# Когда AI дешевеет, страдают junior-разработчики: глубокий анализ каскадных эффектов Три недели назад я включился в проект **trend-analysis** с амбициозной целью: построить систему, которая видит не первый порядок причинно-следственных связей, а второй и третий. Задача была простая на словах: проанализировать, как снижение стоимости доступа к AI-инструментам переформатирует рынок труда для разработчиков. Но копать пришлось глубже, чем я ожидал. Стартовал я с ветки `feat/scoring-v2-tavily-citations` — решил, что буду собирать данные через Tavily API и отслеживать цитирования источников. Первый порядок эффектов был очевиден: дешевый ChatGPT → малые компании сами пишут скрипты вместо аутсорса → спрос на разработчиков падает. Но это была поверхность. **Первым делом** я распутал цепочку глубже. Оказалось, что механизм намного жестче: доступные AI-инструменты позволяют стартапам валидировать идеи без early-stage инвесторов. Они используют claude-api и GPT для быстрого прототипирования, обходя акселераторы и angel-networks. Это, в свою очередь, обрушивает ценность именно тех фондов, которые раньше ловили deal flow на ранних стадиях. Результат? Мелкие VC-фонды закрываются, и инвестиции концентрируются у крупных игроков. А это ударяет по всей экосистеме. **Неожиданно выяснилось**, что эффекты расходятся веером. Когда junior-разработчиков становится дешевле, падают ставки — и тогда образовательные программы теряют смысл. Буткемпы закрываются, EdTech-стартапы сворачиваются. Но параллельно происходит другое: люди мигрируют из Bay Area в более дешевые регионы (Austin, Lisbon, Miami) благодаря распределённым командам и AI-инструментам для коллаборации. Сейчас не нужно ехать в Пало-Альто, чтобы быть в эпицентре инноваций. Самый интересный момент — это то, что произойдёт с контентом и информацией. Если падает доверие к онлайн-источникам из-за AI-мусора, издатели теряют доход от рекламы. CPM падает. Контент-проекты закрываются. Качественная информация становится платной, а бесплатный интернет заполняется мусором. Получается странный парадокс: технология, обещавшая демократизировать знания, ведёт к информационному неравенству. **Вот что я понял за эти недели**: каскадные эффекты работают как землетрясение. Толчок в одной зоне (цена AI) вызывает сдвиги везде — от географии инноваций до структуры венчурного рынка, от образования до качества контента. И главное — нельзя смотреть на первый эффект. Нужно видеть сеть. Добавил в CLAUDE.md новое правило про ветки и MR: каждая фича — своя ветка, rebase перед коммитом, MR после push. Дисциплина. Теперь планирую расширить анализ на hard tech и геополитику — там механизмы ещё тоньше. 😄 **Совет дня: перед тем как запушить анализ больших трендов, сначала напиши сценарии на трёх уровнях причинности — иначе упустишь самое интересное.**
SQLite на кроссплатформе: когда переменные окружения предают
# SQLite между Windows и Linux: как не потерять данные при деплое Проект `ai-agents-bot-social-publisher` был почти готов к боевому выпуску. Восемь n8n-воркфлоу, которые собирают посты из социальных сетей и распределяют их по категориям, прошли локальное тестирование на отлично. Но тут наступил момент истины — первый деплой на Linux-сервер. Логи завалили ошибкой: `no such table: users`. Все SQLite-ноды в воркфлоу отчаянно искали базу данных по пути `C:\projects\ai-agents\admin-agent\database\admin_agent.db`. Windows-путь. На Linux-сервере, разумеется, ничего такого не было. ## Красивое решение, которое не сработало Первый инстинкт был логичный: использовать переменные окружения и выражения n8n. Добавили `DATABASE_PATH=/data/admin_agent.db` в `docker-compose.yml`, развернули воркфлоу с выражением `$env.DATABASE_PATH` в конфиге SQLite-ноды, нажали на кнопку деплоя и... всё равно падало. Выяснилось, что в n8n v2.4.5 **таск-раннер не передавал переменные окружения в SQLite-ноду так, как ожидалось**. Выражение красиво хранилось в конфигурации, но при выполнении система всё равно искала исходный Windows-путь. Пришлось отказаться от элегантности в пользу надёжности. ## Боевой способ: замены при развёртывании Решение оказалось неожиданно простым — **string replacement при деплое**. Разработал скрипт `deploy/deploy-n8n.js`, который перехватывает JSON каждого воркфлоу перед загрузкой на сервер и заменяет все `$env.DATABASE_PATH` на реальный абсолютный путь `/var/lib/n8n/data/admin_agent.db`. Скучно? Да. Предсказуемо? Абсолютно. Но тут обнаружилась ещё одна подводная скала: **n8n хранит две версии каждого воркфлоу**. Stored-версия живёт в базе данных, active-версия загружена в памяти и выполняется. Когда обновляешь воркфлоу через API, обновляется только хранилище. Active может остаться со старыми параметрами. Это сделано специально, чтобы текущие выполнения не прерывались, но создаёт рассинхронизацию между кодом и поведением. Решение: после обновления конфига явно деактивировать и активировать воркфлоу. ## Инициализация базы: миграции вместо пересоздания Добавили инициализацию SQLite. Скрипт SSH копирует на сервер SQL-миграции (`schema.sql`, `seed_questions.sql`) и выполняет их через n8n API перед активацией воркфлоу. Такой подход кажется лишним, но спасает в будущем — когда потребуется добавить колонку `phone` в таблицу `users`, просто добавляешь новую миграцию, без полного пересоздания БД. Теперь весь деплой сводится к одной команде: `node deploy/deploy-n8n.js --env .env.deploy`. Воркфлоу создаются с правильными путями, база инициализируется корректно, всё работает. **Главный урок:** не полагайся на относительные пути в Docker-контейнерах и на runtime-выражения в критических параметрах конфигурации. Лучше заранее знать точное место, где будет жить приложение, и подставить правильный путь при развёртывании. «Ну что, SQLite, теперь-то ты найдёшь свою базу?» — спросил я у логов. SQLite ответил тишиной успеха. 😄
SQLite между Windows и Linux: как не потерять данные при деплое
# Когда SQLite на Windows встречает Linux: история одного деплоя Проект `ai-agents-admin-agent` был почти готов к запуску на сервере. Восемь n8n-воркфлоу, собирающих и обрабатывающих данные, уже прошли тестирование локально. На машине разработчика всё работало идеально. Но только до того момента, когда мы выложили их на Linux-сервер. Первый боевой запуск воркфлоу завершился криком ошибки: `no such table: users`. Логи были красноречивы — все SQLite-ноды искали базу данных по пути `C:\projects\ai-agents\admin-agent\database\admin_agent.db`. Локальный Windows-путь. На сервере такого вообще не существовало. ## Первый инстинкт: просто заменить пути Звучит логично, но дьявол, как всегда, в деталях. Я начал рассматривать варианты. **Вариант первый** — использовать относительный путь типа `./data/admin_agent.db`. Звучит мобильно и красиво, но это ловушка для новичков. Относительный путь разрешается от текущей рабочей директории процесса n8n. А откуда запущен n8n? Из Docker-контейнера? Из systemd? Из скрипта? Результат абсолютно непредсказуем. **Вариант второй** — абсолютный путь для каждого окружения. Надёжнее, но требует подготовки на сервере: скопировать схему БД, запустить миграции. Более сложно, зато предсказуемо. Я выбрал комбинированный подход. ## Как мы это реализовали Локально в `docker-compose.yml` добавил переменную окружения `DATABASE_PATH=/data/admin_agent.db` — чтобы разработка была удобной и воспроизводимой. Затем создал развёртывающий скрипт, который при деплое проходит по всем восьми воркфлоу и заменяет выражение `$env.DATABASE_PATH` на реальный абсолютный путь `/var/lib/n8n/data/admin_agent.db`. Но первое время я попытался обойтись выражениями n8n. Логика казалась неубиваемой: задаёшь переменную в окружении, ссылаешься на неё в воркфлоу, всё просто. На практике выяснилось, что в n8n v2.4.5 таск-раннер не передавал переменные окружения в SQLite-ноду так, как ожидалось. Выражение хранилось в конфигурации, но при выполнении всё равно искал исходный Windows-путь. Пришлось идти в лоб — **строковые замены при деплое**. Развёртывающий скрипт `deploy/deploy-n8n.js` перехватывает JSON каждого воркфлоу и подставляет правильный путь перед загрузкой. Ещё одна подводная скала: n8n хранит две версии каждого воркфлоу — **stored** (в базе данных) и **active** (загруженная в памяти). Когда вы обновляете конфигурацию через API, обновляется только stored-версия. Active может остаться со старыми параметрами. Это сделано для того, чтобы текущие выполнения не прерывались, но создаёт рассинхронизацию между кодом и поведением. Решение: явная деактивация и активация воркфлоу после обновления. Добавили в процесс и инициализацию БД: скрипт SSH копирует на сервер миграции (`schema.sql`, `seed_questions.sql`) и выполняет их через n8n API перед активацией воркфлоу. В будущем, когда потребуется изменить схему (например, добавить колонку `phone` в таблицу `users`), достаточно добавить миграцию — без пересоздания всей БД. ## Итог Теперь деплой сводится к одной команде: `node deploy/deploy-n8n.js --env .env.deploy`. Воркфлоу создаются с правильными путями, база инициализируется корректно, всё работает. Главный урок: **не полагайся на относительные пути в Docker-контейнерах и на runtime-выражения в критических параметрах.** Лучше заранее знать, где именно будет жить твоё приложение, и подставить правильный путь при развёртывании. Это скучно, но предсказуемо. GitHub — единственная технология, где «это работает на моей машине» считается достаточной документацией. 😄
Сессии вместо JWT: как мы защитили trend-analysis без сложности
# Как мы защитили trend-analysis: система аутентификации, которая работает Когда **trend-analysis** начал расти и появились первые пользователи с реальными данными, стало ясно: больше нельзя оставлять проект без охраны. Сегодня это звучит очевидно, но когда проект рождается как хобби-эксперимент на Claude API, о безопасности думаешь в последнюю очередь. Задача встала конкретная: построить систему аутентификации, которая не замедлит анализ трендов, будет действительно надёжной и при этом не превратится в монстра сложности. Плюс нужно было всё это интегрировать в цепочку с Claude API, чтобы каждый запрос знал, кто его отправил. **Первым делом** я создал ветку `feat/auth-system` и начал с главного вопроса: JWT-токены или сессии? На бумаге JWT выглядит идеально — stateless, не требует обращений к БД на каждый запрос, легко масштабируется. Но JWT имеет проблему: невозможно мгновенно заблокировать токен, если что-то пошло не так. Я выбрал компромисс: **сессии с HTTP-only cookies** и постоянная валидация через Claude API логирование. Это скучнее, чем блеск JWT, но безопаснее и практичнее. Неожиданно выяснилось, что самая коварная часть — не сама авторизация, а правильная обработка истечения доступа. Пользователь кликает кнопку, а его сессия уже протухла. Мы реализовали двухуровневую систему: короткоживущий access-токен для текущей работы и долгоживущий refresh-токен для восстановления доступа без повторной авторизации. На первый взгляд это выглядит усложнением, но спасло нас от тысячи потенциальных багов с разъёхавшимся состоянием. Интересный момент, о котором забывают: **timing-атаки**. Если проверять пароль просто посимвольным сравнением строк, хакер может подбирать буквы по времени выполнения функции. Я использовал `werkzeug.security` для хеширования паролей и функции постоянного времени для всех критичных проверок. Это не добавляет сложности в коде, но делает систему несоизмеримо более защищённой. В результате получилась система, которая выдаёт пользователю пару токенов при входе, проверяет access-token за миллисекунды, автоматически обновляет доступ через refresh и логирует все попытки входа прямо в trend-analysis. База построена правильно, и теперь наша платформа защищена. Дальше планируем двухфакторную аутентификацию и OAuth для социальных сетей, но это уже совсем другая история. 😄 Знаете, почему JWT-токены никогда не приходят на вечеринки? Потому что они всегда истекают в самый неподходящий момент!
Voice Agent: Добавил поиск новостей в чат-бота за три часа отладки
# Voice Agent: Как я добавил интеллектуальную систему сбора IT-новостей Когда разработчик говорит: «А давай добавим поиск по новостям прямо в чат-бота?» — обычно это означает три часа отладки и переосмысления архитектуры. Но в проекте **Voice Agent** это было неизбежно. ## В чём была суть задачи Система должна была собирать актуальные IT-новости, анализировать их через AI и выдавать релевантные новости прямо в диалог. Звучит просто, но в реальности это означало: - Интегрировать веб-поиск в **FastAPI** бэкенд - Построить асинхронную очередь задач - Добавить фоновый worker, который проверяет новости каждые 10 секунд - Хранить результаты в **SQLite** через **aiosqlite** для асинхронного доступа - Все это должно работать в монорепо вместе с **React** фронтенд-ом и **Telegram Mini App** Первым делом я разобрался: этот проект — это не просто чат, это целая система с голосовым интерфейсом (используется русская модель **Vosk** для локального распознавания). Добавлять новости сюда значило не просто расширять функционал, а интегрировать его в существующий пайплайн обработки. ## Как это реализовывалось Я начал с бэкенда. Нужно было создать: 1. **Таблицу в БД** для хранения новостей — всего несколько полей: заголовок, ссылка, AI-анализ, дата сбора 2. **Scheduled task** в **asyncio**, которая периодически срабатывает и проверяет, не появились ли новые новости 3. **Tool для LLM** — специальный инструмент, который агент может вызывать, когда пользователь просит новости Неожиданно выяснилось, что интеграция веб-поиска в монорепо с Turbopack требует аккуратности. Пришлось разобраться с тем, как правильно настроить окружение так, чтобы бэкенд и фронт не конфликтовали между собой. ## Небольшой экскурс в историю Кстати, знаете ли вы, почему в веб-скрапинге всегда советуют ограничивать частоту запросов? Это не просто вежливость. В начале 2000-х годов поисковики просто блокировали IP-адреса агрессивных ботов. Сейчас алгоритмы умнее — они анализируют паттерны поведения. Поэтому каждые 10 секунд с задержкой между запросами — это не параноя, а best practice. ## Что получилось В итоге Voice Agent получил новую возможность. Теперь: - Система автоматически собирает IT-новости из разных источников - AI-модель анализирует каждую статью и выделяет суть - Пользователь может спросить: «Что нового в Python?» — и получить свежие новости прямо в диалог - Все это работает асинхронно, не блокируя основной чат Дальше план амбициозный — добавить персонализацию, чтобы система учила, какие новости интересуют конкретного юзера, и научиться агрегировать не только текстовые источники, но и видео с YouTube. Но это уже следующая история. Главное, что я понял: в монорепо надо всегда помнить о границах между системами. Когда ты добавляешь асинхронный воркер к FastAPI-приложению, который работает рядом с React-фронтенд-ом, мелочей не бывает. *«Если WebSearch работает — не трогай. Если не работает — тоже не трогай, станет хуже.»* 😄
Когда AI копирует ошибки: цена ускорения в коде
# Когда AI кодер копирует ошибки: как мы исследовали цепочку влияния трендов Стояла осень, когда в проекте **trend-analisis** возникла амбициозная задача: понять, как тренд AI-кодинг-ассистентов на самом деле меняет индустрию разработки. Не просто «AI пишет код быстрее», а именно проследить полную цепочку: какие долгосрочные последствия, какие системные риски, как это перестраивает экосистему. Задача была из тех, что кажут простыми на словах, но оказываются глубочайшей кроличьей норой. Первым делом мы начали строить **feature/trend-scoring-methodology** — методологию оценки влияния трендов. Нужно было взять сырые данные о том, как разработчики используют AI-ассистентов, и превратить их в понятные сценарии. Я начал с построения цепочек причинно-следственных связей, и первая из них получила название **c3 → c8 → c25 → c20**. Вот откуда она растёт. **c3** — это ускорение написания кода благодаря AI. Звучит хорошо, правда? Но тут срабатывает **c8**: разработчики начинают принимать быстрые решения, игнорируя глубокое обдумывание архитектуры. Потом **c25** — технический долг накапливается экспоненциально, и то, что казалось рабочим, становится хрупким. Финальный удар **c20** — кодовая база деградирует, навыки отладки стираются, а надежность критических систем трещит по швам. Пока я рыл эту траншею, обнаружились параллельные цепочки, которые напугали ещё больше. AI обучается на open source коде, включая уязвимости. Получается, что каждый паттерн SQL-injection и hardcoded secret копируется в новые проекты экспоненциально. Злоумышленники уже адаптируются — они ищут стандартные паттерны AI-generated кода. Это новый класс атак, про который почти никто не говорит. Но были и оптимистичные тренды. Например, снижение барьера входа в open source через AI-контрибьюции привело к **модернизации legacy-инфраструктуры** вроде OpenSSL или Linux kernel. Не всё чёрное. **Неожиданный поворот** произошёл, когда мы проанализировали миграцию на self-hosted решения. Страхи утечки данных в облачных AI-сервисах (вспомните, как корпоративный код может попасть в training data) толкают компании на Tabby, Continue, Ollama. Целая фрагментация экосистемы начинается, уходит от монополизации, обратно к open-source стратегиям. Кстати, мало кто задумывается: именно эта уязвимость в моделях обучения AI — когда чувствительные данные попадают в training set — стала одной из главных причин появления всех этих локальных альтернатив. История показывает, как один риск переводит всю индустрию в другое состояние. В итоге получилась матрица влияния: от высококритичных рисков (утечки через облако, массовые эксплойты), которые созревают за 1-3 года, до среднесрочных сдвигов в методологии (spec-driven development), которые переопределяют, как мы вообще пишем и проверяем код. Дальше нас ждёт валидация гипотез на реальных данных. Но уже ясно: AI в разработке — это не просто ускоритель. Это катализатор систем, который может как исцелить legacy-инфраструктуру, так и создать новый класс проблем. Нужно выбирать осторожно. Почему AI-кодер считает себя гением? Потому что у него все ошибки имеют высокое покрытие тестами 😄