Show HN: Kapso – Iterative Learning from Enterprise Data

Show HN: Kapso – Iterative Learning from Enterprise Data

Alireza and Majid launch Kapso, an iterative AI platform for enterprise data, built with Docker, metrics, CLI and Git, using LinkedIn and Meta experience.

Kapso: итеративное обучение на enterprise‑данных

Итеративный цикл обучения

Во-первых, для начала собираем набор enterprise‑данных, который будет использоваться в процессе обучения. Обычно это SQL‑таблицы, CSV‑файлы или логи, размещённые в PostgreSQL или в файловой системе домашнего сервера. Пример структуры проекта:

yamlКопировать
# docker-compose.yml
version: "3.9"
services:
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: kapso
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: kapso_data
    volumes:
      - db_data:/var/lib/postgresql/data

  trainer:
    build: ./trainer
    depends_on:
      - db
    environment:
      DATABASE_URL: postgresql://kapso:secret@db:5432/kapso_data
    volumes:
      - ./data:/app/data
    command: ["python", "train.py"]
volumes:
  db_data:

После запуска docker compose up -d контейнер trainer подключается к базе, читает данные из /app/data, формирует обучающую выборку и начинает обучение. В процессе обучения метрики (loss, accuracy, через‑put) пишутся в стандартный вывод, а также отправляются в Prometheus Pushgateway:

pythonКопировать
# trainer/train.py (фрагмент)
import time, json, requests

def push_metric(name, value):
    url = "http://prometheus-pushgateway:9090/metrics/job/kapso_trainer"
    payload = f"{name} {value}\n".encode()
    requests.post(url, data=payload)

for epoch in range(epochs):
    loss = train_step()
    accuracy = evaluate()
    push_metric("kapso_training_loss", loss)
    push_metric("kapso_training_accuracy", accuracy)
    time.sleep(1)

После завершения эпохи метрики сохраняются в базе metrics (например, в InfluxDB), а также фиксируются в Git‑репозитории как часть артефактов:

bashКопировать
git add trainer/logs/2024-10-01.log
git commit -m "log epoch 12: loss=0.342 accuracy=0.876"
git push origin main

Во‑вторых, полученные метрики используют для оценки прогресса. Если метрика kapso_training_loss снижается, а kapso_training_accuracy растёт, значит модель улучшается. При обратном тренде (рост loss, падение accuracy) цикл переходит к фазе re‑evaluation: данные фильтруются, параметры гиперпараметров подбираются заново, а конфигурация Docker‑образа обновляется. Такой подход обеспечивает предсказуемость и воспроизводимость результатов.

Примечание. Для удобства анализа графиков удобно использовать готовый дашборд в Grafana, который подключается к Prometheus. Пример дашборда можно посмотреть в статье Как AI‑агент рисует графику в редакторе Klad.

Как метрики формируют прогресс

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

1. Сбор логов. Каждый запуск trainer записывает в файл logs/YYYY-MM-DD_HH-MM-SS.log JSON‑строки с полями epoch, loss, accuracy, timestamp. Скрипт parse_logs.py агрегирует их и формирует метрику kapso_training_iteration:

pythonКопировать
# parse_logs.py (фрагмент)
import glob, json, requests

def aggregate_logs():
    metrics = {}
    for file in glob.glob("logs/*.log"):
        with open(file) as f:
            for line in f:
                entry = json.loads(line)
                key = f"kapso_training_iteration{entry['epoch']}"
                metrics[key] = metrics.get(key, 0) + entry["loss"]
    return metrics

def push_all(metrics):
    url = "http://prometheus-pushgateway:9090/metrics/job/kapso_trainer"
    for k, v in metrics.items():
        payload = f"{k} {v}\n".encode()
        requests.post(url, data=payload)

push_all(aggregate_logs())

2. Связывание с Git. При каждом git commit в репозитории автоматически создаётся тег версии, который попадает в метрику kapso_git_commit. Это позволяет отследить, какая версия кода и какие данные использовались при конкретном запуске обучения:

