Lunary

Lunary provides language-specific SDKs (Python, JavaScript) that wrap LLM client libraries (OpenAI, Anthropic, Azure OpenAI, Mistral, Ollama, LiteLLM) using a decorator/monkey-patching pattern. When you call `lunary.monitor(client)`, it intercepts all API calls before they reach the LLM provider, extracts request/response metadata (model, tokens, latency, cost), and asynchronously logs them to Lunary's backend without blocking the application. This enables zero-code instrumentation of existing LLM applications.

Lunary stores complete conversation histories with full message context, user metadata, and timestamps, enabling developers to replay entire multi-turn conversations in the dashboard. The platform reconstructs conversation flow by linking messages via session/thread IDs, preserving the exact sequence of user inputs, LLM responses, and intermediate tool calls. This enables debugging, auditing, and user support without needing to query your application database.

Lunary provides a native LangChain integration that automatically instruments LangChain agents, chains, and tools without requiring code changes. The integration hooks into LangChain's callback system to capture chain execution traces, tool calls, and intermediate steps. This enables full visibility into LangChain agent behavior, including tool selection, reasoning steps, and error handling.

Lunary supports OpenTelemetry (OTel) as a standard observability protocol, allowing developers to export LLM traces to any OTel-compatible backend (Jaeger, Datadog, New Relic, etc.). This enables integration with existing observability stacks without vendor lock-in. Lunary can act as an OTel collector or exporter, depending on the application architecture.

Lunary offers a self-hosted Community Edition that can be deployed on-premises using Docker or Kubernetes, enabling organizations to keep all data within their infrastructure. The self-hosted version includes core observability features (LLM call logging, dashboards, conversation replay) but may have feature limitations compared to the cloud version. This enables compliance with data residency requirements (GDPR, HIPAA) without relying on cloud infrastructure.

Lunary provides CSV and JSONL export capabilities for conversations and metrics, enabling integration with external data warehouses, analytics platforms, and BI tools. On Enterprise tier, Lunary offers native connectors to data warehouses (Snowflake, BigQuery, Redshift, etc.), enabling automated data syncing without manual exports. This enables advanced analytics and long-term data retention beyond Lunary's built-in retention limits.

Lunary provides role-based access control (RBAC) enabling organizations to grant different permissions to team members (e.g., support can view conversations but not edit prompts, developers can edit prompts but not access billing). On Enterprise tier, SSO/SAML integration enables centralized identity management. This enables secure multi-team collaboration without exposing sensitive data to unauthorized users.

Lunary allows developers to attach custom user IDs, session IDs, and arbitrary metadata (user tier, geography, feature flags) to LLM calls via SDK parameters. The platform aggregates these attributes across all calls from a user, enabling cohort analysis, user-level cost tracking, and behavior segmentation. Custom attributes are indexed and filterable in the dashboard, supporting queries like 'show all conversations from premium users in EU'.

Lunary provides a dashboard-based prompt template editor where developers can store, version, and manage prompts separately from application code. Templates support variable interpolation (e.g., `{user_input}`, `{context}`), and the SDK can fetch templates by name at runtime, automatically handling version selection. This enables non-technical users to edit prompts without code deployment, and provides audit trails of all prompt changes.

Lunary aggregates LLM call metrics (latency, token usage, cost, error rates) in real-time and displays them on customizable dashboards. The platform calculates percentiles (p50, p95, p99), tracks cost trends over time, and identifies performance regressions by comparing current metrics to historical baselines. Dashboards support filtering by model, user, session, and custom attributes, enabling drill-down analysis from high-level trends to individual requests.

Lunary automatically captures exceptions and errors from LLM calls (API errors, timeouts, rate limits, malformed responses) and stores them with full stack traces and context. Errors are grouped by type and linked to the conversation/session where they occurred, enabling developers to identify patterns (e.g., 'errors spike when using model X with long contexts'). The dashboard provides instant search and filtering by error type, model, and user.

Lunary analyzes conversation content using NLP/embedding-based techniques to automatically classify conversations by topic (e.g., 'billing inquiry', 'technical support', 'product feedback'). The platform extracts semantic features from conversations and displays them in dashboards, enabling product teams to understand what users are asking about without manual review. Topic classification is performed server-side on stored conversations.

Lunary provides mechanisms to capture user satisfaction signals (thumbs up/down, star ratings, explicit feedback) on individual LLM responses or entire conversations. Feedback is stored alongside conversation context, enabling correlation analysis (e.g., 'responses with low satisfaction have longer latency'). The platform aggregates satisfaction metrics over time and by segment (user, model, topic), providing a quantitative measure of LLM quality.

Lunary provides server-side PII masking that automatically detects and redacts personally identifiable information (email addresses, phone numbers, credit card numbers, etc.) from logged conversations before storage. Masking rules are configurable and can be applied selectively to specific fields or conversation types. This enables compliance with privacy regulations (GDPR, CCPA) without requiring application-level redaction.

Lunary automatically calculates per-request costs for LLM calls across multiple providers (OpenAI, Anthropic, Mistral, Azure OpenAI, Ollama) using provider-specific pricing models. The platform tracks total cost by model, user, and time period, and provides cost trend analysis and per-token cost comparisons. This enables developers to identify cost drivers and optimize model selection (e.g., 'switching from GPT-4 to GPT-3.5 saves 10x cost with 5% quality loss').