litellm

Provides a single `completion()` function that automatically detects the LLM provider (OpenAI, Anthropic, Google Vertex, AWS Bedrock, Ollama, etc.) from model name patterns and routes requests to the correct provider SDK. Uses a provider detection registry that maps model identifiers to provider-specific API clients, normalizing request/response formats across 50+ providers into a unified interface. Internally handles provider-specific authentication, endpoint routing, and response parsing without requiring developers to write provider-specific code.

The Router class implements weighted load balancing and failover logic across multiple model deployments (same model on different providers, or different models entirely). Routes requests based on configurable strategies: round-robin, least-busy, cost-optimized, or latency-based. Tracks per-deployment metrics (success rate, latency, cost) and automatically fails over to backup deployments if a primary provider returns errors or exceeds rate limits. Uses cooldown management to temporarily disable failing deployments and prevent cascading failures.

Tracks cumulative spend per user, team, and organization with configurable budget limits. Enforces hard limits (reject requests exceeding budget) or soft limits (warn but allow). Provides real-time spend dashboards and analytics. Integrates with cost calculation to track spend in real-time. Supports budget reset schedules (daily, monthly, etc.) and budget alerts via email or webhooks.

Implements rate limiting using a token bucket algorithm with configurable limits per user, team, or organization. Supports multiple rate limit dimensions (requests per minute, tokens per hour, etc.). Integrates with Redis for distributed rate limiting across multiple proxy instances. Returns rate limit headers (X-RateLimit-Remaining, X-RateLimit-Reset) for client-side backoff. Supports priority queuing for high-priority requests.

Provides a guardrails system for validating and filtering LLM inputs and outputs. Supports pre-built guardrails (PII detection, toxicity filtering, jailbreak detection) and custom validators. Runs guardrails before sending requests to LLM (input validation) and after receiving responses (output validation). Integrates with external safety services (OpenAI Moderation API, etc.). Supports guardrail chaining and conditional logic.

Allows organizing models into access groups with wildcard patterns (e.g., 'gpt-4*' matches all GPT-4 variants). Enables fine-grained access control where users/teams can only access specific model groups. Supports dynamic model discovery and routing based on access groups. Useful for enforcing organizational policies (e.g., 'only use approved models') and cost control (e.g., 'restrict expensive models to senior engineers').

Web-based dashboard for managing LiteLLM proxy server operations. Provides UI for API key management (create, rotate, revoke), team and user management, spend tracking and analytics, model access control, and system health monitoring. Supports role-based access to dashboard features (admin, team lead, user). Integrates with database for persistent configuration storage.

Provides a unified interface for generating embeddings across providers (OpenAI, Cohere, Hugging Face, etc.) with the same abstraction as completion API. Supports batch embedding generation for efficiency. Integrates with vector stores (Pinecone, Weaviate, Milvus, etc.) for storing and retrieving embeddings. Tracks embedding costs and usage. Supports semantic search and RAG workflows.

Handles streaming responses from LLM providers by normalizing provider-specific streaming formats (Server-Sent Events, chunked HTTP, WebSocket) into a unified Python iterator. Buffers and parses streaming chunks, reconstructs partial tokens across chunk boundaries, and exposes a consistent `stream=True` parameter across all providers. Supports both sync and async streaming with proper resource cleanup and error handling mid-stream.

Automatically calculates the cost of each LLM request based on provider pricing (per-token rates for input/output, or per-request flat fees). Maintains an internal pricing database with rates for 100+ models across providers, updated regularly. Tracks cumulative costs per request, per user, per team, and per organization. Exposes cost data in response metadata and integrates with spend tracking dashboards. Supports custom pricing overrides for enterprise contracts.

Implements a multi-layer caching system with Redis backend supporting both exact-match caching (hash of messages → cached response) and semantic caching (embeddings-based similarity matching for semantically equivalent prompts). Caches completion responses with configurable TTL and supports cache invalidation by key, pattern, or age. Integrates with Redis for distributed caching across multiple application instances. Provides dynamic cache controls per-request (force refresh, skip cache, etc.).

Provides a unified interface for tool/function calling across providers with different function-calling APIs (OpenAI's function_calling, Anthropic's tool_use, Google's function_calling). Accepts a schema definition (JSON Schema or Pydantic models) and automatically converts it to the provider's native format. Validates LLM-generated function calls against the schema and provides structured output. Supports parallel tool calling, tool choice enforcement, and automatic retry if the LLM generates invalid function calls.

Leverages provider-native prompt caching features (OpenAI's prompt caching, Anthropic's prompt caching) to reduce costs and latency for requests with large, repeated context. Automatically identifies cacheable prompt segments (system prompts, long documents, conversation history) and marks them for caching. Tracks cache hit rates and cost savings. Falls back to non-cached requests for providers without caching support.

Provides a callback system for logging and observability, allowing developers to hook into request/response lifecycle events (pre-request, post-response, error, etc.). Integrates with observability platforms (Langfuse, Arize, Datadog, etc.) via pre-built callbacks. Supports custom callbacks for application-specific logging. Logs include request details, response metadata, cost, latency, and errors. Supports message redaction for privacy (e.g., removing PII before logging).

Implements automatic retry logic with exponential backoff for transient failures (rate limits, timeouts, temporary outages). Supports fallback to alternative models or providers if the primary fails. Configurable retry policies (max retries, backoff strategy, retry-able error codes). Tracks retry metrics and integrates with cooldown management to avoid retrying failing deployments.

A production-grade proxy server that sits between applications and LLM providers, providing centralized API key management, authentication, authorization, budget enforcement, rate limiting, and multi-tenancy. Exposes an OpenAI-compatible API endpoint that applications can call instead of directly calling providers. Manages API keys per user/team/organization with role-based access control. Enforces budget limits per user/team and tracks spend. Supports SCIM and SSO for enterprise deployments.