bashКопировать
git tag -a v1.2.3 -m "release with new feature X"
git push origin v1.2.3

3. Оценка прогресса. На основе метрик kapso_training_loss, kapso_training_accuracy и kapso_git_commit формируется простая формула прогресса:

progress = (accuracy_delta / loss_delta) * weight_commit

Где accuracy_delta и loss_delta — разницы между текущим и предыдущим запуском, а weight_commit учитывает, насколько изменился код (например, количество изменённых файлов). Формула реализуется в Grafana‑панеле и отображается в виде Gauge‑дашборда.

4. Автоматический триггер пере‑обучения. Если progress падает ниже порога (например, 0.5), CI‑pipeline (GitHub Actions) запускает новый контейнер trainer с обновлёнными гиперпараметрами. Пример workflow‑файла:

yamlКопировать
# .github/workflows/retrigger.yml
name: Re‑train on regression
on:
  push:
    branches: [ main ]
jobs:
  train:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Build trainer image
        run: docker build -t kapso/trainer ./trainer
      - name: Run trainer
        run: docker run --rm -e DATABASE_URL=... kapso/trainer

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

Ссылка на аналогичный подход: подробнее о локальном AST‑парсинге и формировании метрик в проекте Graphify‑Labs можно прочитать в статье Graphify‑Labs/graphify: локальный AST‑парсинг кода и docs.

Архитектура Kapso: Docker, CLI и Git

Архитектура Kapso: Docker, CLI и Git

Контейнеризация с Docker и Docker Compose

Для развертывания Kapso в домашней лаборатории удобно использовать Docker‑Compose — это позволяет описать все сервисы в одном файле и управлять ими через привычные команды docker compose up и docker compose down.

В качестве базовых образов берём лёгкие Alpine‑based образы, а для production‑версий — Debian‑based, чтобы иметь более полный набор утилит. При помощи мульти‑стейдж Dockerfile можно собрать кастомный образ kapso‑api, включающий все зависимости и готовый к запуску.

dockerfileКопировать
# syntax = docker/dockerfile:1
FROM alpine:3.19 AS builder
RUN apk add --no-cache git make gcc musl-dev
WORKDIR /src
COPY . .
RUN make build

FROM alpine:3.19
COPY --from=builder /src/bin/kapso /usr/local/bin/kapso
ENTRYPOINT ["kapso"]

yamlКопировать
version: "3.8"
services:
  kapso-api:
    image: kapso/api:latest
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://kapso:secret@postgres:5432/kapso
    depends_on:
      - postgres
  kapso-worker:
    image: kapso/worker:latest
    depends_on:
      - kapso-api
  postgres:
    image: postgres:15
    environment:
      - POSTGRES_USER=kapso
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=kapso
    volumes:
      - pg_data:/var/lib/postgresql/data
volumes:
  pg_data:

• Почему Docker Compose?

  • Позволяет задать зависимости между контейнерами (worker → api → postgres).
  • Упрощает локальное тестирование — все сервисы поднимаются одной командой.
  • Описывает сети, volumes и переменные окружения в Declarative‑стиле, что соответствует подходу «инфраструктура как код».

• Мульти‑стейдж сборка (пример выше) гарантирует, что в финальном образе нет лишних инструментов сборки, что уменьшает размер и повышает безопасность.

CLI‑инструменты для управления данными

Kapso поставляется с набором консольных утилит, которые позволяют полностью управлять данными, конфигурацией и Git‑репозиторием. Все команды имеют одинаковый синтаксис и выводятся в stdout / stderr, что упрощает их интеграцию в скрипты и CI/CD‑пайплайны.

bashКопировать
# Инициализация нового проекта с указанием схемы данных
kapso data init --name demo --schema ./schema.json

# Инжекция данных из CSV‑файла в PostgreSQL
kapso data ingest --source ./data.csv --target postgres

