' \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "enabled_ui_pages_internal_users": null
+ }'
+```
+
diff --git a/docs/my-website/docs/proxy/users.md b/docs/my-website/docs/proxy/users.md
index 3e0e00dfa52..a389f0bd443 100644
--- a/docs/my-website/docs/proxy/users.md
+++ b/docs/my-website/docs/proxy/users.md
@@ -545,6 +545,26 @@ You can set:
- max parallel requests
- rpm / tpm limits per model for a given key
+### TPM Rate Limit Type (Input/Output/Total)
+
+By default, TPM (tokens per minute) rate limits count **total tokens** (input + output). You can configure this to count only input tokens or only output tokens instead.
+
+Set `token_rate_limit_type` in your `config.yaml`:
+
+```yaml
+general_settings:
+ master_key: sk-1234
+ token_rate_limit_type: "output" # Options: "input", "output", "total" (default)
+```
+
+| Value | Description |
+|-------|-------------|
+| `total` | Count total tokens (prompt + completion). **Default behavior.** |
+| `input` | Count only prompt/input tokens |
+| `output` | Count only completion/output tokens |
+
+This setting applies globally to all TPM rate limit checks (keys, users, teams, etc.).
+
diff --git a/docs/my-website/docs/rag_ingest.md b/docs/my-website/docs/rag_ingest.md
index 1133b85f206..7adc2d70b5b 100644
--- a/docs/my-website/docs/rag_ingest.md
+++ b/docs/my-website/docs/rag_ingest.md
@@ -5,7 +5,7 @@ All-in-one document ingestion pipeline: **Upload → Chunk → Embed → Vector
| Feature | Supported |
|---------|-----------|
| Logging | Yes |
-| Supported Providers | `openai`, `bedrock`, `vertex_ai`, `gemini` |
+| Supported Providers | `openai`, `bedrock`, `vertex_ai`, `gemini`, `s3_vectors` |
:::tip
After ingesting documents, use [/rag/query](./rag_query.md) to search and generate responses with your ingested content.
@@ -75,6 +75,31 @@ curl -X POST "http://localhost:4000/v1/rag/ingest" \
}"
```
+### AWS S3 Vectors
+
+```bash showLineNumbers title="Ingest to S3 Vectors"
+curl -X POST "http://localhost:4000/v1/rag/ingest" \
+ -H "Authorization: Bearer sk-1234" \
+ -H "Content-Type: application/json" \
+ -d "{
+ \"file\": {
+ \"filename\": \"document.txt\",
+ \"content\": \"$(base64 -i document.txt)\",
+ \"content_type\": \"text/plain\"
+ },
+ \"ingest_options\": {
+ \"embedding\": {
+ \"model\": \"text-embedding-3-small\"
+ },
+ \"vector_store\": {
+ \"custom_llm_provider\": \"s3_vectors\",
+ \"vector_bucket_name\": \"my-embeddings\",
+ \"aws_region_name\": \"us-west-2\"
+ }
+ }
+ }"
+```
+
## Response
```json
@@ -265,6 +290,57 @@ When `vector_store_id` is omitted, LiteLLM automatically creates:
4. Install: `pip install 'google-cloud-aiplatform>=1.60.0'`
:::
+### vector_store (AWS S3 Vectors)
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `custom_llm_provider` | string | - | `"s3_vectors"` |
+| `vector_bucket_name` | string | **required** | S3 vector bucket name |
+| `index_name` | string | auto-create | Vector index name |
+| `dimension` | integer | auto-detect | Vector dimension (auto-detected from embedding model) |
+| `distance_metric` | string | `cosine` | Distance metric: `cosine` or `euclidean` |
+| `non_filterable_metadata_keys` | array | `["source_text"]` | Metadata keys excluded from filtering |
+| `aws_region_name` | string | `us-west-2` | AWS region |
+| `aws_access_key_id` | string | env | AWS access key |
+| `aws_secret_access_key` | string | env | AWS secret key |
+
+:::info S3 Vectors Auto-Creation
+When `index_name` is omitted, LiteLLM automatically creates:
+- S3 vector bucket (if it doesn't exist)
+- Vector index with auto-detected dimensions from your embedding model
+
+**Dimension Auto-Detection**: The vector dimension is automatically detected by making a test embedding request to your specified model. No need to manually specify dimensions!
+
+**Supported Embedding Models**: Works with any LiteLLM-supported embedding model (OpenAI, Cohere, Bedrock, Azure, etc.)
+:::
+
+**Example with auto-detection:**
+```json
+{
+ "embedding": {
+ "model": "text-embedding-3-small" // Dimension auto-detected as 1536
+ },
+ "vector_store": {
+ "custom_llm_provider": "s3_vectors",
+ "vector_bucket_name": "my-embeddings"
+ }
+}
+```
+
+**Example with custom embedding provider:**
+```json
+{
+ "embedding": {
+ "model": "cohere/embed-english-v3.0" // Dimension auto-detected as 1024
+ },
+ "vector_store": {
+ "custom_llm_provider": "s3_vectors",
+ "vector_bucket_name": "my-embeddings",
+ "distance_metric": "cosine"
+ }
+}
+```
+
## Input Examples
### File (Base64)
diff --git a/docs/my-website/docs/routing.md b/docs/my-website/docs/routing.md
index 47967775e1e..2b3a28edf75 100644
--- a/docs/my-website/docs/routing.md
+++ b/docs/my-website/docs/routing.md
@@ -830,6 +830,12 @@ asyncio.run(router_acompletion())
+## Traffic Mirroring / Silent Experiments
+
+Traffic mirroring allows you to "mimic" production traffic to a secondary (silent) model for evaluation purposes. The silent model's response is gathered in the background and does not affect the latency or result of the primary request.
+
+[**See detailed guide on A/B Testing - Traffic Mirroring here**](./traffic_mirroring.md)
+
## Basic Reliability
### Deployment Ordering (Priority)
diff --git a/docs/my-website/docs/search/brave.md b/docs/my-website/docs/search/brave.md
new file mode 100644
index 00000000000..d43efd47cd1
--- /dev/null
+++ b/docs/my-website/docs/search/brave.md
@@ -0,0 +1,55 @@
+# Brave Search
+
+Get started by creating a free API key via https://brave.com/search/api/.
+
+For documentation on other parameters supported by the Brave Search API, visit https://api-dashboard.search.brave.com/api-reference/web/search.
+
+## LiteLLM Python SDK
+
+```python showLineNumbers title="Brave Search"
+import os
+from litellm import search
+
+os.environ["BRAVE_API_KEY"] = "BSATzx..."
+
+response = search(
+ query="Brave browser features",
+ search_provider="brave",
+ max_results=5
+)
+```
+
+## LiteLLM AI Gateway
+
+### 1. Setup config.yaml
+
+```yaml showLineNumbers title="config.yaml"
+model_list:
+ - model_name: gpt-4
+ litellm_params:
+ model: gpt-4
+ api_key: os.environ/OPENAI_API_KEY
+
+search_tools:
+ - search_tool_name: brave-search
+ litellm_params:
+ search_provider: brave
+ api_key: os.environ/BRAVE_API_KEY
+```
+
+### 2. Start the proxy
+
+```bash
+litellm --config /path/to/config.yaml
+
+# RUNNING on http://0.0.0.0:4000
+```
+
+### 3. Test the search endpoint
+
+```bash showLineNumbers title="Test Request"
+curl http://0.0.0.0:4000/v1/search/brave-search \
+ -H "Authorization: Bearer sk-1234" \
+ -H "Content-Type: application/json" \
+ -d '{ "query": "Brave browser features", "max_results": 5 }'
+```
diff --git a/docs/my-website/docs/search/index.md b/docs/my-website/docs/search/index.md
index 037a1b59388..551a495261a 100644
--- a/docs/my-website/docs/search/index.md
+++ b/docs/my-website/docs/search/index.md
@@ -2,7 +2,7 @@
| Feature | Supported |
|---------|-----------|
-| Supported Providers | `perplexity`, `tavily`, `parallel_ai`, `exa_ai`, `google_pse`, `dataforseo`, `firecrawl`, `searxng`, `linkup` |
+| Supported Providers | `perplexity`, `tavily`, `parallel_ai`, `exa_ai`, `brave`, `google_pse`, `dataforseo`, `firecrawl`, `searxng`, `linkup` |
| Cost Tracking | ✅ |
| Logging | ✅ |
| Load Balancing | ❌ |
@@ -162,6 +162,11 @@ search_tools:
search_provider: exa_ai
api_key: os.environ/EXA_API_KEY
+ - search_tool_name: my-search
+ litellm_params:
+ search_provider: brave
+ api_key: os.environ/BRAVE_API_KEY
+
router_settings:
routing_strategy: simple-shuffle # or 'least-busy', 'latency-based-routing'
```
@@ -205,7 +210,7 @@ See the [official Perplexity Search documentation](https://docs.perplexity.ai/ap
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `query` | string or array | Yes | Search query. Can be a single string or array of strings |
-| `search_provider` | string | Yes (SDK) | The search provider to use: `"perplexity"`, `"tavily"`, `"parallel_ai"`, `"exa_ai"`, `"google_pse"`, `"dataforseo"`, `"firecrawl"`, `"searxng"`, or `"linkup"` |
+| `search_provider` | string | Yes (SDK) | The search provider to use: `"perplexity"`, `"tavily"`, `"parallel_ai"`, `"exa_ai"`, `"brave"`, `"google_pse"`, `"dataforseo"`, `"firecrawl"`, `"searxng"`, or `"linkup"` |
| `search_tool_name` | string | Yes (Proxy) | Name of the search tool configured in `config.yaml` |
| `max_results` | integer | No | Maximum number of results to return (1-20). Default: 10 |
| `search_domain_filter` | array | No | List of domains to filter results (max 20 domains) |
@@ -264,6 +269,7 @@ The response follows Perplexity's search format with the following structure:
| Perplexity AI | `PERPLEXITYAI_API_KEY` | `perplexity` |
| Tavily | `TAVILY_API_KEY` | `tavily` |
| Exa AI | `EXA_API_KEY` | `exa_ai` |
+| Brave Search | `BRAVE_API_KEY` | `brave` |
| Parallel AI | `PARALLEL_AI_API_KEY` | `parallel_ai` |
| Google PSE | `GOOGLE_PSE_API_KEY`, `GOOGLE_PSE_ENGINE_ID` | `google_pse` |
| DataForSEO | `DATAFORSEO_LOGIN`, `DATAFORSEO_PASSWORD` | `dataforseo` |
diff --git a/docs/my-website/docs/text_to_speech.md b/docs/my-website/docs/text_to_speech.md
index 77d15ccb3a5..667ffc925c1 100644
--- a/docs/my-website/docs/text_to_speech.md
+++ b/docs/my-website/docs/text_to_speech.md
@@ -46,7 +46,7 @@ os.environ["OPENAI_API_KEY"] = "sk-.."
async def test_async_speech():
speech_file_path = Path(__file__).parent / "speech.mp3"
- response = await litellm.aspeech(
+ response = await aspeech(
model="openai/tts-1",
voice="alloy",
input="the quick brown fox jumped over the lazy dogs",
diff --git a/docs/my-website/docs/traffic_mirroring.md b/docs/my-website/docs/traffic_mirroring.md
new file mode 100644
index 00000000000..3bdcb0f1614
--- /dev/null
+++ b/docs/my-website/docs/traffic_mirroring.md
@@ -0,0 +1,83 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# A/B Testing - Traffic Mirroring
+
+Traffic mirroring allows you to "mimic" production traffic to a secondary (silent) model for evaluation purposes. The silent model's response is gathered in the background and does not affect the latency or result of the primary request.
+
+This is useful for:
+- Testing a new model's performance on production prompts before switching.
+- Comparing costs and latency between different providers.
+- Debugging issues by mirroring traffic to a more verbose model.
+
+## Quick Start
+
+To enable traffic mirroring, add `silent_model` to the `litellm_params` of a deployment.
+
+
+
+
+```python
+from litellm import Router
+
+model_list = [
+ {
+ "model_name": "gpt-3.5-turbo",
+ "litellm_params": {
+ "model": "azure/chatgpt-v-2",
+ "api_key": "...",
+ "silent_model": "gpt-4" # 👈 Mirror traffic to gpt-4
+ },
+ },
+ {
+ "model_name": "gpt-4",
+ "litellm_params": {
+ "model": "openai/gpt-4",
+ "api_key": "..."
+ },
+ }
+]
+
+router = Router(model_list=model_list)
+
+# The request to "gpt-3.5-turbo" will trigger a background call to "gpt-4"
+response = await router.acompletion(
+ model="gpt-3.5-turbo",
+ messages=[{"role": "user", "content": "How does traffic mirroring work?"}]
+)
+```
+
+
+
+
+Add `silent_model` to your `config.yaml`:
+
+```yaml
+model_list:
+ - model_name: primary-model
+ litellm_params:
+ model: azure/gpt-35-turbo
+ api_key: os.environ/AZURE_API_KEY
+ silent_model: evaluation-model # 👈 Mirror traffic here
+ - model_name: evaluation-model
+ litellm_params:
+ model: openai/gpt-4o
+ api_key: os.environ/OPENAI_API_KEY
+```
+
+
+
+
+## How it works
+1. **Request Received**: A request is made to a model group (e.g. `primary-model`).
+2. **Deployment Picked**: LiteLLM picks a deployment from the group.
+3. **Primary Call**: LiteLLM makes the call to the primary deployment.
+4. **Mirroring**: If `silent_model` is present, LiteLLM triggers a background call to that model.
+ - For **Sync** calls: Uses a shared thread pool.
+ - For **Async** calls: Uses `asyncio.create_task`.
+5. **Isolation**: The background call uses a `deepcopy` of the original request parameters and sets `metadata["is_silent_experiment"] = True`. It also strips out logging IDs to prevent collisions in usage tracking.
+
+## Key Features
+- **Latency Isolation**: The primary request returns as soon as it's ready. The background (silent) call does not block.
+- **Unified Logging**: Background calls are processed via the Router, meaning they are automatically logged to your configured observability tools (Langfuse, S3, etc.).
+- **Evaluation**: Use the `is_silent_experiment: True` flag in your logs to filter and compare results between the primary and mirrored calls.
diff --git a/docs/my-website/docs/troubleshoot/spend_queue_warnings.md b/docs/my-website/docs/troubleshoot/spend_queue_warnings.md
new file mode 100644
index 00000000000..4be8b18f5cd
--- /dev/null
+++ b/docs/my-website/docs/troubleshoot/spend_queue_warnings.md
@@ -0,0 +1,46 @@
+# Spend Update Queue Full Warnings
+
+## Overview
+
+The "Spend update queue is full" warning occurs in high-volume LiteLLM proxy deployments when the internal spend tracking queue reaches capacity. This is a protective mechanism to prevent memory issues during traffic spikes.
+
+## Warning Message
+
+```
+WARNING:litellm.proxy.db.db_transaction_queue.spend_update_queue:Spend update queue is full. Aggregating entries to prevent memory issues.
+```
+
+## Root Cause
+
+The spend update queue has a default maximum size of 10,000 entries (`MAX_SIZE_IN_MEMORY_QUEUE=10000`). When this limit is reached:
+
+1. New spend tracking entries are aggregated instead of queued individually
+2. This prevents memory exhaustion but may slightly delay spend updates
+3. The warning indicates your deployment is processing requests faster than the database can handle spend updates
+
+## Solutions
+
+### 1. Increase Queue Size
+
+Set the `MAX_SIZE_IN_MEMORY_QUEUE` environment variable to a higher value:
+
+```bash
+MAX_SIZE_IN_MEMORY_QUEUE=50000
+```
+
+**Tradeoffs:**
+Higher queue sizes store more items in memory - provision at least 8GB RAM for large queues
+- Recommended for deployments with consistent high traffic
+
+### 2. Horizontal Scaling
+
+Deploy multiple proxy instances with load balancing. This distributes the spend tracking load across multiple queues, reducing the pressure on any single instance's spend update queue.
+
+
+
+## Related Configuration
+
+```yaml
+# Environment variables
+MAX_SIZE_IN_MEMORY_QUEUE: 10000 # Default queue size
+```
diff --git a/docs/my-website/docs/tutorials/claude_agent_sdk.md b/docs/my-website/docs/tutorials/claude_agent_sdk.md
new file mode 100644
index 00000000000..c56784ba2df
--- /dev/null
+++ b/docs/my-website/docs/tutorials/claude_agent_sdk.md
@@ -0,0 +1,115 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Claude Agent SDK with LiteLLM
+
+Use Anthropic's Claude Agent SDK with any LLM provider through LiteLLM Proxy.
+
+The Claude Agent SDK provides a high-level interface for building AI agents. By pointing it to LiteLLM, you can use the same agent code with OpenAI, Bedrock, Azure, Vertex AI, or any other provider.
+
+## Quick Start
+
+### 1. Install Dependencies
+
+```bash
+pip install claude-agent-sdk
+```
+
+### 2. Start LiteLLM Proxy
+
+```yaml title="config.yaml" showLineNumbers
+model_list:
+ - model_name: bedrock-claude-sonnet-3.5
+ litellm_params:
+ model: "bedrock/us.anthropic.claude-3-5-sonnet-20240620-v1:0"
+ aws_region_name: "us-east-1"
+
+ - model_name: bedrock-claude-sonnet-4
+ litellm_params:
+ model: "bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0"
+ aws_region_name: "us-east-1"
+
+ - model_name: bedrock-claude-sonnet-4.5
+ litellm_params:
+ model: "bedrock/us.anthropic.claude-sonnet-4-5-20250929-v1:0"
+ aws_region_name: "us-east-1"
+
+ - model_name: bedrock-claude-opus-4.5
+ litellm_params:
+ model: "bedrock/us.anthropic.claude-opus-4-5-20251101-v1:0"
+ aws_region_name: "us-east-1"
+
+ - model_name: bedrock-nova-premier
+ litellm_params:
+ model: "bedrock/amazon.nova-premier-v1:0"
+ aws_region_name: "us-east-1"
+```
+
+```bash
+litellm --config config.yaml
+```
+
+### 3. Point Agent SDK to LiteLLM
+
+| Environment Variable | Value | Description |
+|---------------------|-------|-------------|
+| `ANTHROPIC_BASE_URL` | `http://localhost:4000` | LiteLLM proxy URL |
+| `ANTHROPIC_API_KEY` | `sk-1234` | Your LiteLLM API key (not Anthropic key) |
+
+```python title="agent.py" showLineNumbers
+import os
+from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions
+
+# Point to LiteLLM proxy (not Anthropic)
+os.environ["ANTHROPIC_BASE_URL"] = "http://localhost:4000"
+os.environ["ANTHROPIC_API_KEY"] = "sk-1234" # Your LiteLLM key
+
+# Configure agent with any model from your config
+options = ClaudeAgentOptions(
+ system_prompt="You are a helpful AI assistant.",
+ model="bedrock-claude-sonnet-4", # Use any model from config.yaml
+ max_turns=20,
+)
+
+async with ClaudeSDKClient(options=options) as client:
+ await client.query("What is LiteLLM?")
+
+ async for msg in client.receive_response():
+ if hasattr(msg, 'content'):
+ for content_block in msg.content:
+ if hasattr(content_block, 'text'):
+ print(content_block.text, end='', flush=True)
+```
+
+
+
+## Why Use LiteLLM with Agent SDK?
+
+| Feature | Benefit |
+|---------|---------|
+| **Multi-Provider** | Use the same agent code with OpenAI, Bedrock, Azure, Vertex AI, etc. |
+| **Cost Tracking** | Track spending across all agent conversations |
+| **Rate Limiting** | Set budgets and limits on agent usage |
+| **Load Balancing** | Distribute requests across multiple API keys or regions |
+| **Fallbacks** | Automatically retry with different models if one fails |
+
+## Complete Example
+
+See our [cookbook example](https://github.com/BerriAI/litellm/tree/main/cookbook/anthropic_agent_sdk) for a complete interactive CLI agent that:
+- Streams responses in real-time
+- Switches between models dynamically
+- Fetches available models from the proxy
+
+```bash
+# Clone and run the example
+git clone https://github.com/BerriAI/litellm.git
+cd litellm/cookbook/anthropic_agent_sdk
+pip install -r requirements.txt
+python main.py
+```
+
+## Related Resources
+
+- [Claude Agent SDK Documentation](https://github.com/anthropics/anthropic-agent-sdk)
+- [LiteLLM Proxy Quick Start](../proxy/quick_start)
+- [Complete Cookbook Example](https://github.com/BerriAI/litellm/tree/main/cookbook/anthropic_agent_sdk)
diff --git a/docs/my-website/docs/tutorials/claude_code_max_subscription.md b/docs/my-website/docs/tutorials/claude_code_max_subscription.md
new file mode 100644
index 00000000000..399051d41ea
--- /dev/null
+++ b/docs/my-website/docs/tutorials/claude_code_max_subscription.md
@@ -0,0 +1,357 @@
+import Image from '@theme/IdealImage';
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Using Claude Code Max Subscription
+
+
+
+
+Route Claude Code Max subscription traffic through LiteLLM AI Gateway.
+
+
+**Why Claude Code Max over direct API?**
+- **Lower costs** — Claude Code Max subscriptions are cheaper for Claude Code power users than per-token API pricing
+
+**Why route through LiteLLM?**
+- **Cost attribution** — Track spend per user, team, or key
+- **Budgets & rate limits** — Set spending caps and request limits
+- **Guardrails** — Apply content filtering and safety controls to all requests
+
+
+
+## Quick Start Video
+
+Watch the end-to-end walkthrough of setting up Claude Code with LiteLLM Gateway:
+
+
+
+## Prerequisites
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) installed
+- Claude Max subscription
+- LiteLLM Gateway running
+
+## Step 1: Configure LiteLLM Proxy
+
+Create a `config.yaml` with the critical `forward_client_headers_to_llm_api: true` setting:
+
+```yaml showLineNumbers title="config.yaml"
+model_list:
+ - model_name: anthropic-claude
+ litellm_params:
+ model: anthropic/claude-sonnet-4-20250514
+
+ - model_name: claude-3-5-sonnet-20241022
+ litellm_params:
+ model: anthropic/claude-3-5-sonnet-20241022
+
+ - model_name: claude-3-5-haiku-20241022
+ litellm_params:
+ model: anthropic/claude-3-5-haiku-20241022
+
+general_settings:
+ forward_client_headers_to_llm_api: true # Required: forwards OAuth token to Anthropic
+
+litellm_settings:
+ master_key: os.environ/LITELLM_MASTER_KEY
+```
+
+:::info Why `forward_client_headers_to_llm_api`?
+
+This setting forwards the user's OAuth token (in the `Authorization` header) through LiteLLM to the Anthropic API, enabling per-user authentication with their Max subscription while LiteLLM handles tracking and controls.
+
+:::
+
+## Step 2: Start LiteLLM Proxy
+
+```bash showLineNumbers title="Start LiteLLM Proxy"
+litellm --config /path/to/config.yaml
+
+# RUNNING on http://0.0.0.0:4000
+```
+
+## Walkthrough
+
+### Part 1: Create a Virtual Key in LiteLLM
+
+Navigate to the LiteLLM Dashboard and create a new virtual key for Claude Code usage.
+
+#### 1.1 Open Virtual Keys Page
+
+Navigate to the Virtual Keys section in the LiteLLM Dashboard.
+
+
+
+#### 1.2 Click "Create New Key"
+
+
+
+#### 1.3 Configure Key Details
+
+Enter a key name (e.g., `claude-code-test`) and select the models you want to allow access to.
+
+
+
+#### 1.4 Select Models
+
+Choose the Anthropic models that should be accessible via this key (e.g., `anthropic-claude`, `claude-4.5-haiku`).
+
+
+
+#### 1.5 Confirm Model Selection
+
+
+
+#### 1.6 Create the Key
+
+Click "Create Key" to generate your virtual key. Copy the generated key value (e.g., `sk-otsclFlEblQ-6D60ua2IZg`).
+
+
+
+---
+
+### Part 2: Sign into Claude Code Max Plan (Client Side)
+
+Set up Claude Code environment variables and authenticate with your Max subscription.
+
+#### 2.1 Set Environment Variables
+
+Configure Claude Code to use LiteLLM Gateway with your virtual key:
+
+```bash showLineNumbers title="Configure Claude Code Environment Variables"
+export ANTHROPIC_BASE_URL=http://localhost:4000
+export ANTHROPIC_MODEL="anthropic-claude"
+export ANTHROPIC_CUSTOM_HEADERS="x-litellm-api-key: Bearer sk-otsclFlEblQ-6D60ua2IZg"
+```
+
+
+
+#### Environment Variables Explained
+
+| Variable | Description |
+|----------|-------------|
+| `ANTHROPIC_BASE_URL` | Points Claude Code to your LiteLLM Gateway endpoint |
+| `ANTHROPIC_MODEL` | The model name configured in your LiteLLM `config.yaml` |
+| `ANTHROPIC_CUSTOM_HEADERS` | The `x-litellm-api-key` header for LiteLLM authentication |
+
+#### 2.2 Launch Claude Code
+
+Start Claude Code:
+
+```bash showLineNumbers title="Launch Claude Code"
+claude
+```
+
+
+
+#### 2.3 Select Login Method
+
+Choose "Claude account with subscription" (Pro, Max, Team, or Enterprise).
+
+
+
+#### 2.4 Authorize in Browser
+
+Claude Code opens your browser to authenticate. Click "Authorize" to connect your Claude Max account.
+
+
+
+#### 2.5 Login Successful
+
+After authorization, you'll see the login success confirmation.
+
+
+
+#### 2.6 Complete Setup
+
+Press Enter to continue past the security notes and complete the setup.
+
+
+
+---
+
+### Part 3: Use Claude Code with LiteLLM
+
+Now you can use Claude Code normally, and all requests will be tracked in LiteLLM.
+
+#### 3.1 Make a Request in Claude Code
+
+Start using Claude Code - requests will flow through LiteLLM Gateway.
+
+
+
+#### 3.2 View Logs in LiteLLM Dashboard
+
+Navigate to the Logs page in LiteLLM Dashboard to see all Claude Code requests.
+
+
+
+#### 3.3 View Request Details
+
+Click on a request to see detailed information including tokens, cost, duration, and model used.
+
+
+
+The logs show:
+- **Key Name**: `claude-code-test` (the virtual key you created)
+- **Model**: `anthropic/claude-sonnet-4-20250514`
+- **Tokens**: 65012 (64679 prompt + 333 completion)
+- **Cost**: $0.249754
+- **Status**: Success
+
+
+
+---
+
+## How It Works
+
+LiteLLM Gateway handles two types of authentication:
+1. **`x-litellm-api-key`**: Authenticates the request with LiteLLM (usage tracking, budgets, rate limits)
+2. **OAuth Token (via `Authorization` header)**: Forwarded to Anthropic API for Claude Max authentication
+
+```mermaid
+sequenceDiagram
+ participant User as Claude Code User
+ participant LiteLLM as LiteLLM AI Gateway
+ participant Anthropic as Anthropic API
+
+ User->>LiteLLM: Request with:
- x-litellm-api-key (LiteLLM auth)
- Authorization: Bearer {oauth_token}
+
+ Note over LiteLLM: 1. Validate x-litellm-api-key
2. Check budgets/rate limits
3. Log request for tracking
+
+ LiteLLM->>Anthropic: Forward request with:
- Authorization: Bearer {oauth_token}
(User's Claude Max OAuth token)
+
+ Note over Anthropic: Authenticate user via
OAuth token from Max plan
+
+ Anthropic-->>LiteLLM: Response
+
+ Note over LiteLLM: Log usage, tokens, cost
+
+ LiteLLM-->>User: Response
+```
+
+### Header Flow
+
+| Header | Purpose | Handled By |
+|--------|---------|------------|
+| `x-litellm-api-key` | LiteLLM Gateway authentication, budget tracking, rate limits | LiteLLM |
+| `Authorization: Bearer {oauth_token}` | Claude Max subscription authentication | Anthropic API |
+
+### Complete Request Flow Example
+
+Here's what a typical request looks like when Claude Code makes a call through LiteLLM:
+
+```bash showLineNumbers title="Example Request from Claude Code to LiteLLM"
+curl -X POST "http://localhost:4000/v1/messages" \
+ -H "x-litellm-api-key: Bearer sk-otsclFlEblQ-6D60ua2IZg" \
+ -H "Authorization: Bearer oauth_token_from_max_plan" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "model": "anthropic-claude",
+ "max_tokens": 1024,
+ "messages": [{"role": "user", "content": "Hello, Claude!"}]
+ }'
+```
+
+LiteLLM then:
+1. Validates `x-litellm-api-key` for gateway access
+2. Logs the request for usage tracking
+3. Forwards the request to Anthropic with the OAuth `Authorization` header (because of `forward_client_headers_to_llm_api: true`)
+
+## Advanced Configuration
+
+### Per-Model Header Forwarding
+
+For more granular control, you can enable header forwarding only for specific models:
+
+```yaml showLineNumbers title="config.yaml - Per-Model Header Forwarding"
+model_list:
+ - model_name: anthropic-claude
+ litellm_params:
+ model: anthropic/claude-sonnet-4-20250514
+
+ - model_name: claude-3-5-haiku-20241022
+ litellm_params:
+ model: anthropic/claude-3-5-haiku-20241022
+
+litellm_settings:
+ master_key: os.environ/LITELLM_MASTER_KEY
+ model_group_settings:
+ forward_client_headers_to_llm_api:
+ - anthropic-claude
+ - claude-3-5-haiku-20241022
+```
+
+### Budget Controls
+
+Set up per-user budgets while using Max subscriptions:
+
+```yaml showLineNumbers title="config.yaml - With Database for Budget Tracking"
+model_list:
+ - model_name: anthropic-claude
+ litellm_params:
+ model: anthropic/claude-sonnet-4-20250514
+
+general_settings:
+ forward_client_headers_to_llm_api: true
+ database_url: "postgresql://..."
+
+litellm_settings:
+ master_key: os.environ/LITELLM_MASTER_KEY
+```
+
+Then create virtual keys with budgets:
+
+```bash showLineNumbers title="Create Virtual Key with Budget"
+curl -X POST "http://localhost:4000/key/generate" \
+ -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "key_alias": "developer-1",
+ "max_budget": 100.00,
+ "budget_duration": "monthly"
+ }'
+```
+
+## Troubleshooting
+
+### OAuth Token Not Being Forwarded
+
+**Symptom**: Authentication errors from Anthropic API
+
+**Solution**: Ensure `forward_client_headers_to_llm_api: true` is set in your config:
+
+```yaml showLineNumbers title="config.yaml - Enable Header Forwarding"
+general_settings:
+ forward_client_headers_to_llm_api: true
+```
+
+### LiteLLM Authentication Failing
+
+**Symptom**: 401 errors from LiteLLM Gateway
+
+**Solution**: Verify `x-litellm-api-key` header is set correctly in `ANTHROPIC_CUSTOM_HEADERS`:
+
+```bash showLineNumbers title="Verify Key Info"
+curl -X GET "http://localhost:4000/key/info" \
+ -H "Authorization: Bearer sk-otsclFlEblQ-6D60ua2IZg"
+```
+
+### Model Not Found
+
+**Symptom**: Model not found errors
+
+**Solution**: Ensure the `ANTHROPIC_MODEL` matches a model name in your config:
+
+```bash showLineNumbers title="List Available Models"
+curl "http://localhost:4000/v1/models" \
+ -H "Authorization: Bearer sk-otsclFlEblQ-6D60ua2IZg"
+```
+
+## Related Documentation
+
+- [Forward Client Headers](/docs/proxy/forward_client_headers) - Detailed header forwarding configuration
+- [Claude Code Quickstart](/docs/tutorials/claude_responses_api) - Basic Claude Code + LiteLLM setup
+- [Virtual Keys](/docs/proxy/virtual_keys) - Creating and managing API keys
+- [Budgets & Rate Limits](/docs/proxy/users) - Setting up usage controls
diff --git a/docs/my-website/docs/tutorials/claude_code_plugin_marketplace.md b/docs/my-website/docs/tutorials/claude_code_plugin_marketplace.md
new file mode 100644
index 00000000000..9d93c717c4f
--- /dev/null
+++ b/docs/my-website/docs/tutorials/claude_code_plugin_marketplace.md
@@ -0,0 +1,279 @@
+import Image from '@theme/IdealImage';
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Claude Code Plugin Marketplace (Managed Skills)
+
+LiteLLM AI Gateway acts as a central registry for Claude Code plugins. Admins can govern which plugins are available across the organization, and engineers can discover and install approved plugins from a single source.
+
+## Prerequisites
+
+- LiteLLM Proxy running with database connected
+- Admin access to LiteLLM UI
+- Plugins hosted on GitHub, GitLab, or any git-accessible URL
+
+## Admin Guide: Managing the Marketplace
+
+### Step 1: Navigate to Claude Code Plugins
+
+In the LiteLLM Admin UI, click on **Claude Code Plugins** in the left navigation menu.
+
+
+
+### Step 2: View the Plugins List
+
+You'll see the list of all registered plugins. From here you can add, enable, disable, or delete plugins.
+
+
+
+### Step 3: Add a New Plugin
+
+Click **+ Add New Plugin** to register a plugin in your marketplace.
+
+
+
+### Step 4: Fill in Plugin Details
+
+Enter the plugin information:
+
+- **Name**: Plugin identifier (kebab-case, e.g., `my-plugin`)
+- **Source Type**: Choose GitHub or URL
+- **Repository/URL**: The git source (e.g., `org/repo` for GitHub)
+- **Version**: Semantic version (optional)
+- **Description**: What the plugin does
+- **Category**: Plugin category for organization
+- **Keywords**: Search terms
+
+
+
+### Step 5: Submit the Plugin
+
+After filling in the details, click **Add Plugin** to register it.
+
+
+
+### Step 6: Enable/Disable Plugins
+
+Toggle plugins on or off to control what appears in the public marketplace. Only **enabled** plugins are visible to engineers.
+
+
+
+## Engineer Guide: Installing Plugins
+
+### Step 1: Add the LiteLLM Marketplace
+
+Add your company's LiteLLM marketplace to Claude Code:
+
+```bash
+claude plugin marketplace add http://your-litellm-proxy:4000/claude-code/marketplace.json
+```
+
+
+
+### Step 2: Browse Available Plugins
+
+List all available plugins from the marketplace:
+
+```bash
+claude plugin search @litellm
+```
+
+### Step 3: Install a Plugin
+
+Install any plugin from the marketplace:
+
+```bash
+claude plugin install my-plugin@litellm
+```
+
+
+
+### Step 4: Verify Installation
+
+The plugin is now installed and ready to use:
+
+
+
+## API Reference
+
+### Public Endpoint (No Auth Required)
+
+#### GET `/claude-code/marketplace.json`
+
+Returns the marketplace catalog for Claude Code discovery.
+
+```bash
+curl http://localhost:4000/claude-code/marketplace.json
+```
+
+**Response:**
+```json
+{
+ "name": "litellm",
+ "owner": {
+ "name": "LiteLLM",
+ "email": "support@litellm.ai"
+ },
+ "plugins": [
+ {
+ "name": "my-plugin",
+ "source": {
+ "source": "github",
+ "repo": "org/my-plugin"
+ },
+ "version": "1.0.0",
+ "description": "My awesome plugin",
+ "category": "productivity",
+ "keywords": ["automation", "tools"]
+ }
+ ]
+}
+```
+
+### Admin Endpoints (Auth Required)
+
+#### POST `/claude-code/plugins`
+
+Register a new plugin.
+
+```bash
+curl -X POST http://localhost:4000/claude-code/plugins \
+ -H "Authorization: Bearer sk-..." \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "my-plugin",
+ "source": {"source": "github", "repo": "org/my-plugin"},
+ "version": "1.0.0",
+ "description": "My awesome plugin",
+ "category": "productivity",
+ "keywords": ["automation", "tools"]
+ }'
+```
+
+#### GET `/claude-code/plugins`
+
+List all registered plugins.
+
+```bash
+curl http://localhost:4000/claude-code/plugins \
+ -H "Authorization: Bearer sk-..."
+```
+
+#### POST `/claude-code/plugins/{name}/enable`
+
+Enable a plugin.
+
+```bash
+curl -X POST http://localhost:4000/claude-code/plugins/my-plugin/enable \
+ -H "Authorization: Bearer sk-..."
+```
+
+#### POST `/claude-code/plugins/{name}/disable`
+
+Disable a plugin.
+
+```bash
+curl -X POST http://localhost:4000/claude-code/plugins/my-plugin/disable \
+ -H "Authorization: Bearer sk-..."
+```
+
+#### DELETE `/claude-code/plugins/{name}`
+
+Delete a plugin.
+
+```bash
+curl -X DELETE http://localhost:4000/claude-code/plugins/my-plugin \
+ -H "Authorization: Bearer sk-..."
+```
+
+## Plugin Source Formats
+
+
+
+
+```json
+{
+ "name": "my-plugin",
+ "source": {
+ "source": "github",
+ "repo": "organization/repository"
+ }
+}
+```
+
+
+
+
+```json
+{
+ "name": "my-plugin",
+ "source": {
+ "source": "url",
+ "url": "https://github.com/org/repo.git"
+ }
+}
+```
+
+Use this format for GitLab, Bitbucket, or self-hosted git repositories.
+
+
+
+
+## Example: Setting Up an Internal Plugin Marketplace
+
+### 1. Create Internal Plugins
+
+Structure your plugin repository:
+
+```
+my-company-plugin/
+├── plugin.json # Plugin manifest
+├── SKILL.md # Main skill file
+├── skills/ # Additional skills
+│ └── helper.md
+└── README.md
+```
+
+### 2. Register Plugins via API
+
+```bash
+# Register your internal tools plugin
+curl -X POST http://localhost:4000/claude-code/plugins \
+ -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "internal-tools",
+ "source": {"source": "github", "repo": "mycompany/internal-tools"},
+ "version": "1.0.0",
+ "description": "Internal development tools and utilities",
+ "author": {"name": "Platform Team", "email": "platform@mycompany.com"},
+ "category": "internal",
+ "keywords": ["internal", "tools", "utilities"]
+ }'
+```
+
+### 3. Use in Claude Code
+
+Send engineers the marketplace URL:
+
+```bash
+# One-time setup for each engineer
+claude plugin marketplace add http://litellm.internal.company.com/claude-code/marketplace.json
+
+# Install company plugins
+claude plugin install internal-tools@litellm
+```
+
+## Troubleshooting
+
+**Plugin not appearing in marketplace:**
+- Verify the plugin is **enabled** in the admin UI
+- Check that the plugin has a valid `source` field
+
+**Installation fails:**
+- Ensure the git repository is accessible from the engineer's machine
+- For private repos, engineers need appropriate git credentials configured
+
+**Database errors:**
+- Verify LiteLLM proxy is connected to the database
+- Check proxy logs for detailed error messages
diff --git a/docs/my-website/docs/tutorials/claude_code_websearch.md b/docs/my-website/docs/tutorials/claude_code_websearch.md
index cc2f79666da..478fc960348 100644
--- a/docs/my-website/docs/tutorials/claude_code_websearch.md
+++ b/docs/my-website/docs/tutorials/claude_code_websearch.md
@@ -1,12 +1,16 @@
+import Image from '@theme/IdealImage';
+
# Claude Code - WebSearch Across All Providers
Enable Claude Code's web search tool to work with any provider (Bedrock, Azure, Vertex, etc.). LiteLLM automatically intercepts web search requests and executes them server-side.
+
+
## Proxy Configuration
Add WebSearch interception to your `litellm_config.yaml`:
-```yaml
+```yaml showLineNumbers title="litellm_config.yaml"
model_list:
- model_name: bedrock-sonnet
litellm_params:
@@ -37,7 +41,7 @@ search_tools:
Create `config.yaml`:
-```yaml
+```yaml showLineNumbers title="config.yaml"
model_list:
- model_name: bedrock-sonnet
litellm_params:
@@ -58,14 +62,14 @@ search_tools:
### 2. Start Proxy
-```bash
+```bash showLineNumbers title="Start LiteLLM Proxy"
export PERPLEXITY_API_KEY=your-key
litellm --config config.yaml
```
### 3. Use with Claude Code
-```bash
+```bash showLineNumbers title="Configure Claude Code"
export ANTHROPIC_BASE_URL=http://localhost:4000
export ANTHROPIC_API_KEY=sk-1234
claude
@@ -116,12 +120,19 @@ sequenceDiagram
Configure which search provider to use. LiteLLM supports multiple search providers:
-| Provider | Configuration |
-|----------|---------------|
-| **Perplexity** | `search_provider: perplexity` |
-| **Tavily** | `search_provider: tavily` |
+| Provider | `search_provider` Value | Environment Variable |
+|----------|------------------------|----------------------|
+| **Perplexity AI** | `perplexity` | `PERPLEXITYAI_API_KEY` |
+| **Tavily** | `tavily` | `TAVILY_API_KEY` |
+| **Exa AI** | `exa_ai` | `EXA_API_KEY` |
+| **Parallel AI** | `parallel_ai` | `PARALLEL_AI_API_KEY` |
+| **Google PSE** | `google_pse` | `GOOGLE_PSE_API_KEY`, `GOOGLE_PSE_ENGINE_ID` |
+| **DataForSEO** | `dataforseo` | `DATAFORSEO_LOGIN`, `DATAFORSEO_PASSWORD` |
+| **Firecrawl** | `firecrawl` | `FIRECRAWL_API_KEY` |
+| **SearXNG** | `searxng` | `SEARXNG_API_BASE` (required) |
+| **Linkup** | `linkup` | `LINKUP_API_KEY` |
-See [all supported search providers](../search/index.md) for the complete list.
+See [all supported search providers](../search/index.md) for detailed setup instructions and provider-specific parameters.
## Configuration Options
@@ -145,7 +156,7 @@ Use these values in `enabled_providers`:
### Complete Configuration Example
-```yaml
+```yaml showLineNumbers title="Complete config.yaml"
model_list:
- model_name: bedrock-sonnet
litellm_params:
diff --git a/docs/my-website/docs/tutorials/claude_responses_api.md b/docs/my-website/docs/tutorials/claude_responses_api.md
index 6b681d93a83..03ac9935fd2 100644
--- a/docs/my-website/docs/tutorials/claude_responses_api.md
+++ b/docs/my-website/docs/tutorials/claude_responses_api.md
@@ -37,18 +37,22 @@ Create a secure configuration using environment variables:
```yaml
model_list:
- # Claude models
- - model_name: claude-3-5-sonnet-20241022
+ # Configure the models you want to use
+ - model_name: claude-sonnet-4-5-20250929
litellm_params:
- model: anthropic/claude-3-5-sonnet-20241022
- api_key: os.environ/ANTHROPIC_API_KEY
-
- - model_name: claude-3-5-haiku-20241022
- litellm_params:
- model: anthropic/claude-3-5-haiku-20241022
+ model: anthropic/claude-sonnet-4-5-20250929
+ api_key: os.environ/ANTHROPIC_API_KEY
+
+ - model_name: claude-haiku-4-5-20251001
+ litellm_params:
+ model: anthropic/claude-haiku-4-5-20251001
+ api_key: os.environ/ANTHROPIC_API_KEY
+
+ - model_name: claude-opus-4-5-20251101
+ litellm_params:
+ model: anthropic/claude-opus-4-5-20251101
api_key: os.environ/ANTHROPIC_API_KEY
-
litellm_settings:
master_key: os.environ/LITELLM_MASTER_KEY
```
@@ -60,6 +64,10 @@ export ANTHROPIC_API_KEY="your-anthropic-api-key"
export LITELLM_MASTER_KEY="sk-1234567890" # Generate a secure key
```
+:::tip
+Alternatively, you can store `ANTHROPIC_API_KEY` in a `.env` file in your proxy directory. LiteLLM will automatically load it when starting.
+:::
+
### 2. Start proxy
```bash
@@ -111,15 +119,55 @@ export ANTHROPIC_AUTH_TOKEN="$LITELLM_MASTER_KEY"
### 5. Use Claude Code
-Start Claude Code and it will automatically use your configured models:
+Start Claude Code with the model you want to use:
```bash
-# Claude Code will use the models configured in your LiteLLM proxy
-claude
+# Specify model at startup
+claude --model claude-sonnet-4-5-20250929
-# Or specify a model if you have multiple configured
-claude --model claude-3-5-sonnet-20241022
-claude --model claude-3-5-haiku-20241022
+# Or specify a different model
+claude --model claude-haiku-4-5-20251001
+claude --model claude-opus-4-5-20251101
+
+# Or change model during a session
+claude
+/model claude-sonnet-4-5-20250929
+```
+
+Alternatively, set default models with environment variables:
+
+```bash
+export ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-5-20250929
+export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
+export ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-5-20251101
+claude
+```
+
+### Using 1M Context Window
+
+Claude Code supports extended context (1 million tokens) using the `[1m]` suffix:
+
+```bash
+# Use Sonnet with 1M context (requires quotes in shell)
+claude --model 'claude-sonnet-4-5-20250929[1m]'
+
+# Inside a Claude Code session (no quotes needed)
+/model claude-sonnet-4-5-20250929[1m]
+```
+
+:::warning
+**Important:** When using `--model` with `[1m]` in the shell, you must use quotes to prevent the shell from interpreting the brackets.
+:::
+
+**How it works:**
+- Claude Code strips the `[1m]` suffix before sending to LiteLLM
+- Claude Code automatically adds the header `anthropic-beta: context-1m-2025-08-07`
+- Your LiteLLM config should **NOT** include `[1m]` in model names
+
+**Verify 1M context is active:**
+```bash
+/context
+# Should show: 21k/1000k tokens (2%)
```
Example conversation:
@@ -140,6 +188,7 @@ Common issues and solutions:
**Model not found:**
- Ensure the model name in Claude Code matches exactly with your `config.yaml`
+- Use `--model` flag or environment variables to specify the model
- Check LiteLLM logs for detailed error messages
## Using Bedrock/Vertex AI/Azure Foundry Models
diff --git a/docs/my-website/docs/tutorials/cursor_integration.md b/docs/my-website/docs/tutorials/cursor_integration.md
index 3f462e1ee5d..49f88bd0487 100644
--- a/docs/my-website/docs/tutorials/cursor_integration.md
+++ b/docs/my-website/docs/tutorials/cursor_integration.md
@@ -1,3 +1,5 @@
+import Image from '@theme/IdealImage';
+
# Cursor Integration
Route Cursor IDE requests through LiteLLM for unified logging, budget controls, and access to any model.
@@ -76,6 +78,34 @@ Send a message. All requests now route through LiteLLM.
---
+## Connecting MCP Servers
+
+You can also connect MCP servers to Cursor via LiteLLM Proxy.
+
+For official instructions on configuring MCP integration with Cursor, please refer to the Cursor documentation here: [https://cursor.com/en-US/docs/context/mcp](https://cursor.com/en-US/docs/context/mcp).
+
+1. In Cursor Settings, go to the "Tools & MCP" tab and click "New MCP Server".
+
+2. In your `mcp.json`, add the following configuration:
+
+```
+{
+ "mcpServers": {
+ "litellm": {
+ "url": "http://localhost:4000/everything/mcp",
+ "type": "http",
+ "headers": {
+ "Authorization": "Bearer sk-LITELLM_VIRTUAL_KEY"
+ }
+ }
+ }
+}
+```
+
+3. LiteLLM's MCP will now appear under "Installed MCP Servers" in Cursor.
+
+
+
## Troubleshooting
| Issue | Solution |
diff --git a/docs/my-website/docs/tutorials/opencode_integration.md b/docs/my-website/docs/tutorials/opencode_integration.md
new file mode 100644
index 00000000000..e55367833f2
--- /dev/null
+++ b/docs/my-website/docs/tutorials/opencode_integration.md
@@ -0,0 +1,301 @@
+import Image from '@theme/IdealImage';
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# OpenCode Quickstart
+
+This tutorial shows how to connect OpenCode to your existing LiteLLM instance and switch between models.
+
+:::info
+
+This integration allows you to use any LiteLLM supported model through OpenCode with centralized authentication, usage tracking, and cost controls.
+
+:::
+
+
+
+### Video Walkthrough
+
+
+
+## Prerequisites
+
+- LiteLLM already configured and running (e.g., http://localhost:4000)
+- LiteLLM API key
+
+## Installation
+
+### Step 1: Install OpenCode
+
+Choose your preferred installation method:
+
+
+
+
+```bash
+curl -fsSL https://opencode.ai/install | bash
+```
+
+
+
+
+```bash
+npm install -g opencode-ai
+```
+
+
+
+
+```bash
+brew install sst/tap/opencode
+```
+
+
+
+
+Verify installation:
+
+```bash
+opencode --version
+```
+
+### Step 2: Configure LiteLLM Provider
+
+Create your OpenCode configuration file. You can place this in different locations depending on your needs:
+
+**Configuration locations:**
+- **Global**: `~/.config/opencode/opencode.json` (applies to all projects)
+- **Project**: `opencode.json` in your project root (project-specific settings)
+- **Custom**: Set `OPENCODE_CONFIG` environment variable
+
+Create `~/.config/opencode/opencode.json` (global config):
+
+```json
+{
+ "$schema": "https://opencode.ai/config.json",
+ "provider": {
+ "litellm": {
+ "npm": "@ai-sdk/openai-compatible",
+ "name": "LiteLLM",
+ "options": {
+ "baseURL": "http://localhost:4000/v1"
+ },
+ "models": {
+ "gpt-4": {
+ "name": "GPT-4"
+ },
+ "claude-3-5-sonnet-20241022": {
+ "name": "Claude 3.5 Sonnet"
+ },
+ "deepseek-chat": {
+ "name": "DeepSeek Chat"
+ }
+ }
+ }
+ }
+}
+```
+
+:::tip
+The keys in the "models" object (e.g., "gpt-4", "claude-3-5-sonnet-20241022") should match the `model_name` values from your LiteLLM configuration. The "name" field provides a friendly display name that will appear as an alias in OpenCode.
+:::
+
+### Step 3: Connect to LiteLLM Provider
+
+Launch OpenCode:
+
+```bash
+opencode
+```
+
+Add your API key:
+
+```bash
+/connect
+```
+
+Then:
+- **Enter provider name**: `LiteLLM` (must match the "name" field in your config)
+- **Enter your LiteLLM API key**: Your LiteLLM master key or virtual key
+
+### Step 4: Switch Between Models
+
+In OpenCode, run:
+
+```bash
+/models
+```
+
+Select any model from your LiteLLM configuration. OpenCode will route all requests through your LiteLLM instance.
+
+## Advanced Configuration
+
+### Model Parameters
+
+You can customize model parameters like context limits:
+
+```json
+{
+ "$schema": "https://opencode.ai/config.json",
+ "provider": {
+ "litellm": {
+ "npm": "@ai-sdk/openai-compatible",
+ "name": "LiteLLM",
+ "options": {
+ "baseURL": "http://localhost:4000/v1"
+ },
+ "models": {
+ "gpt-4": {
+ "name": "GPT-4",
+ "limit": {
+ "context": 128000,
+ "output": 4096
+ }
+ },
+ "claude-3-5-sonnet-20241022": {
+ "name": "Claude 3.5 Sonnet",
+ "limit": {
+ "context": 200000,
+ "output": 8192
+ }
+ }
+ }
+ }
+ }
+}
+```
+
+### Multi-Provider Setup
+
+You can configure multiple LiteLLM instances or mix with other providers:
+
+
+
+
+```json
+{
+ "$schema": "https://opencode.ai/config.json",
+ "provider": {
+ "litellm-prod": {
+ "npm": "@ai-sdk/openai-compatible",
+ "name": "LiteLLM Production",
+ "options": {
+ "baseURL": "https://your-prod-instance.com/v1"
+ },
+ "models": {
+ "gpt-4": {
+ "name": "GPT-4 (Production)"
+ }
+ }
+ },
+ "litellm-dev": {
+ "npm": "@ai-sdk/openai-compatible",
+ "name": "LiteLLM Development",
+ "options": {
+ "baseURL": "http://localhost:4000/v1"
+ },
+ "models": {
+ "gpt-4": {
+ "name": "GPT-4 (Development)"
+ }
+ }
+ }
+ }
+}
+```
+
+
+
+
+```json
+{
+ "$schema": "https://opencode.ai/config.json",
+ "provider": {
+ "litellm": {
+ "npm": "@ai-sdk/openai-compatible",
+ "name": "LiteLLM",
+ "options": {
+ "baseURL": "http://localhost:4000/v1"
+ },
+ "models": {
+ "gpt-4": {
+ "name": "GPT-4 via LiteLLM"
+ },
+ "claude-3-5-sonnet-20241022": {
+ "name": "Claude 3.5 Sonnet via LiteLLM"
+ }
+ }
+ },
+ "openai": {
+ "npm": "@ai-sdk/openai",
+ "name": "OpenAI Direct",
+ "models": {
+ "gpt-4o": {
+ "name": "GPT-4o (Direct)"
+ }
+ }
+ }
+ }
+}
+```
+
+
+
+
+## Example LiteLLM Configuration
+
+Here's an example LiteLLM `config.yaml` that works well with OpenCode:
+
+```yaml
+model_list:
+ # OpenAI models
+ - model_name: gpt-4
+ litellm_params:
+ model: openai/gpt-4
+ api_key: os.environ/OPENAI_API_KEY
+
+ - model_name: gpt-4o
+ litellm_params:
+ model: openai/gpt-4o
+ api_key: os.environ/OPENAI_API_KEY
+
+ # Anthropic models
+ - model_name: claude-3-5-sonnet-20241022
+ litellm_params:
+ model: anthropic/claude-3-5-sonnet-20241022
+ api_key: os.environ/ANTHROPIC_API_KEY
+
+ # DeepSeek models
+ - model_name: deepseek-chat
+ litellm_params:
+ model: deepseek/deepseek-chat
+ api_key: os.environ/DEEPSEEK_API_KEY
+```
+
+## Troubleshooting
+
+**OpenCode not connecting:**
+- Verify your LiteLLM proxy is running: `curl http://localhost:4000/health`
+- Check that the `baseURL` in your OpenCode config matches your LiteLLM instance
+- Ensure the provider name in `/connect` matches exactly with your config
+
+**Authentication errors:**
+- Verify your LiteLLM API key is correct
+- Check that your LiteLLM instance has authentication properly configured
+- Ensure your API key has access to the models you're trying to use
+
+**Model not found:**
+- Ensure the model names in OpenCode config match your LiteLLM `model_name` values
+- Check LiteLLM logs for detailed error messages
+- Verify the models are properly configured in your LiteLLM instance
+
+**Configuration not loading:**
+- Check the config file path and permissions
+- Validate JSON syntax using a JSON validator
+- Ensure the `$schema` URL is accessible
+
+## Tips
+
+- Add more models to the config as needed - they'll appear in `/models`
+- Use project-specific configs for different codebases with different model requirements
+- Monitor your LiteLLM proxy logs to see OpenCode requests in real-time
diff --git a/docs/my-website/img/a2a_agent_spend.png b/docs/my-website/img/a2a_agent_spend.png
new file mode 100644
index 0000000000000000000000000000000000000000..15ec769392a8f68c346b245819cc07c584d1e106
GIT binary patch
literal 188367
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
z
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