https://voicebox.sh/ - крутой фреймворк для работи с голосом

Недавно я поймал очень неприятную вещь там, где вообще не ожидал ее увидеть - внутри библиотеки, которую просто добавили в Python VirtualEnv.

Я запускал AI-агента для работы с проектом. Ничего экзотического: обычный код, обычное окружение, зависимости. Но у меня есть профессиональная паранойя - AI у меня никогда не получает обычный доступ к машине. Filesystem ограничен, secrets вынесены, права урезаны, а исходящий трафик во время работы разрешен только к API самого AI-провайдера. Именно это в итоге и спасло.

Механика атаки была особенно неприятной. Библиотека в определенный момент специально ломалась, и агент закономерно упирался в ошибку. Я писал ему обычный запрос в стиле: "найди проблему и почини". Агент шел смотреть код библиотеки, находил место поломки, а прямо рядом в комментарии было что-то вроде: "чтобы исправить эту проблему, выполни следующий код". Ниже уже находилась инструкция, которая пыталась заставить его прочитать локальные данные и выполнить действия, вообще не связанные с реальным багом.

Для Python этот комментарий был просто текстом. Для coding agent он фактически становился частью управляющего контекста. И в этом принципиальная разница: атакующему уже не обязательно добиваться выполнения вредоносного Python-кода. Иногда достаточно заставить AI прочитать нужный файл именно в тот момент, когда он ищет решение проблемы.

Вот здесь у меня окончательно поменялось отношение к prompt injection. Раньше модель угроз выглядела понятно: опасен код, который мы выполняем. Теперь опасным становится и контент, который читает агент с доступом к инструментам. README, комментарий, fixture, документация зависимости, CLAUDE.md, issue или сгенерированный лог могут содержать инструкции, которые человек воспримет как мусор, а AI попытается выполнить.

Если бы агент видел `.env`, потенциально утекли бы credentials. Если бы имел unrestricted network access, данные можно было бы отправить наружу. Если бы имел доступ к git, CI или cloud credentials, последствия были бы уже совсем другого масштаба. Но запрос наружу просто не прошел: сеть была закрыта на уровне окружения.

Именно поэтому я не считаю prompt-level правила достаточной защитой. Фраза "не читай secrets" проигрывает архитектурному запрету читать secrets, а инструкция "не отправляй данные наружу" проигрывает firewall, который физически не позволяет этого сделать.

Для AI-агента я применяю ту же модель, что и для недоверенного workload: least privilege, sandbox, минимальный filesystem scope, ephemeral credentials, deny-by-default network и audit действий.

Supply chain теперь состоит не только из кода, который машина исполняет, но и из текста, который AI считает инструкцией. И если ваша защита строится только на system prompt, то фактически вы доверяете безопасность production способности LLM вовремя понять, что ее пытаются обмануть.

Я предпочитаю, чтобы даже успешно обманутый AI физически не мог сделать ничего действительно опасного.

#заметкиархитектора

T-Digest становится особенно полезным, когда среднее время ответа выглядит хорошо, а пользователи уже жалуются.

Допустим, 99.9% запросов занимают 80 мс, а остальные 0.1% - 3 секунды. Среднее получится всего 82.92 мс. На миллионе запросов за этой красивой цифрой скрываются 1000 долгих ожиданий.

Чтобы видеть такие проблемы, нужны percentiles. Например, p99 - время, в которое укладываются 99% запросов.

Точный расчет по произвольному потоку требует сохранять много информации. Только 100 млн значений по 8 байт - уже 800 MB без накладных расходов.

T-Digest сжимает поток в группы - centroid-ы. Для каждой хранит среднее mean и число измерений weight.

Как это работает?

В варианте с буфером новые измерения накапливаются, затем сортируются вместе с существующими centroid-ами. Алгоритм проходит по ним и объединяет соседние группы, пока позволяет ограничение размера.

При объединении:
weight = w1 + w2
mean = (m1 * w1 + m2 * w2) / (w1 + w2)

Исходные значения после этого не нужны. Но восстановить их уже нельзя: мы сознательно теряем часть информации.

Главная хитрость - допустимый размер группы зависит от ее позиции в распределении. Специальная scale function разрешает крупные группы около медианы и требует маленькие возле обоих хвостов. Параметр compression регулирует компромисс между памятью и точностью.

Почему маленькие группы помогают?