# Установка конфигурационного ключа
kapso config set --key log_level --value info

# Клонирование конфигурационного репозитория Git
kapso git clone --repo https://github.com/kapso/configs.git --path ./configs

• Инициализация проекта – создаёт структуру каталогов, копирует пример схемы и готовит базу данных.
• Инжекция данных – поддерживает различные источники (CSV, JSON, SQL) и автоматически синхронизирует схему с базой.
• Конфигурация – все параметры Kapso (уровень логов, пути к хранилищу, URL‑ы) хранятся в Git‑репозитории, что обеспечивает аудит изменений.
• Git‑интеграция – позволяет treat конфигурацию как код: kapso git pull обновляет локальные настройки, kapso git push отправляет изменения в удалённый репозиторий.

При работе с данными важно соблюдать предсказуемость: каждый запуск CLI‑команды фиксирует входные параметры в журнале (journald) и в отдельном файле kapso.log. Это упрощает отладку и позволяет восстановить состояние после сбоя.

Для более продвинутого использования знани‑гропа удобно хранить схемы в Git и подключать их к локальному AST‑парсеру, описанному в Graphify‑Labs/graphify. Это даёт возможность задавать запросы к схеме без написания собственного кода.

---

Во‑первых, Docker Compose обеспечивает воспроизводимую среду, а CLI‑инструменты делают управление данными предсказуемым и audit‑able.
С практической точки зрения, если вы уже используете Git для хранения конфигураций, то Kapso полностью вписывается в ваш текущий workflow без дополнительного learning‑curve.

Метрики и мониторинг: измеряем качество модели

Метрики и мониторинг: измеряем качество модели

В Kapso подход к мониторингу строится на принципе предсказуемости. Если мы не можем измерить точность ответов модели на конкретном наборе корпоративных данных, то всё обучение превращается в гадание на кофейной гуще. Разработчики платформы, опираясь на опыт в LinkedIn и Meta, реализовали систему, которая позволяет отслеживать не только техническое состояние контейнеров, но и содержательную корректность работы AI.

Сбор метрик в реальном времени

Для того чтобы понимать, как модель справляется с нагрузкой и качеством данных, Kapso использует связку Docker и специализированных экспортеров. С практической точки зрения важно разделять инфраструктурные метрики (загрузка CPU, использование памяти контейнером) и бизнес-метрики (latency ответа, точность извлечения сущностей).

Все компоненты Kapso разворачиваются через Docker Compose, что позволяет быстро подключить Prometheus для сбора данных. Чтобы мониторинг был полноценным, необходимо настроить сбор метрик из CLI-интерфейса и внутренних сервисов.

Пример базового конфига docker-compose.yml для организации мониторинга в локальной лаборатории:

yamlКопировать
services:
  # Основной сервис Kapso
  kapso-engine:
    image: kapso/engine:latest
    container_name: kapso-engine
    restart: unless-stopped
    networks:
      - monitoring-net
    # Включаем экспорт метрик через встроенный эндпоинт
    command: ["--metrics-port", "8080"]

  # Prometheus для сбора и хранения метрик
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    networks:
      - monitoring-net

networks:
  monitoring-net:
    driver: bridge

Конфигурация Prometheus (prometheus.yml) должна явно указывать на эндпоинт Kapso:

yamlКопировать
scrape_configs:
  - job_name: 'kapso-metrics'
    static_configs:
      - targets: ['kapso-engine:8080']

Если вы хотите глубже разобраться в том, как современные инструменты помогают визуализировать сложные процессы, рекомендую изучить материал про как AI-агент рисует графику в редакторе Klad. Хотя это другой кейс, принцип визуализации данных через агентов здесь пересекается.

Анализ эффективности и оптимизация

Сбор данных — это только половина дела. Настоящая ценность Kapso заключается в итеративном подходе: мы берем метрики, находим слабые места в знаниях модели и обновляем базу данных. Это напоминает работу с графами знаний, где важно понимать связи между документами и запросами.

