Вы запустили AI-ассистента для отдела продаж. Через месяц счёт за API вырос вдвое, а менеджеры жалуются, что бот иногда несёт чушь. Вы не знаете, кто виноват и что менять. Знакомая боль?
Без наблюдения за работой AI-приложения вы управляете вслепую. Это как рекламный бюджет без аналитики - деньги уходят, а отдачи не видно. Хорошая новость: настроить базовое наблюдение можно за 30 минут без программиста. Большинство инструментов из этой статьи требуют изменения 1-3 строк кода - ваш менеджер справится.
Разберём на примере стройфирмы: у вас есть чат-бот на сайте, который отвечает на вопросы клиентов по прайсу и типовому договору подряда. Без наблюдения вы не знаете, сколько стоит каждый диалог, почему бот иногда советует не то, и не замечаете утечку бюджета, пока не придёт счёт. Инструменты observability (наблюдаемости) делают эту цепочку видимой - и переводят управление AI с уровня «кажется, работает» на уровень чисел и алертов.
Что такое трейс и чем он отличается от обычного мониторинга
Обычный мониторинг приложений (APM) смотрит на время ответа и коды ошибок. Для AI этого мало. Вам нужно видеть, что именно происходило внутри: какой запрос ушёл в модель, сколько токенов (единиц текста, которыми измеряется объём) потрачено, сколько это стоило, какие документы были найдены.
Трейс (от английского trace - след, запись пути) - это полная запись одного запроса пользователя. Он состоит из:
- Generation - конкретный вызов языковой модели: что спросили, что ответила, сколько токенов, сколько денег
- Span - логическая операция внутри запроса (поиск документов, вызов инструмента)
- Session - цепочка запросов одного пользователя в рамках диалога
- User - агрегация по конкретному клиенту: средняя стоимость сессии, качество ответов
Пример структуры трейса:
Trace (session_id, user_id, metadata)
├── Span: Поиск документов в базе (1.2с)
│ ├── Создание векторного представления (0.3с, $0.0001)
│ └── Поиск в Qdrant (0.9с)
├── Generation: Вызов AI-модели (2.1с)
│ ├── вход: 1247 токенов ($0.006)
│ └── выход: 312 токенов ($0.005)
└── Span: Постобработка ответа (0.05с)
Итого: 3.35 секунды, $0.011 за один запрос. Инструмент Langfuse записывает всё это в базу данных ClickHouse, что позволяет строить отчёты по миллионам запросов без замедления.
Langfuse: бесплатный инструмент, который можно поставить на свой компьютер
Langfuse - открытый инструмент с лицензией MIT (можно использовать бесплатно). Он написан на TypeScript/Next.js, использует ClickHouse для хранения трейсов и Postgres для метаданных. Можно развернуть на своём сервере через Docker Compose (контейнеры для запуска) или Kubernetes (система управления контейнерами), либо пользоваться облачной версией.
Для компаний, которые не хотят отправлять данные на чужие сервера (например, стройфирма с договорами подряда), локальная версия даёт полный контроль. Трейсы с промптами и ответами пользователей не покидают вашу инфраструктуру.
Требования для локальной установки: 2 виртуальных процессора, 4 ГБ оперативной памяти - хватит до 500 тысяч трейсов в месяц. ClickHouse при таком объёме занимает около 10 ГБ диска.
Интеграция через Python SDK - минимальный код. Декоратор @observe() автоматически создаёт трейс для каждого вызова функции. Вот как это выглядит:
from langfuse.decorators import observe, langfuse_context
import anthropic
@observe() # автоматически создаёт trace и span
def rag_pipeline(question: str) -> str:
# Nested spans создаются автоматически
context = retrieve_context(question)
langfuse_context.update_current_observation(
metadata={"retrieved_chunks": len(context)}
)
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=1024,
messages=[{"role": "user", "content": f"Контекст: {context}\nВопрос: {question}"}]
)
return response.content[0].text
@observe(name="context-retrieval")
def retrieve_context(question: str) -> str:
# Этот span будет вложен в родительский
...
Альтернативный вариант - заменить импорт OpenAI через прокси. Все вызовы автоматически трейсятся без изменения остального кода:
from langfuse.openai import openai # Замена import openai
# Все вызовы автоматически трейсятся
Облачная версия Langfuse: $49 в месяц за 1 миллион событий, $199 в месяц за 10 миллионов. Есть бесплатный уровень - 50 тысяч событий в месяц. Для малого бизнеса на старте этого достаточно.
LangSmith: сервис для тех, кто использует LangChain
LangSmith - облачная платформа наблюдения от компании LangChain Inc. Она глубоко интегрирована с фреймворками LangChain, LangGraph и LangServe. Если ваша команда строит приложения на LangChain (популярный фреймворк для AI-приложений), LangSmith даёт готовую интеграцию без дополнительного кода.
Отличительные возможности:
- Annotation queues - очередь трейсов на ручную разметку: можно приоритезировать и распределять между сотрудниками
- Datasets - хранение золотого набора правильных ответов и автоматический запуск оценки на новых промптах
- LangGraph Studio - визуализация и отладка агентских графов в реальном времени
from langchain_anthropic import ChatAnthropic
from langsmith import traceable
@traceable(run_type="chain", name="support-pipeline")
def run_support_chain(user_message: str) -> str:
llm = ChatAnthropic(model="claude-sonnet-4-5")
# Все вызовы LangChain автоматически трейсятся
response = llm.invoke(user_message)
return response.content
Цены: $39 в месяц за план для разработчика (10 тысяч единиц трейсинга в месяц), $99 в месяц за plus (100 тысяч). Enterprise - по запросу. Локальной версии нет - только облачная.
Ключевое ограничение: данные хранятся на серверах LangChain Inc. в США. Для компаний, которым нужно хранить данные в России или ЕС, это не подходит без специального соглашения.
Helicone: прокси-подход - не нужно менять код
Helicone работает иначе: вместо установки SDK в код, это HTTP-прокси (посредник) между вашим приложением и AI-провайдером. Нужно изменить одну строку в коде - и вы получаете трейсинг, отслеживание расходов и ограничение запросов.
Это особенно ценно, когда нет возможности менять много кода или когда приложение использует несколько провайдеров сразу. Helicone поддерживает OpenAI, Anthropic, Google, Mistral, Cohere, Azure OpenAI.
# Было
client = anthropic.Anthropic(base_url="https://api.anthropic.com")
# Стало - весь трафик идёт через Helicone
client = anthropic.Anthropic(
base_url="https://anthropic.helicone.ai",
default_headers={
"Helicone-Auth": f"Bearer {HELICONE_API_KEY}",
"Helicone-User-Id": user_id, # группировка по пользователям
}
)
Возможности: отслеживание расходов по провайдерам и моделям, ограничение запросов по user_id, повтор трейсов для отладки, шаблоны промптов с версионированием, кеширование.
Цены: бесплатно до 10 тысяч запросов в месяц, $20 за 100 тысяч, $200 за 1 миллион. Локальная версия доступна только в enterprise.
Overhead: прокси добавляет 5-20 миллисекунд к каждому запросу из-за дополнительного сетевого перехода. При среднем времени ответа 500 миллисекунд это 1-4% - незаметно. Если важен каждый миллисекунд - стоит учитывать.
Arize Phoenix: локальный инструмент с открытым кодом
Arize Phoenix - открытый инструмент (лицензия Apache 2.0) с упором на локальную разработку и нативную поддержку OpenTelemetry. Идеален для экспериментов и отладки на своём компьютере без отправки данных в облако.
OpenTelemetry (OTEL) - это стандарт для распределённого трейсинга. Идея: инструментируете код один раз, а данные можете направлять в любой backend. Это важно: если вы настроите код под OTEL, то в будущем сможете переключиться между Langfuse, Arize и другими без изменения кода.
import phoenix as px
from openinference.instrumentation.anthropic import AnthropicInstrumentor
from opentelemetry import trace as trace_api
from opentelemetry.exporter.otlp.proto.http import trace_exporter
from opentelemetry.sdk import trace as trace_sdk
# Запуск Phoenix UI локально
px.launch_app()
# Настройка OpenTelemetry
tracer_provider = trace_sdk.TracerProvider()
tracer_provider.add_span_processor(
trace_sdk.SimpleSpanProcessor(
trace_exporter.OTLPSpanExporter(конечная точка API="http://localhost:6006/v1/traces")
)
)
trace_api.set_tracer_provider(tracer_provider)
# Инструментация Anthropic SDK
AnthropicInstrumentor().instrument(tracer_provider=tracer_provider)
# Теперь все вызовы автоматически идут в Phoenix UI
Phoenix UI открывается на localhost:6006 и показывает дерево трейсов, временную диаграмму задержек и встроенный интерфейс оценки. Оценка прямо в UI - ключевая функция: выделяете трейс, нажимаете «Evaluate», Phoenix запускает AI-судью и добавляет оценку к трейсу.
Для производственного использования есть облачная версия Arize с более длительным хранением и командными функциями.
OpenTelemetry как стандарт
Для AI-приложений OpenInference (от Arize) расширяет OTEL семантическими соглашениями, специфичными для AI: gen_ai.prompt (промпт), gen_ai.completion (ответ), llm.model_name (название модели), llm.token_count.prompt (количество токенов в промпте), llm.token_count.completion (количество токенов в ответе).
Следующий код показывает, как отправлять данные одновременно в Langfuse и Arize - один раз настроив код:
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
provider = TracerProvider()
# Langfuse OTEL конечная точка API
provider.add_span_processor(SimpleSpanProcessor(
OTLPSpanExporter(конечная точка API="https://cloud.langfuse.com/api/public/otel/v1/traces",
headers={"Authorization": f"Basic {langfuse_b64_key}"})
))
# Arize Phoenix
provider.add_span_processor(SimpleSpanProcessor(
OTLPSpanExporter(конечная точка API="http://localhost:6006/v1/traces")
))
Алертинг: как не пропустить сбой
Алертинг (система оповещений) на ухудшение работы - следующий уровень после базового мониторинга. Типичные триггеры:
- Задержка: p90 (90% запросов) выше 2 секунд для интерактивных запросов или рост p90 более чем на 30% за последний час.
- Рост расходов: увеличение стоимости на сессию более чем на 20% за 1 час - может означать, что кто-то ввёл в промпт огромный текст или ошибка в коде.
- Частота ошибок: HTTP 5xx (ошибки сервера) плюс таймауты более 1% за 5 минут.
- Частота отказов: рост процента отказов модели более чем на 5% от базовой линии - сигнал об изменении модели провайдером.
Langfuse поддерживает вебхуки: при пересечении порога POST-запрос идёт в Slack, PagerDuty или кастомный конечная точка API.
# Langfuse webhook payload
{
"type": "metric_alert",
"metric": "p90_latency_ms",
"value": 3240,
"threshold": 2000,
"window": "5m",
"timestamp": "2026-06-05T14:23:00Z"
}
Для более сложного алертинга: Langfuse экспортирует метрики в Prometheus (система мониторинга), откуда Grafana (инструмент визуализации) строит дашборды и AlertManager рассылает уведомления.
Сравнение инструментов: что выбрать малому бизнесу
Langfuse: можно поставить на свой сервер (MIT-лицензия), от $0 до $199 в месяц, хорошая поддержка агентов, встроенная оценка, поддержка OpenTelemetry. Лучший выбор для компаний, которые хотят хранить данные у себя.
LangSmith: только облачная версия, от $39 до $99 в месяц, нативная интеграция с LangChain/LangGraph, отличная поддержка агентских сценариев, встроенная оценка. Лучший выбор для команд, которые используют LangChain.
Helicone: облачная или корпоративная локальная версия, от $0 до $200 в месяц, минимальная настройка (только замена URL), нет встроенной оценки. Лучший выбор для быстрого старта без изменения кода.
Arize Phoenix: локальная версия (Apache 2.0), бесплатно на своём компьютере, облачная для производства, нативный OpenTelemetry, встроенная оценка в интерфейсе. Лучший выбор для экспериментов и отладки локально.
Практический пример: контроль расходов на AI
Разберём на примере стройфирмы. Компания запустила внутреннего AI-ассистента для отдела продаж. Через месяц счёт за API вырос вдвое без видимой причины.
Без наблюдения: разработчики смотрят в логи, пытаются найти «жирный» запрос вручную, тратят день.
С Langfuse: открывают дашборд, фильтруют по cost_per_session (стоимость за сессию), видят, что один пользователь генерирует 40% всех расходов. Заходят в его трейсы - он передаёт в промпт огромные блоки скопированного текста. Добавляют ограничение на размер входа. Расходы возвращаются к норме за 20 минут.
Это не гипотетический сценарий - именно так работает контроль расходов на AI в зрелых командах. Разбивка по user_id, по типу запроса, по времени суток - всё это позволяет управлять AI-бюджетом так же, как управляют бюджетом рекламной кампании: на основе данных, а не ощущений.
Langfuse, LangSmith и Helicone все поддерживают эту разбивку из коробки. Нужно только передавать user_id в каждом запросе.
Частые вопросы
Langfuse vs LangSmith: что выбрать, если не используете LangChain?
Langfuse. Он не привязан к LangChain, поддерживает любой LLM через OpenAI-совместимый API или нативные SDK (Anthropic, OpenAI, Cohere), работает локально. LangSmith без LangChain теряет свои ключевые преимущества.
Как настроить оповещение о внезапном росте отказов?
В Langfuse: создать метрику на основе оценки «отказ» (AI-судья или регулярное выражение по паттернам отказа), настроить порог в 3% от скользящего среднего за 24 часа, добавить вебхук в Slack. При срабатывании - проверить changelog OpenAI и последние трейсы с отказами.
Helicone не нужен, если уже есть Langfuse - или они дополняют друг друга?
Они частично перекрываются. Helicone сильнее в ограничении запросов и отслеживании расходов без дополнительного кода. Langfuse сильнее в оценке, управлении промптами и кастомных метриках. Если уже есть Langfuse с полной настройкой - Helicone добавляет мало.
Как хранить трейсы с персональными данными?
Три подхода: (1) маскировать персональные данные до записи через Presidio или кастомную функцию обфускации; (2) Langfuse локально на своём сервере с политикой удаления трейсов через 30 дней; (3) не записывать пользовательский контент в трейсы вообще, только метаданные (токены, задержка, оценки). Первый вариант предпочтительнее для полной отладки.
Какой overhead добавляет трейсинг к рабочему запросу?
Langfuse SDK отправляет данные асинхронно через фоновый процесс - overhead менее 1 миллисекунды для самого запроса. Helicone-прокси добавляет синхронно 5-20 миллисекунд из-за дополнительного сетевого перехода. При времени до первого токена 500-2000 миллисекунд это незаметно.
Что делать прямо сейчас
Если пока не знаете, с чего начать: поставьте Langfuse локально на Docker Compose и оберните один ключевой конечная точка API декоратором @observe(). За неделю накопится достаточно данных, чтобы увидеть реальную картину расходов и распределение времени ответа по пользователям.
Следующий приоритет после наблюдения - снижение стоимости: кеширование частых запросов и выбор более дешёвой модели.
AI Компас (t.me/kosmoslab_ai) - канал для предпринимателей в РФ и СНГ, которые применяют AI в своём бизнесе без программиста. Разбираем инструменты и схемы - без курсов и теории.