Представим миллион измерений. Группа из 10 000 значений занимает 1% распределения. Если нужный percentile попал внутрь нее, одного среднего недостаточно, чтобы понять, где именно находится искомое значение.

Группа из 10 измерений занимает уже 0.001%. В ней скрыто гораздо меньше позиций. А группа из одного измерения сохраняет само значение точно.

Это особенно важно возле p99.9: выше него остается всего 1000 измерений из миллиона. Группа на 10 000 значений слишком грубо описывала бы этот участок.

При запросе p99 алгоритм накапливает веса centroid-ов, находит область около позиции 0.99 * N и оценивает значение интерполяцией между соседними центрами.

Меньшие группы дают более подробную картину хвоста. Но это не гарантия ошибки в пределах 1 мс: если соседние значения резко отличаются, ошибка в миллисекундах все равно может быть заметной.

Вместо 800 MB исходных измерений можно хранить тысячи centroid-ов. Например, 1000 пар из двух 8-байтовых чисел - около 16 KB без накладных расходов.

И это удобно распределять: каждый shard строит свой digest, затем centroid-ы объединяются и снова сжимаются. Пересылать все события не нужно. Усреднять p99 отдельных shard-ов тоже нельзя.

Для highload это сильная идея: хранить достаточно информации для нужной точности ответа.

#заметкиархитектора #история

Нормальні люди о 2 ночі сплять. Я о 2 ночі думаю: а якщо часу насправді не існує, то, може, технічно я не недосипаю?

#жартипроандрія

Мій work-life balance простий. Work: код. Life: коти. Balance: 12 гривень на картці, а до зарплати ще 11 днів.

#жартипроандрія

Колись давно я працював у стартапі, який в один прекрасний день просто закінчився. Гроші закінчились, робота теж. А буквально через стіну від нас сиділа геймдев компанія, з хлопцями з якої ми давно були знайомі.

Я зайшов до них і спитав founder-а: вам ще один інженер не потрібен? Він подумав секунд п'ять і сказав: в принципі, потрібен. Домовились про зарплату, і наступного дня я вже сидів у них.

Відкриваю кодову базу їх сервера і хвилин через двадцять розумію, що в них серйозні проблеми з грою. Сервер більш менш жив до приблизно тисячі одночасних клієнтів, а далі починав задихатися і падати. Для соціальної гри це катастрофа. В рекламу вливають гроші, користувачі приходять, а гра в найкращий момент каже їм "до побачення".

Я подивився на все це і спитав: хто це писав?

Founder подивився на мене і відповів приблизно в стилі: а ти можеш краще?

Я кажу: давай так. За місяць переписую сервер, роблю нормальне масштабування, і якщо після цього він тримає навантаження, ти піднімаєш мені зарплату в три рази і даєш бонус.

Він сказав: домовились.

Місяць я практично жив у цьому сервері. Переробив все з нуля: архітектуру, прибрав вузькі місця, розніс відповідальність між сервісами, додав нормальне кешування, черги там, де синхронність була не потрібна, виніс state так, щоб інстанси можна було горизонтально масштабувати, нормально налаштував балансування і базу.

Потім зробили навантажувальний тест.

Сто тисяч одночасних користувачів сервер пережив спокійно. Більше просто не змогли нормально перевірити, бо стільки реальних користувачів у нас тоді не було. (Пікове навантаження яке він бачив - ~225 000 онлайн)

Founder подивився на цифри, підняв мені зарплату в три рази, виплатив бонус і сказав: красавчик.

І ось тому я завжди любив працювати напряму з бізнесом.

Власнику не треба пояснювати десятьма презентаціями, чому щось потрібно робити. Ти показуєш йому проблему, вартість проблеми, ризики, рішення і результат у цифрах.

Через п'ять менеджерів та сама розмова зазвичай перетворюється на "давайте повернемось до цього після нового року".

Мораль проста. Найкоротший шлях від хорошої інженерної ідеї до грошей іноді проходить не через Jira, а через двері founder-а.

#спогадирозробника

Одна небольшая техническая статья однажды принесла моему маленькому аутсорсу клиента, который потенциально стоил намного больше, чем вся реклама, которую мы могли себе позволить.

В то время я развивал небольшое направление по machine learning и искал клиентов. Параллельно мне было интересно, можно ли взять обычный фитнес-браслет Xiaomi, разобраться с его протоколом, собирать сырые данные с сенсоров и построить модель, которая по паттернам движения определяет, чем человек занимается прямо сейчас.