Для анализа того, как модель интерпретирует код или документацию, можно использовать подходы, описанные в руководстве по локальному AST-парсингу кода и docs. В Kapso этот процесс автоматизирован: система сравнивает текущие ответы с эталонными (ground truth) и выявляет отклонения.

Процесс оптимизации выглядит так:

1. Выявление аномалий: через Grafana отслеживаем всплески ошибок в CLI-командах.
2. Анализ через Git: так как Kapso использует Git для версионирования данных и конфигураций, любая деградация метрик позволяет точно определить, какой именно набор данных (dataset) вызвал проблему.
3. Итерация: внесение правок в обучающую выборку и повторный запуск тестов.

С точки зрения системного инженера, такая архитектура обеспечивает прозрачность. Вы не просто видите, что «модель стала работать хуже», вы видите конкретный коммит в Git и конкретный график latency, который это подтверждает. Это и есть профессиональный подход, который часто обсуждается в контексте навыков реальных инженеров.

Для эффективной работы с инфраструктурой Kapso через терминал используйте встроенный CLI. Например, чтобы быстро проверить текущее состояние метрик без захода в веб-интерфейс:

bashКопировать
# Проверка статуса текущей итерации обучения
kapso cli metrics status --last-run

# Экспорт отчета об ошибках в формате JSON для анализа
kapso cli metrics report --format json > error_report.json

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

Практические сценарии внедрения

Внедрение в существующие пайплайны

С практической точки зрения, Kapso не пытается заменить вашу текущую инфраструктуру, а встраивается в неё как дополнительный слой для работы с данными. Если вы уже используете Docker для контейнеризации своих сервисов, интеграция Kapso сводится к добавлению нового этапа в ваш CI/CD процесс.

Главное преимущество здесь — предсказуемость. Поскольку платформа опирается на принципы GitOps, любое изменение в наборе данных или параметрах обучения фиксируется в репозитории. Это позволяет избежать ситуации, когда модель внезапно начинает вести себя иначе без видимых причин.

Для интеграции в существующий пайплайн (например, на базе GitLab CI или GitHub Actions) вам достаточно развернуть Kapso в отдельном контейнере и настроить доступ к вашим хранилищам данных. Если вы используете сложные структуры данных, полезно будет сначала прогнать их через инструменты вроде Graphify, чтобы превратить разрозненные схемы SQL и конфигурации в структурированный граф знаний.

Пример базового docker-compose.yml для запуска Kapso рядом с вашим рабочим окружением:

yamlКопировать
version: '3.8'

services:
  kapso-engine:
    image: kapso/engine:latest
    restart: unless-stopped
    environment:
      - DATA_SOURCE_URL=postgres://user:password@db-host:5432/enterprise_data
      - GIT_REMOTE_URL=git@github.com:your-org/ml-models.git
    volumes:
      - ./kapso_data:/var/lib/kapso
    networks:
      - ml-network

networks:
  ml-network:
    driver: bridge

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

Автоматизация обучения и развертывание

Когда процесс интеграции налажен, наступает этап автоматизации. В Kapso итеративное обучение завязано на метриках. Если показатели качества модели (accuracy, F1-score и другие) падают ниже заданного порога, система должна не просто отправить уведомление, а инициировать процесс переобучения на новых данных.

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

Сценарий автоматизации через CLI может выглядеть так:

bashКопировать
# 1. Синхронизируем состояние с Git-репозиторием
kapso sync --remote origin/main

# 2. Запускаем итерацию обучения на свежем срезе данных
kapso train --dataset-id enterprise_logs_v2 --config ./configs/training_params.yaml

# 3. Проверяем метрики после завершения
# Если метрики в норме, фиксируем изменения в Git
if kapso metrics check --threshold 0.85; then
  kapso git commit -m "feat: update model weights based on enterprise_logs_v2"
  kapso git push
else
  echo "Training failed to meet quality threshold"
  exit 1
fi

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

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