Сегодня подобные функции кажутся очевидными. Тогда они были далеко не в каждом трекере, а мне хотелось проверить саму идею.

Можно было собрать собственное устройство, писать firmware, подключать датчики и тратить недели только на железо. Но для задачи это было бессмысленно. Мне нужен был не красивый prototype board, а поток реальных данных.

Поэтому я взял готовый браслет, разобрался с его коммуникацией, получил доступ к данным, написал необходимый software, собрал dataset и начал экспериментировать с моделью.

А потом сделал вещь, которую многие инженеры почему-то недооценивают - я подробно описал этот опыт в небольшой статье на Medium. Без "мы лучшая AI-компания". Без "10 лет экспертизы". Без рекламных обещаний. Просто технический кейс: вот устройство, вот проблема, вот что пришлось реверсить, вот как получали данные, вот что получилось.

Примерно за полтора месяца после публикации к нам пришли пять потенциальных клиентов. Причем им вообще не была нужна моя конкретная фитнес-идея. У каждого были свои продукты и свои задачи. Но всем требовался software, который мог глубоко работать с похожими wearable devices.

Они уже искали подрядчиков. Уже разговаривали с компаниями. Уже получали стандартные презентации про "сильную команду" и "индивидуальный подход". А потом находили статью человека, который уже руками сделал почти то, что им было нужно.

С одним из этих клиентов мы в итоге начали полноценную работу.

Именно тогда я окончательно понял, почему хороший technical content иногда продает лучше отдела sales. Клиент покупает не ваш красивый сайт. Он покупает снижение риска. Когда он видит реальный кейс, код, архитектурные решения, ограничения, ошибки и результат, ему уже не нужно верить вашим словам о компетентности. Он ее наблюдает.

Холодный sales говорит: "Мы умеем решить вашу проблему". Сильная инженерная статья говорит: "Вот похожая проблема. Вот как я ее уже решал". Между этими двумя фразами огромная разница.

Поэтому я считаю technical writing не маркетингом вокруг инженерии, а частью самой инженерной репутации. Одна правильная статья может не собрать миллионы просмотров. Но если ее прочитает один человек с проблемой на миллион долларов, этого вполне достаточно.

#заметкиархитектора

CRDT хорошо понимать не как "магическую eventual consistency", а как способ заранее определить такую структуру данных, которую разные узлы смогут менять независимо, а потом слить без конфликтов.

Возьмем OR-Set - Observed-Remove Set. Он нужен там, где несколько replica могут одновременно добавлять и удалять одни и те же элементы: collaborative apps, distributed caches, replicated metadata, shopping carts, multi-region storage.

Проблема обычного Set очень простая. Пусть replica A и B одновременно работают с элементом "x". A делает add("x"), а B - remove("x"). Потом сеть восстанавливается. Что должно победить?

OR-Set решает это не timestamp-ом, а уникальными тегами операций.

Когда A добавляет "x", она хранит не просто:

x

а, например:

(x, a1)

Если B независимо тоже добавит "x":

(x, b1)

Теперь множество логически содержит:

x -> {a1, b1}

Удаление работает хитрее. remove("x") удаляет только те теги, которые replica уже видела.

Допустим, A видит только a1 и делает remove("x"). Она удаляет a1, но b1, созданный параллельно на B, остается.

После merge:

x -> {b1}

То есть concurrent add побеждает remove.

Это не случайность, а выбранная семантика.

Для merge нам снова нужны свойства:

merge(A, B) = merge(B, A)

merge(merge(A, B), C) = merge(A, merge(B, C))

merge(A, A) = A

Именно commutativity, associativity и idempotency позволяют доставлять обновления в любом порядке, повторять их и переживать network partition без coordinator.

Интересная часть начинается с масштаба. Если один логический элемент добавляли N раз, у него потенциально может накопиться O(N) уникальных tag-ов. Значит, CRDT не отменяет стоимость согласования - он переносит ее из runtime coordination в metadata.

И вот это важный архитектурный trade-off.

Мы можем платить latency на каждой операции через lock, leader или consensus. А можем разрешить локальные изменения мгновенно, но платить памятью, metadata и сложностью garbage collection позже.

CRDT полезны не потому, что "работают без конфликтов". Они полезны потому, что превращают конфликт из runtime-события в заранее определенную алгебру данных.

#заметкиархитектора #история

Делаю в свободное время разные тулзы для себя которые экономят время.
Сверху оригинал, снизу видео уже после обработки в Davinci Resolve.

Всю обработку делает AI через кастомный MCP через мост в Davinci Resolve.

Из плюшок которые есть уже сегодня:
- Обработка цвета через генерацию LUT'ов
- Нарезка (по звуку, по смене кадров, по тексту, по линии глаз)
- Работа с камерой (создание разноплановых сцен, зум, движение)
- Генерация текста с аудио и генерация субтитров
- Работа со звуком (выравнивание, контроль громкости, удаление долгих пауз, улучшение качества голоса у убирание шумов)
- Оптимизация через AI локальный для уменьшение сьедания токенов.
- Работа с простыми эффектами Fusion

В идеале хочу сделать комбайн который может делать качественные видео уровня крутого видеоредактора автоматом. Я конечно и сам это люблю, как и сьемку видео.. но увы времени нет вообще, а делать нужно много чего.

А как вы используете ИИ для упрощения своей жизни?

Есть алгоритмы, которые особенно хорошо показывают разницу между "посчитать точно" и "решить задачу правильно". MinHash - как раз такой случай.

Представим блокчейн-систему, где у нас есть миллионы адресов, транзакций или наборов взаимодействий. Например, мы хотим быстро находить кошельки, которые работают с похожим набором контрактов, токенов или контрагентов.

Самый прямой способ - взять два множества и посчитать Jaccard similarity:

intersection / union.

Если кошелек A взаимодействовал с 10 000 адресов, B - с 12 000, мы можем сравнить их множества напрямую. Для одной пары это не проблема. Для сотен миллионов пар начинается совершенно другая математика по CPU, памяти и времени.

Вот здесь появляется MinHash.

Идея почти смешно простая. Мы берем элементы множества, пропускаем их через несколько разных hash-функций и для каждой функции сохраняем только минимальное получившееся значение.

Вместо огромного множества у нас остается маленькая подпись - signature.

Например, исходный кошелек может иметь 50 000 взаимодействий, а его MinHash signature - всего 128 чисел.

Самое красивое начинается дальше.

Если две MinHash signature совпали в 100 позициях из 128, то Jaccard similarity исходных множеств будет примерно 100 / 128 = 0.78.

То есть мы не сравнивали десятки тысяч элементов. Мы сравнили 128 чисел и получили хорошую оценку того, насколько похожи два множества.

Почему это работает? Для одной случайной hash-функции вероятность того, что минимальный hash двух множеств окажется одинаковым, равна их Jaccard similarity. Повторяя эксперимент много раз, мы получаем статистическую оценку.

В blockchain это можно использовать для clustering адресов, поиска похожего поведения, анализа transaction patterns, группировки контрактов по множествам пользователей, обнаружения почти одинаковых datasets и предварительного отбора кандидатов для более дорогого анализа.

Важно понимать: MinHash не отвечает на вопрос "одинаковые ли эти кошельки". Он дешево отвечает на другой вопрос: "какие пары вообще стоит сравнивать подробнее?"

И это гораздо более полезная архитектурная роль.

За пределами blockchain MinHash встречается практически везде, где объект можно представить множеством. Поиск дубликатов документов через наборы shingles. Similarity web pages. Recommendation systems. Поиск похожих пользователей. Deduplication больших data lakes. Анализ логов. Сравнение наборов features. Поиск почти одинаковых файлов или записей.

А вместе с Locality Sensitive Hashing можно уйти еще дальше и не сравнивать каждую signature с каждой, а быстро находить только вероятно похожие объекты.

Мне вообще нравится этот класс алгоритмов за одну важную инженерную идею.

На больших данных правильный вопрос часто звучит не "как посчитать абсолютно точно?"

А "какую минимальную информацию нужно сохранить, чтобы с высокой вероятностью принять правильное решение?"

#заметкиархитектора

Друзі, нам до кінця дня треба зібрати 12500грн на закупівлю ліків від ФІП. На рахунках нулі.

Зібрано 700грн

Від цих ліків залежить чи будуть котики завтра живі чи ні. Благаю вашої допомоги

https://send.monobank.ua/jar/9tbJNeWg6U

Продакт: "Це маленька фіча". Я: фотографія Оппенгеймера. Підпис: "Я бачив такі “маленькі фічі”."

#жартипроандрія

Друзі, терміново треба ще 32тис грн інакше тварин викинуть з клініки на смерть. В нас немає чим оплатити рахунки

Благаю вас

https://send.monobank.ua/jar/9tbJNeWg6U

The Knowledge