Merge branch 'main' into litellm_health_endpoint_issues_0001

2026-10-06 02:48:13 +00:00 · 2026-01-20 12:09:07 -08:00 · 2026-01-20 12:09:07 -08:00 · b66da96497
commit b66da96497
parent b27f28991a ce37729da4
800 changed files with 48704 additions and 6564 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -44,8 +44,8 @@ commands:
            pip install "pytest-asyncio==0.21.1"
            pip install "respx==0.22.0"
            pip install "hypercorn==0.17.3"
-            pip install "pydantic==2.10.2"
-            pip install "mcp==1.10.1"
+            pip install "pydantic==2.11.0"
+            pip install "mcp==1.25.0"
            pip install "requests-mock>=1.12.1"
            pip install "responses==0.25.7"
            pip install "pytest-xdist==3.6.1"
@ -1152,8 +1152,8 @@ jobs:
            pip install "pytest-cov==5.0.0"
            pip install "pytest-asyncio==0.21.1"
            pip install "respx==0.22.0"
-            pip install "pydantic==2.10.2"
-            pip install "mcp==1.10.1"
+            pip install "pydantic==2.11.0"
+            pip install "mcp==1.25.0"
      # Run pytest and generate JUnit XML report
      - run:
          name: Run tests
@ -1556,8 +1556,8 @@ jobs:
            pip install "pytest-asyncio==0.21.1"
            pip install "respx==0.22.0"
            pip install "hypercorn==0.17.3"
-            pip install "pydantic==2.10.2"
-            pip install "mcp==1.10.1"
+            pip install "pydantic==2.11.0"
+            pip install "mcp==1.25.0"
            pip install "requests-mock>=1.12.1"
            pip install "responses==0.25.7"
            pip install "pytest-xdist==3.6.1"
@ -1915,7 +1915,7 @@ jobs:
            pip install "pytest-asyncio==0.21.1"
            pip install "pytest-cov==5.0.0"
            pip install "tomli==2.2.1"
-            pip install "mcp==1.10.1"
+            pip install "mcp==1.25.0"
      - run:
          name: Run tests
          command: |
@ -1959,6 +1959,18 @@ jobs:
          command: |
            kind create cluster --name litellm-test

+      - run:
+          name: Build Docker image for helm tests
+          command: |
+            IMAGE_TAG=${CIRCLE_SHA1:-ci}
+            docker build -t litellm-ci:${IMAGE_TAG} -f docker/Dockerfile.database .
+
+      - run:
+          name: Load Docker image into Kind
+          command: |
+            IMAGE_TAG=${CIRCLE_SHA1:-ci}
+            kind load docker-image litellm-ci:${IMAGE_TAG} --name litellm-test
+
      # Run helm lint
      - run:
          name: Run helm lint
@ -1969,7 +1981,11 @@ jobs:
      - run:
          name: Run helm tests
          command: |
-            helm install litellm ./deploy/charts/litellm-helm -f ./deploy/charts/litellm-helm/ci/test-values.yaml
+            IMAGE_TAG=${CIRCLE_SHA1:-ci}
+            helm install litellm ./deploy/charts/litellm-helm -f ./deploy/charts/litellm-helm/ci/test-values.yaml \
+              --set image.repository=litellm-ci \
+              --set image.tag=${IMAGE_TAG} \
+              --set image.pullPolicy=Never
            # Wait for pod to be ready
            echo "Waiting 30 seconds for pod to be ready..."
            sleep 30
@ -2020,6 +2036,7 @@ jobs:
      - run: python ./tests/code_coverage_tests/info_log_check.py
      - run: python ./tests/code_coverage_tests/test_ban_set_verbose.py
      - run: python ./tests/code_coverage_tests/code_qa_check_tests.py
+      - run: python ./tests/code_coverage_tests/check_get_model_cost_key_performance.py
      - run: python ./tests/code_coverage_tests/test_proxy_types_import.py
      - run: python ./tests/code_coverage_tests/callback_manager_test.py
      - run: python ./tests/code_coverage_tests/recursive_detector.py
@ -2038,39 +2055,6 @@ jobs:
      - run: python ./tests/code_coverage_tests/memory_test.py
      - run: helm lint ./deploy/charts/litellm-helm

-  memory_leak_tests:
-    docker:
-      - image: cimg/python:3.11
-        auth:
-          username: ${DOCKERHUB_USERNAME}
-          password: ${DOCKERHUB_PASSWORD}
-    working_directory: ~/project
-    resource_class: large
-    steps:
-      - setup_litellm_test_deps
-      - run:
-          name: Install Memory Test Dependencies
-          command: |
-            pip install "psutil>=5.9.0"
-            pip install "fastapi>=0.100.0"
-            pip install "httpx>=0.24.0"
-            pip install "uvicorn>=0.23.0"
-      - run:
-          name: Run Linear Memory Growth Tests
-          command: |
-            echo "Running memory leak tests individually to avoid baseline drift..."
-            echo "Running test_memory_baseline_1k..."
-            python -m pytest tests/load_tests/test_linear_memory_growth.py::test_memory_baseline_1k -v -s --tb=short
-            echo "Running test_memory_baseline_2k..."
-            python -m pytest tests/load_tests/test_linear_memory_growth.py::test_memory_baseline_2k -v -s --tb=short
-            echo "Running test_memory_baseline_4k..."
-            python -m pytest tests/load_tests/test_linear_memory_growth.py::test_memory_baseline_4k -v -s --tb=short
-            echo "Running test_memory_baseline_10k..."
-            python -m pytest tests/load_tests/test_linear_memory_growth.py::test_memory_baseline_10k -v -s --tb=short
-            echo "Running test_memory_baseline_30k..."
-            python -m pytest tests/load_tests/test_linear_memory_growth.py::test_memory_baseline_30k -v -s --tb=short
-          no_output_timeout: 60m
-
  db_migration_disable_update_check:
    machine:
      image: ubuntu-2204:2023.10.1
@ -3821,12 +3805,6 @@ workflows:
              only:
                - main
                - /litellm_.*/
-      - memory_leak_tests:
-          filters:
-            branches:
-              only:
-                - main
-                - /litellm_.*/
      - ui_build:
          filters:
            branches:
--- a/.circleci/requirements.txt
+++ b/.circleci/requirements.txt
@ -8,12 +8,12 @@ redis==5.2.1
 redisvl==0.4.1
 anthropic
 orjson==3.10.12 # fast /embedding responses
-pydantic==2.10.2
+pydantic==2.11.0
 google-cloud-aiplatform==1.43.0
 google-cloud-iam==2.19.1
 fastapi-sso==0.16.0 
 uvloop==0.21.0
-mcp==1.10.1    # for MCP server  
+mcp==1.25.0    # for MCP server  
 semantic_router==0.1.10 # for auto-routing with litellm
 fastuuid==0.12.0
 responses==0.25.7  # for proxy client tests
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@ -7,6 +7,16 @@ body:
    attributes:
      value: |
        Thanks for taking the time to fill out this bug report!
+        
+        **💡 Tip:** See our [Troubleshooting Guide](https://docs.litellm.ai/docs/troubleshoot) for what information to include.
+  - type: checkboxes
+    id: duplicate-check
+    attributes:
+      label: Check for existing issues
+      description: Please search to see if an issue already exists for the bug you encountered.
+      options:
+        - label: I have searched the existing issues and checked that my issue is not a duplicate.
+          required: true
  - type: textarea
    id: what-happened
    attributes:
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@ -7,6 +7,14 @@ body:
    attributes:
      value: |
        Thanks for making LiteLLM better! 
+  - type: checkboxes
+    id: duplicate-check
+    attributes:
+      label: Check for existing issues
+      description: Please search to see if an issue already exists for the feature you are requesting.
+      options:
+        - label: I have searched the existing issues and checked that my issue is not a duplicate.
+          required: true
  - type: textarea
    id: the-feature
    attributes:
--- a/.github/workflows/check_duplicate_issues.yml
+++ b/.github/workflows/check_duplicate_issues.yml
@ -0,0 +1,29 @@
+name: Check Duplicate Issues
+
+on:
+  issues:
+    types: [opened, edited]
+
+jobs:
+  check-duplicate:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      contents: read
+    steps:
+      - name: Check for potential duplicates
+        uses: wow-actions/potential-duplicates@v1
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          label: potential-duplicate
+          threshold: 0.6
+          reaction: eyes
+          comment: |
+            **⚠️ Potential duplicate detected**
+            
+            This issue appears similar to existing issue(s):
+            {{#issues}}
+            - [#{{number}}]({{html_url}}) - {{title}} ({{accuracy}}% similar)
+            {{/issues}}
+            
+            Please review the linked issue(s) to see if they address your concern. If this is not a duplicate, please provide additional context to help us understand the difference.
--- a/.github/workflows/label-component.yml
+++ b/.github/workflows/label-component.yml
@ -80,3 +80,37 @@ jobs:
                break;
              }
            }
+
+            // Check for 'claude code' keyword (can be applied alongside component labels)
+            if (/claude code/i.test(body)) {
+              const claudeLabel = {
+                name: 'claude code',
+                color: '7c3aed',
+                description: 'Issues related to Claude Code usage'
+              };
+
+              try {
+                await github.rest.issues.getLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  name: claudeLabel.name
+                });
+              } catch (error) {
+                if (error.status === 404) {
+                  await github.rest.issues.createLabel({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    name: claudeLabel.name,
+                    color: claudeLabel.color,
+                    description: claudeLabel.description
+                  });
+                }
+              }
+
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                labels: [claudeLabel.name]
+              });
+            }
--- a/.github/workflows/test-litellm.yml
+++ b/.github/workflows/test-litellm.yml
@ -35,6 +35,7 @@ jobs:
        poetry run pip install "google-cloud-aiplatform>=1.38"
        poetry run pip install "fastapi-offline==1.7.3"
        poetry run pip install "python-multipart==0.0.18"
+        poetry run pip install "openapi-core"
    - name: Setup litellm-enterprise as local package
      run: |
        cd enterprise
--- a/.github/workflows/test-mcp.yml
+++ b/.github/workflows/test-mcp.yml
@ -34,8 +34,8 @@ jobs:
        poetry run pip install "pytest-cov==5.0.0"
        poetry run pip install "pytest-asyncio==0.21.1"
        poetry run pip install "respx==0.22.0"
-        poetry run pip install "pydantic==2.10.2"
-        poetry run pip install "mcp==1.10.1"
+        poetry run pip install "pydantic==2.11.0"
+        poetry run pip install "mcp==1.25.0"
        poetry run pip install pytest-xdist

    - name: Setup litellm-enterprise as local package
--- a/.gitignore
+++ b/.gitignore
@ -59,6 +59,7 @@ litellm/proxy/_super_secret_config.yaml
 litellm/proxy/myenv/bin/activate
 litellm/proxy/myenv/bin/Activate.ps1
 myenv/*
+litellm/proxy/_experimental/out/_next/
 litellm/proxy/_experimental/out/404/index.html
 litellm/proxy/_experimental/out/model_hub/index.html
 litellm/proxy/_experimental/out/onboarding/index.html
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@ -0,0 +1,398 @@
+# LiteLLM Architecture - LiteLLM SDK + AI Gateway
+
+This document helps contributors understand where to make changes in LiteLLM.
+
+---
+
+## How It Works
+
+The LiteLLM AI Gateway (Proxy) uses the LiteLLM SDK internally for all LLM calls:
+
+```
+OpenAI SDK (client)    ──▶  LiteLLM AI Gateway (proxy/)  ──▶  LiteLLM SDK (litellm/)  ──▶  LLM API
+Anthropic SDK (client) ──▶  LiteLLMAI Gateway (proxy/)  ──▶  LiteLLM SDK (litellm/)  ──▶  LLM API
+Any HTTP client        ──▶  LiteLLMAI Gateway (proxy/)  ──▶  LiteLLM SDK (litellm/)  ──▶  LLM API
+```
+
+The **AI Gateway** adds authentication, rate limiting, budgets, and routing on top of the SDK.
+The **SDK** handles the actual LLM provider calls, request/response transformations, and streaming.
+
+---
+
+## 1. AI Gateway (Proxy) Request Flow
+
+The AI Gateway (`litellm/proxy/`) wraps the SDK with authentication, rate limiting, and management features.
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant ProxyServer as proxy/proxy_server.py
+    participant Auth as proxy/auth/user_api_key_auth.py
+    participant Redis as Redis Cache
+    participant Hooks as proxy/hooks/
+    participant Router as router.py
+    participant Main as main.py + utils.py
+    participant Handler as llms/custom_httpx/llm_http_handler.py
+    participant Transform as llms/{provider}/chat/transformation.py
+    participant Provider as LLM Provider API
+    participant CostCalc as cost_calculator.py
+    participant LoggingObj as litellm_logging.py
+    participant DBWriter as db/db_spend_update_writer.py
+    participant Postgres as PostgreSQL
+
+    %% Request Flow
+    Client->>ProxyServer: POST /v1/chat/completions
+    ProxyServer->>Auth: user_api_key_auth()
+    Auth->>Redis: Check API key cache
+    Redis-->>Auth: Key info + spend limits
+    ProxyServer->>Hooks: max_budget_limiter, parallel_request_limiter
+    Hooks->>Redis: Check/increment rate limit counters
+    ProxyServer->>Router: route_request()
+    Router->>Main: litellm.acompletion()
+    Main->>Handler: BaseLLMHTTPHandler.completion()
+    Handler->>Transform: ProviderConfig.transform_request()
+    Handler->>Provider: HTTP Request
+    Provider-->>Handler: Response
+    Handler->>Transform: ProviderConfig.transform_response()
+    Transform-->>Handler: ModelResponse
+    Handler-->>Main: ModelResponse
+    
+    %% Cost Attribution (in utils.py wrapper)
+    Main->>LoggingObj: update_response_metadata()
+    LoggingObj->>CostCalc: _response_cost_calculator()
+    CostCalc->>CostCalc: completion_cost(tokens × price)
+    CostCalc-->>LoggingObj: response_cost
+    LoggingObj-->>Main: Set response._hidden_params["response_cost"]
+    Main-->>ProxyServer: ModelResponse (with cost in _hidden_params)
+    
+    %% Response Headers + Async Logging
+    ProxyServer->>ProxyServer: Extract cost from hidden_params
+    ProxyServer->>LoggingObj: async_success_handler()
+    LoggingObj->>Hooks: async_log_success_event()
+    Hooks->>DBWriter: update_database(response_cost)
+    DBWriter->>Redis: Queue spend increment
+    DBWriter->>Postgres: Batch write spend logs (async)
+    ProxyServer-->>Client: ModelResponse + x-litellm-response-cost header
+```
+
+### Proxy Components
+
+```mermaid
+graph TD
+    subgraph "Incoming Request"
+        Client["POST /v1/chat/completions"]
+    end
+
+    subgraph "proxy/proxy_server.py"
+        Endpoint["chat_completion()"]
+    end
+
+    subgraph "proxy/auth/"
+        Auth["user_api_key_auth()"]
+    end
+
+    subgraph "proxy/"
+        PreCall["litellm_pre_call_utils.py"]
+        RouteRequest["route_llm_request.py"]
+    end
+
+    subgraph "litellm/"
+        Router["router.py"]
+        Main["main.py"]
+    end
+
+    subgraph "Infrastructure"
+        DualCache["DualCache<br/>(in-memory + Redis)"]
+        Postgres["PostgreSQL<br/>(keys, teams, spend logs)"]
+    end
+
+    Client --> Endpoint
+    Endpoint --> Auth
+    Auth --> DualCache
+    DualCache -.->|cache miss| Postgres
+    Auth --> PreCall
+    PreCall --> RouteRequest
+    RouteRequest --> Router
+    Router --> DualCache
+    Router --> Main
+    Main --> Client
+```
+
+**Key proxy files:**
+- `proxy/proxy_server.py` - Main API endpoints
+- `proxy/auth/` - Authentication (API keys, JWT, OAuth2)
+- `proxy/hooks/` - Proxy-level callbacks
+- `router.py` - Load balancing, fallbacks
+- `router_strategy/` - Routing algorithms (`lowest_latency.py`, `simple_shuffle.py`, etc.)
+
+**LLM-specific proxy endpoints:**
+
+| Endpoint | Directory | Purpose |
+|----------|-----------|---------|
+| `/v1/messages` | `proxy/anthropic_endpoints/` | Anthropic Messages API |
+| `/vertex-ai/*` | `proxy/vertex_ai_endpoints/` | Vertex AI passthrough |
+| `/gemini/*` | `proxy/google_endpoints/` | Google AI Studio passthrough |
+| `/v1/images/*` | `proxy/image_endpoints/` | Image generation |
+| `/v1/batches` | `proxy/batches_endpoints/` | Batch processing |
+| `/v1/files` | `proxy/openai_files_endpoints/` | File uploads |
+| `/v1/fine_tuning` | `proxy/fine_tuning_endpoints/` | Fine-tuning jobs |
+| `/v1/rerank` | `proxy/rerank_endpoints/` | Reranking |
+| `/v1/responses` | `proxy/response_api_endpoints/` | OpenAI Responses API |
+| `/v1/vector_stores` | `proxy/vector_store_endpoints/` | Vector stores |
+| `/*` (passthrough) | `proxy/pass_through_endpoints/` | Direct provider passthrough |
+
+**Proxy Hooks** (`proxy/hooks/__init__.py`):
+
+| Hook | File | Purpose |
+|------|------|---------|
+| `max_budget_limiter` | `proxy/hooks/max_budget_limiter.py` | Enforce budget limits |
+| `parallel_request_limiter` | `proxy/hooks/parallel_request_limiter_v3.py` | Rate limiting per key/user |
+| `cache_control_check` | `proxy/hooks/cache_control_check.py` | Cache validation |
+| `responses_id_security` | `proxy/hooks/responses_id_security.py` | Response ID validation |
+| `litellm_skills` | `proxy/hooks/skills_injection.py` | Skills injection |
+
+To add a new proxy hook, implement `CustomLogger` and register in `PROXY_HOOKS`.
+
+### Infrastructure Components
+
+The AI Gateway uses external infrastructure for persistence and caching:
+
+```mermaid
+graph LR
+    subgraph "AI Gateway (proxy/)"
+        Proxy["proxy_server.py"]
+        Auth["auth/user_api_key_auth.py"]
+        DBWriter["db/db_spend_update_writer.py<br/>DBSpendUpdateWriter"]
+        InternalCache["utils.py<br/>InternalUsageCache"]
+        CostCallback["hooks/proxy_track_cost_callback.py<br/>_ProxyDBLogger"]
+        Scheduler["APScheduler<br/>ProxyStartupEvent"]
+    end
+
+    subgraph "SDK (litellm/)"
+        Router["router.py<br/>Router.cache (DualCache)"]
+        LLMCache["caching/caching_handler.py<br/>LLMCachingHandler"]
+        CacheClass["caching/caching.py<br/>Cache"]
+    end
+
+    subgraph "Redis (caching/redis_cache.py)"
+        RateLimit["Rate Limit Counters"]
+        SpendQueue["Spend Increment Queue"]
+        KeyCache["API Key Cache"]
+        TPM_RPM["TPM/RPM Tracking"]
+        Cooldowns["Deployment Cooldowns"]
+        LLMResponseCache["LLM Response Cache"]
+    end
+
+    subgraph "PostgreSQL (proxy/schema.prisma)"
+        Keys["LiteLLM_VerificationToken"]
+        Teams["LiteLLM_TeamTable"]
+        SpendLogs["LiteLLM_SpendLogs"]
+        Users["LiteLLM_UserTable"]
+    end
+
+    Auth --> InternalCache
+    InternalCache --> KeyCache
+    InternalCache -.->|cache miss| Keys
+    InternalCache --> RateLimit
+    Router --> TPM_RPM
+    Router --> Cooldowns
+    LLMCache --> CacheClass
+    CacheClass --> LLMResponseCache
+    CostCallback --> DBWriter
+    DBWriter --> SpendQueue
+    DBWriter --> SpendLogs
+    Scheduler --> SpendLogs
+    Scheduler --> Keys
+```
+
+| Component | Purpose | Key Files/Classes |
+|-----------|---------|-------------------|
+| **Redis** | Rate limiting, API key caching, TPM/RPM tracking, cooldowns, LLM response caching, spend queuing | `caching/redis_cache.py` (`RedisCache`), `caching/dual_cache.py` (`DualCache`) |
+| **PostgreSQL** | API keys, teams, users, spend logs | `proxy/utils.py` (`PrismaClient`), `proxy/schema.prisma` |
+| **InternalUsageCache** | Proxy-level cache for rate limits + API keys (in-memory + Redis) | `proxy/utils.py` (`InternalUsageCache`) |
+| **Router.cache** | TPM/RPM tracking, deployment cooldowns, client caching (in-memory + Redis) | `router.py` (`Router.cache: DualCache`) |
+| **LLMCachingHandler** | SDK-level LLM response/embedding caching | `caching/caching_handler.py` (`LLMCachingHandler`), `caching/caching.py` (`Cache`) |
+| **DBSpendUpdateWriter** | Batches spend updates to reduce DB writes | `proxy/db/db_spend_update_writer.py` (`DBSpendUpdateWriter`) |
+| **Cost Tracking** | Calculates and logs response costs | `proxy/hooks/proxy_track_cost_callback.py` (`_ProxyDBLogger`) |
+
+**Background Jobs** (APScheduler, initialized in `proxy/proxy_server.py` → `ProxyStartupEvent.initialize_scheduled_background_jobs()`):
+
+| Job | Interval | Purpose | Key Files |
+|-----|----------|---------|-----------|
+| `update_spend` | 60s | Batch write spend logs to PostgreSQL | `proxy/db/db_spend_update_writer.py` |
+| `reset_budget` | 10-12min | Reset budgets for keys/users/teams | `proxy/management_helpers/budget_reset_job.py` |
+| `add_deployment` | 10s | Sync new model deployments from DB | `proxy/proxy_server.py` (`ProxyConfig`) |
+| `cleanup_old_spend_logs` | cron/interval | Delete old spend logs | `proxy/management_helpers/spend_log_cleanup.py` |
+| `check_batch_cost` | 30min | Calculate costs for batch jobs | `proxy/management_helpers/check_batch_cost_job.py` |
+| `check_responses_cost` | 30min | Calculate costs for responses API | `proxy/management_helpers/check_responses_cost_job.py` |
+| `process_rotations` | 1hr | Auto-rotate API keys | `proxy/management_helpers/key_rotation_manager.py` |
+| `_run_background_health_check` | continuous | Health check model deployments | `proxy/proxy_server.py` |
+| `send_weekly_spend_report` | weekly | Slack spend alerts | `proxy/utils.py` (`SlackAlerting`) |
+| `send_monthly_spend_report` | monthly | Slack spend alerts | `proxy/utils.py` (`SlackAlerting`) |
+
+**Cost Attribution Flow:**
+1. LLM response returns to `utils.py` wrapper after `litellm.acompletion()` completes
+2. `update_response_metadata()` (`llm_response_utils/response_metadata.py`) is called
+3. `logging_obj._response_cost_calculator()` (`litellm_logging.py`) calculates cost via `litellm.completion_cost()` (`cost_calculator.py`)
+4. Cost is stored in `response._hidden_params["response_cost"]`
+5. `proxy/common_request_processing.py` extracts cost from `hidden_params` and adds to response headers (`x-litellm-response-cost`)
+6. `logging_obj.async_success_handler()` triggers callbacks including `_ProxyDBLogger.async_log_success_event()`
+7. `DBSpendUpdateWriter.update_database()` queues spend increments to Redis
+8. Background job `update_spend` flushes queued spend to PostgreSQL every 60s
+
+---
+
+## 2. SDK Request Flow
+
+The SDK (`litellm/`) provides the core LLM calling functionality used by both direct SDK users and the AI Gateway.
+
+```mermaid
+graph TD
+    subgraph "SDK Entry Points"
+        Completion["litellm.completion()"]
+        Messages["litellm.messages()"]
+    end
+
+    subgraph "main.py"
+        Main["completion()<br/>acompletion()"]
+    end
+
+    subgraph "utils.py"
+        GetProvider["get_llm_provider()"]
+    end
+
+    subgraph "llms/custom_httpx/"
+        Handler["llm_http_handler.py<br/>BaseLLMHTTPHandler"]
+        HTTP["http_handler.py<br/>HTTPHandler / AsyncHTTPHandler"]
+    end
+
+    subgraph "llms/{provider}/chat/"
+        TransformReq["transform_request()"]
+        TransformResp["transform_response()"]
+    end
+
+    subgraph "litellm_core_utils/"
+        Streaming["streaming_handler.py"]
+    end
+
+    subgraph "integrations/ (async, off main thread)"
+        Callbacks["custom_logger.py<br/>Langfuse, Datadog, etc."]
+    end
+
+    Completion --> Main
+    Messages --> Main
+    Main --> GetProvider
+    GetProvider --> Handler
+    Handler --> TransformReq
+    TransformReq --> HTTP
+    HTTP --> Provider["LLM Provider API"]
+    Provider --> HTTP
+    HTTP --> TransformResp
+    TransformResp --> Streaming
+    Streaming --> Response["ModelResponse"]
+    Response -.->|async| Callbacks
+```
+
+**Key SDK files:**
+- `main.py` - Entry points: `completion()`, `acompletion()`, `embedding()`
+- `utils.py` - `get_llm_provider()` resolves model → provider
+- `llms/custom_httpx/llm_http_handler.py` - Central HTTP orchestrator
+- `llms/custom_httpx/http_handler.py` - Low-level HTTP client
+- `llms/{provider}/chat/transformation.py` - Provider-specific transformations
+- `litellm_core_utils/streaming_handler.py` - Streaming response handling
+- `integrations/` - Async callbacks (Langfuse, Datadog, etc.)
+
+---
+
+## 3. Translation Layer
+
+When a request comes in, it goes through a **translation layer** that converts between API formats.
+Each translation is isolated in its own file, making it easy to test and modify independently.
+
+### Where to find translations
+
+| Incoming API | Provider | Translation File |
+|--------------|----------|------------------|
+| `/v1/chat/completions` | Anthropic | `llms/anthropic/chat/transformation.py` |
+| `/v1/chat/completions` | Bedrock Converse | `llms/bedrock/chat/converse_transformation.py` |
+| `/v1/chat/completions` | Bedrock Invoke | `llms/bedrock/chat/invoke_transformations/anthropic_claude3_transformation.py` |
+| `/v1/chat/completions` | Gemini | `llms/gemini/chat/transformation.py` |
+| `/v1/chat/completions` | Vertex AI | `llms/vertex_ai/gemini/transformation.py` |
+| `/v1/chat/completions` | OpenAI | `llms/openai/chat/gpt_transformation.py` |
+| `/v1/messages` (passthrough) | Anthropic | `llms/anthropic/experimental_pass_through/messages/transformation.py` |
+| `/v1/messages` (passthrough) | Bedrock | `llms/bedrock/messages/invoke_transformations/anthropic_claude3_transformation.py` |
+| `/v1/messages` (passthrough) | Vertex AI | `llms/vertex_ai/vertex_ai_partner_models/anthropic/experimental_pass_through/transformation.py` |
+| Passthrough endpoints | All | `proxy/pass_through_endpoints/llm_provider_handlers/` |
+
+### Example: Debugging prompt caching
+
+If `/v1/messages` → Bedrock Converse prompt caching isn't working but Bedrock Invoke works:
+
+1. **Bedrock Converse translation**: `llms/bedrock/chat/converse_transformation.py`
+2. **Bedrock Invoke translation**: `llms/bedrock/chat/invoke_transformations/anthropic_claude3_transformation.py`
+3. Compare how each handles `cache_control` in `transform_request()`
+
+### How translations work
+
+Each provider has a `Config` class that inherits from `BaseConfig` (`llms/base_llm/chat/transformation.py`):
+
+```python
+class ProviderConfig(BaseConfig):
+    def transform_request(self, model, messages, optional_params, litellm_params, headers):
+        # Convert OpenAI format → Provider format
+        return {"messages": transformed_messages, ...}
+    
+    def transform_response(self, model, raw_response, model_response, logging_obj, ...):
+        # Convert Provider format → OpenAI format
+        return ModelResponse(choices=[...], usage=Usage(...))
+```
+
+The `BaseLLMHTTPHandler` (`llms/custom_httpx/llm_http_handler.py`) calls these methods - you never need to modify the handler itself.
+
+---
+
+## 4. Adding/Modifying Providers
+
+### To add a new provider:
+
+1. Create `llms/{provider}/chat/transformation.py`
+2. Implement `Config` class with `transform_request()` and `transform_response()`
+3. Add tests in `tests/llm_translation/test_{provider}.py`
+
+### To add a feature (e.g., prompt caching):
+
+1. Find the translation file from the table above
+2. Modify `transform_request()` to handle the new parameter
+3. Add unit tests that verify the transformation
+
+### Testing checklist
+
+When adding a feature, verify it works across all paths:
+
+| Test | File Pattern |
+|------|--------------|
+| OpenAI passthrough | `tests/llm_translation/test_openai*.py` |
+| Anthropic direct | `tests/llm_translation/test_anthropic*.py` |
+| Bedrock Invoke | `tests/llm_translation/test_bedrock*.py` |
+| Bedrock Converse | `tests/llm_translation/test_bedrock*converse*.py` |
+| Vertex AI | `tests/llm_translation/test_vertex*.py` |
+| Gemini | `tests/llm_translation/test_gemini*.py` |
+
+### Unit testing translations
+
+Translations are designed to be unit testable without making API calls:
+
+```python
+from litellm.llms.bedrock.chat.converse_transformation import BedrockConverseConfig
+
+def test_prompt_caching_transform():
+    config = BedrockConverseConfig()
+    result = config.transform_request(
+        model="anthropic.claude-3-opus",
+        messages=[{"role": "user", "content": "test", "cache_control": {"type": "ephemeral"}}],
+        optional_params={},
+        litellm_params={},
+        headers={}
+    )
+    assert "cachePoint" in str(result)  # Verify cache_control was translated
+```
--- a/3
+++ b/3
@ -45,6 +45,7 @@ install-proxy-dev-ci:
 install-test-deps: install-proxy-dev
 	poetry run pip install "pytest-retry==1.6.3"
 	poetry run pip install pytest-xdist
+	poetry run pip install openapi-core
 	cd enterprise && poetry run pip install -e . && cd ..

 install-helm-unittest:
@ -100,4 +101,4 @@ test-llm-translation-single: install-test-deps
 	@mkdir -p test-results
 	poetry run pytest tests/llm_translation/$(FILE) \
 		--junitxml=test-results/junit.xml \
-		-v --tb=short --maxfail=100 --timeout=300
+		-v --tb=short --maxfail=100 --timeout=300
--- a/README.md
+++ b/README.md
@ -374,7 +374,9 @@ Support for more providers. Missing a provider or LLM Platform, raise a [feature
 1. (In root) create virtual environment `python -m venv .venv`
 2. Activate virtual environment `source .venv/bin/activate`
 3. Install dependencies `pip install -e ".[all]"`
-4. Start proxy backend `python litellm/proxy_cli.py`
+4. `pip install prisma`
+5. `prisma generate`
+6. Start proxy backend `python litellm/proxy/proxy_cli.py`

 ### Frontend
 1. Navigate to `ui/litellm-dashboard`
--- a/batch_small.jsonl
+++ b/batch_small.jsonl
@ -1,4 +0,0 @@
-{"custom_id": "request-1", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "gpt-3.5-turbo", "messages": [{"role": "user", "content": "Hello, how are you?"}]}}
-{"custom_id": "request-2", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "gpt-3.5-turbo", "messages": [{"role": "user", "content": "What is the weather today?"}]}}
-{"custom_id": "request-3", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "gpt-3.5-turbo", "messages": [{"role": "user", "content": "Tell me a short joke"}]}}
-
--- a/ci_cd/.grype.yaml
+++ b/ci_cd/.grype.yaml
@ -0,0 +1,3 @@
+ignore:
+  - vulnerability: CVE-2026-22184
+    reason: no fixed zlib package is available yet in the Wolfi repositories, so this is ignored temporarily until an upstream release exists
--- a/ci_cd/security_scans.sh
+++ b/ci_cd/security_scans.sh
@ -101,12 +101,12 @@ run_grype_scans() {
    # Build and scan Dockerfile.database
    echo "Building and scanning Dockerfile.database..."
    docker build --no-cache -t litellm-database:latest -f ./docker/Dockerfile.database .
-    grype litellm-database:latest --fail-on critical
+    grype litellm-database:latest --config ci_cd/.grype.yaml --fail-on critical
    
    # Build and scan main Dockerfile
    echo "Building and scanning main Dockerfile..."
    docker build --no-cache -t litellm:latest .
-    grype litellm:latest --fail-on critical
+    grype litellm:latest --config ci_cd/.grype.yaml --fail-on critical
    
    # Restore original .dockerignore
    echo "Restoring original .dockerignore..."
@ -129,6 +129,14 @@ run_grype_scans() {
        "CVE-2025-13836" # Python 3.13 HTTP response reading OOM/DoS - no fix available in base image
        "CVE-2025-12084" # Python 3.13 xml.dom.minidom quadratic algorithm - no fix available in base image
        "CVE-2025-60876" # BusyBox wget HTTP request splitting - no fix available in Chainguard Wolfi base image
+        "CVE-2026-0861" # Wolfi glibc still flagged even on 2.42-r5; upstream patched build unavailable yet
+        "CVE-2010-4756" # glibc glob DoS - awaiting patched Wolfi glibc build
+        "CVE-2019-1010022" # glibc stack guard bypass - awaiting patched Wolfi glibc build
+        "CVE-2019-1010023" # glibc ldd remap issue - awaiting patched Wolfi glibc build
+        "CVE-2019-1010024" # glibc ASLR mitigation bypass - awaiting patched Wolfi glibc build
+        "CVE-2019-1010025" # glibc pthread heap address leak - awaiting patched Wolfi glibc build
+        "CVE-2026-22184" # zlib untgz buffer overflow - untgz unused + no fixed Wolfi build yet
+        "GHSA-58pv-8j8x-9vj2" # jaraco.context path traversal - setuptools vendored only (v5.3.0), not used in application code (using v6.1.0+)
    )

    # Build JSON array of allowlisted CVE IDs for jq
--- a/cookbook/ai_coding_tool_guides/claude_code_quickstart/guide.md
+++ b/cookbook/ai_coding_tool_guides/claude_code_quickstart/guide.md
@ -0,0 +1,195 @@
+# Claude Code with LiteLLM Quickstart
+
+This guide shows how to call Claude models (and any LiteLLM-supported model) through LiteLLM proxy from Claude Code.
+
+> **Note:** This integration is based on [Anthropic's official LiteLLM configuration documentation](https://docs.anthropic.com/en/docs/claude-code/llm-gateway#litellm-configuration). It allows you to use any LiteLLM supported model through Claude Code with centralized authentication, usage tracking, and cost controls.
+
+## Video Walkthrough
+
+Watch the full tutorial: https://www.loom.com/embed/3c17d683cdb74d36a3698763cc558f56
+
+## Prerequisites
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) installed
+- API keys for your chosen providers
+
+## Installation
+
+First, install LiteLLM with proxy support:
+
+```bash
+pip install 'litellm[proxy]'
+```
+
+## Step 1: Setup config.yaml
+
+Create a secure configuration using environment variables:
+
+```yaml
+model_list:
+  # Claude models
+  - model_name: claude-3-5-sonnet-20241022    
+    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
+      api_key: os.environ/ANTHROPIC_API_KEY
+
+  
+litellm_settings:
+  master_key: os.environ/LITELLM_MASTER_KEY
+```
+
+Set your environment variables:
+
+```bash
+export ANTHROPIC_API_KEY="your-anthropic-api-key"
+export LITELLM_MASTER_KEY="sk-1234567890"  # Generate a secure key
+```
+
+## Step 2: Start Proxy
+
+```bash
+litellm --config /path/to/config.yaml
+
+# RUNNING on http://0.0.0.0:4000
+```
+
+## Step 3: Verify Setup
+
+Test that your proxy is working correctly:
+
+```bash
+curl -X POST http://0.0.0.0:4000/v1/messages \
+-H "Authorization: Bearer $LITELLM_MASTER_KEY" \
+-H "Content-Type: application/json" \
+-d '{
+    "model": "claude-3-5-sonnet-20241022",
+    "max_tokens": 1000,
+    "messages": [{"role": "user", "content": "What is the capital of France?"}]
+}'
+```
+
+## Step 4: Configure Claude Code
+
+### Method 1: Unified Endpoint (Recommended)
+
+Configure Claude Code to use LiteLLM's unified endpoint. Either a virtual key or master key can be used here:
+
+```bash
+export ANTHROPIC_BASE_URL="http://0.0.0.0:4000"
+export ANTHROPIC_AUTH_TOKEN="$LITELLM_MASTER_KEY"
+```
+
+> **Tip:** LITELLM_MASTER_KEY gives Claude access to all proxy models, whereas a virtual key would be limited to the models set in the UI.
+
+### Method 2: Provider-specific Pass-through Endpoint
+
+Alternatively, use the Anthropic pass-through endpoint:
+
+```bash
+export ANTHROPIC_BASE_URL="http://0.0.0.0:4000/anthropic"
+export ANTHROPIC_AUTH_TOKEN="$LITELLM_MASTER_KEY"
+```
+
+## Step 5: Use Claude Code
+
+Start Claude Code and it will automatically use your configured models:
+
+```bash
+# Claude Code will use the models configured in your LiteLLM proxy
+claude
+
+# Or specify a model if you have multiple configured
+claude --model claude-3-5-sonnet-20241022
+claude --model claude-3-5-haiku-20241022
+```
+
+## Troubleshooting
+
+Common issues and solutions:
+
+**Claude Code not connecting:**
+- Verify your proxy is running: `curl http://0.0.0.0:4000/health`
+- Check that `ANTHROPIC_BASE_URL` is set correctly
+- Ensure your `ANTHROPIC_AUTH_TOKEN` matches your LiteLLM master key
+
+**Authentication errors:**
+- Verify your environment variables are set: `echo $LITELLM_MASTER_KEY`
+- Check that your API keys are valid and have sufficient credits
+- Ensure the `ANTHROPIC_AUTH_TOKEN` matches your LiteLLM master key
+
+**Model not found:**
+- Ensure the model name in Claude Code matches exactly with your `config.yaml`
+- Check LiteLLM logs for detailed error messages
+
+## Using Multiple Models and Providers
+
+Expand your configuration to support multiple providers and models:
+
+```yaml
+model_list:
+  # OpenAI models
+  - model_name: codex-mini
+    litellm_params:  
+      model: openai/codex-mini
+      api_key: os.environ/OPENAI_API_KEY
+      api_base: https://api.openai.com/v1
+
+  - model_name: o3-pro
+    litellm_params:
+      model: openai/o3-pro
+      api_key: os.environ/OPENAI_API_KEY
+      api_base: https://api.openai.com/v1
+
+  - model_name: gpt-4o
+    litellm_params:
+      model: openai/gpt-4o
+      api_key: os.environ/OPENAI_API_KEY
+      api_base: https://api.openai.com/v1
+
+  # 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
+  
+  - model_name: claude-3-5-haiku-20241022
+    litellm_params:
+      model: anthropic/claude-3-5-haiku-20241022
+      api_key: os.environ/ANTHROPIC_API_KEY
+
+  # AWS Bedrock
+  - model_name: claude-bedrock
+    litellm_params:
+      model: bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0
+      aws_access_key_id: os.environ/AWS_ACCESS_KEY_ID
+      aws_secret_access_key: os.environ/AWS_SECRET_ACCESS_KEY
+      aws_region_name: us-east-1
+
+litellm_settings:
+  master_key: os.environ/LITELLM_MASTER_KEY
+```
+
+Switch between models seamlessly:
+
+```bash
+# Use Claude for complex reasoning
+claude --model claude-3-5-sonnet-20241022
+
+# Use Haiku for fast responses
+claude --model claude-3-5-haiku-20241022
+
+# Use Bedrock deployment
+claude --model claude-bedrock
+```
+
+## Additional Resources
+
+- [LiteLLM Documentation](https://docs.litellm.ai/)
+- [Claude Code Documentation](https://docs.anthropic.com/en/docs/claude-code/overview)
+- [Anthropic's LiteLLM Configuration Guide](https://docs.anthropic.com/en/docs/claude-code/llm-gateway#litellm-configuration)
+
--- a/cookbook/ai_coding_tool_guides/index.json
+++ b/cookbook/ai_coding_tool_guides/index.json
@ -0,0 +1,134 @@
+[{
+    "title": "Claude Code Quickstart",
+    "description": "This is a quickstart guide to using Claude Code with LiteLLM.",
+    "url": "https://docs.litellm.ai/docs/tutorials/claude_responses_api",
+    "date": "2026-01-15",
+    "version": "1.0.0",
+    "tags": [
+        "Claude Code",
+        "LiteLLM"
+    ]
+},
+{
+    "title": "Claude Code with MCPs",
+    "description": "This is a guide to using Claude Code with MCPs via LiteLLM Proxy.",
+    "url": "https://docs.litellm.ai/docs/tutorials/claude_mcp",
+    "date": "2026-01-15",
+    "version": "1.0.0",
+    "tags": [
+        "Claude Code",
+        "LiteLLM",
+        "MCP"
+    ]
+}, 
+{
+    "title": "Claude Code with Non-Anthropic Models",
+    "description": "This is a guide to using Claude Code with non-Anthropic models via LiteLLM Proxy.",
+    "url": "https://docs.litellm.ai/docs/tutorials/claude_non_anthropic_models",
+    "date": "2026-01-16",
+    "version": "1.0.0",
+    "tags": [
+        "Claude Code",
+        "LiteLLM",
+        "OpenAI",
+        "Gemini"
+    ]
+},
+{
+    "title": "Cursor Quickstart",
+    "description": "This is a quickstart guide to using Cursor with LiteLLM.",
+    "url": "https://docs.litellm.ai/docs/tutorials/cursor_integration",
+    "date": "2026-01-16",
+    "version": "1.0.0",
+    "tags": [
+        "Cursor",
+        "LiteLLM",
+        "Quickstart"
+    ]
+},
+{
+    "title": "Github Copilot Quickstart",
+    "description": "This is a quickstart guide to using Github Copilot with LiteLLM.",
+    "url": "https://docs.litellm.ai/docs/tutorials/github_copilot_integration",
+    "date": "2026-01-16",
+    "version": "1.0.0",
+    "tags": [
+        "Github Copilot",
+        "LiteLLM",
+        "Quickstart"
+    ]
+},
+{
+    "title": "LiteLLM Gemini CLI Quickstart",
+    "description": "This is a quickstart guide to using LiteLLM Gemini CLI.",
+    "url": "https://docs.litellm.ai/docs/tutorials/litellm_gemini_cli",
+    "date": "2026-01-16",
+    "version": "1.0.0",
+    "tags": [
+        "Gemini CLI",
+        "Gemini",
+        "LiteLLM",
+        "Quickstart"
+    ]
+},
+{
+    "title": "OpenAI Codex CLI Quickstart",
+    "description": "This is a quickstart guide to using OpenAI Codex CLI.",
+    "url": "https://docs.litellm.ai/docs/tutorials/openai_codex",
+    "date": "2026-01-16",
+    "version": "1.0.0",
+    "tags": [
+        "OpenAI Codex CLI",
+        "OpenAI",
+        "LiteLLM",
+        "Quickstart"
+    ]
+},
+{
+    "title": "OpenWebUI Quickstart",
+    "description": "This is a quickstart guide to using OpenWebUI with LiteLLM.",
+    "url": "https://docs.litellm.ai/docs/tutorials/openweb_ui",
+    "date": "2026-01-16",
+    "version": "1.0.0",
+    "tags": [
+        "OpenWebUI",
+        "LiteLLM",
+        "Quickstart"
+    ]
+},
+{
+    "title": "AI Coding Tool Usage Tracking",
+    "description": "This is a guide to tracking usage for AI coding tools monitor the use of Claude Code , Google Antigravity, OpenAI Codex, Roo Code etc. through LiteLLM.",
+    "url": "https://docs.litellm.ai/docs/tutorials/cost_tracking_coding",
+    "date": "2026-01-17",
+    "version": "1.0.0",
+    "tags": [
+        "Claude Code",
+        "Gemini CLI",
+        "OpenAI Codex",
+        "LiteLLM"
+    ]
+},
+{
+    "title": "Use Web Search with Claude Code (across Bedrock/OpenAI/Gemini/etc.)",
+    "description": "This is a guide for using Web Search with Claude Code via LiteLLM.",
+    "url": "https://docs.litellm.ai/docs/tutorials/claude_code_websearch",
+    "date": "2026-01-17",
+    "version": "1.0.0",
+    "tags": [
+        "Claude Code",
+        "LiteLLM",
+        "Web Search"
+    ]
+},
+{
+    "title": "Track Claude Code Usage per user via Custom Headers",
+    "description": "This is a guide for tracking claude code user usage by passing a customer ID header.",
+    "url": "https://docs.litellm.ai/docs/tutorials/claude_code_customer_tracking",
+    "date": "2026-01-17",
+    "version": "1.0.0",
+    "tags": [
+        "Claude Code",
+        "LiteLLM"
+    ]
+}]
--- a/deploy/charts/litellm-helm/Chart.yaml
+++ b/deploy/charts/litellm-helm/Chart.yaml
@ -18,7 +18,7 @@ type: application
 # This is the chart version. This version number should be incremented each time you make changes
 # to the chart and its templates, including the app version.
 # Versions are expected to follow Semantic Versioning (https://semver.org/)
-version: 1.0.0
+version: 1.1.0

 # This is the version number of the application being deployed. This version number should be
 # incremented each time you make changes to the application. Versions are not expected to
--- a/deploy/charts/litellm-helm/templates/deployment.yaml
+++ b/deploy/charts/litellm-helm/templates/deployment.yaml
@ -10,7 +10,7 @@ metadata:
    {{- toYaml .Values.deploymentLabels | nindent 4 }}
    {{- end }}
 spec:
-  {{- if not .Values.autoscaling.enabled }}
+  {{- if and (not .Values.keda.enabled) (not .Values.autoscaling.enabled) }}
  replicas: {{ .Values.replicaCount }}
  {{- end }}
  selector:
@ -170,7 +170,8 @@ spec:
            {{- toYaml .Values.resources | nindent 12 }}
          volumeMounts:
            - name: litellm-config
-              mountPath: /etc/litellm/
+              mountPath: /etc/litellm/config.yaml
+              subPath: config.yaml
          {{ if .Values.securityContext.readOnlyRootFilesystem }}
            - name: tmp
              mountPath: /tmp
--- a/deploy/charts/litellm-helm/templates/keda.yaml
+++ b/deploy/charts/litellm-helm/templates/keda.yaml
@ -0,0 +1,37 @@
+{{- if and .Values.keda.enabled (not .Values.autoscaling.enabled) }}
+apiVersion: keda.sh/v1alpha1
+kind: ScaledObject
+metadata:
+  name: {{ include "litellm.fullname" . }}
+  labels:
+    {{- include "litellm.labels" . | nindent 4 }}
+  {{- if .Values.keda.scaledObject.annotations }}
+  annotations: {{ toYaml .Values.keda.scaledObject.annotations | nindent 4 }}
+  {{- end }}
+spec:
+  scaleTargetRef:
+    name: {{ include "litellm.fullname" . }}
+  pollingInterval: {{ .Values.keda.pollingInterval }}
+  cooldownPeriod: {{ .Values.keda.cooldownPeriod }}
+  minReplicaCount: {{ .Values.keda.minReplicas }}
+  maxReplicaCount: {{ .Values.keda.maxReplicas }}
+{{- with .Values.keda.fallback }}
+  fallback:
+    failureThreshold: {{ .failureThreshold | default 3 }}
+    replicas: {{ .replicas | default $.Values.keda.maxReplicas }}
+{{- end }}
+  triggers:
+{{- with .Values.keda.triggers }}
+  {{- toYaml . | nindent 2 }}
+{{- end }}
+  advanced:
+    restoreToOriginalReplicaCount: {{ .Values.keda.restoreToOriginalReplicaCount }}
+{{- if .Values.keda.behavior }}
+    horizontalPodAutoscalerConfig:
+      behavior:
+{{- with .Values.keda.behavior }}
+{{- toYaml . | nindent 8 }}
+{{- end }}
+
+{{- end }}
+{{- end }}
--- a/deploy/charts/litellm-helm/tests/deployment_tests.yaml
+++ b/deploy/charts/litellm-helm/tests/deployment_tests.yaml
@ -136,7 +136,8 @@ tests:
          path: spec.template.spec.containers[0].volumeMounts
          content:
            name: litellm-config
-            mountPath: /etc/litellm/
+            mountPath: /etc/litellm/config.yaml
+            subPath: config.yaml
  - it: should work with lifecycle hooks
    template: deployment.yaml
    set:
--- a/deploy/charts/litellm-helm/values.yaml
+++ b/deploy/charts/litellm-helm/values.yaml
@ -156,6 +156,40 @@ autoscaling:
  targetCPUUtilizationPercentage: 80
  # targetMemoryUtilizationPercentage: 80

+# Autoscaling with keda is mutually exclusive with hpa
+keda:
+  enabled: false
+  minReplicas: 1
+  maxReplicas: 100
+  pollingInterval: 30
+  cooldownPeriod: 300
+  # fallback:
+  #   failureThreshold: 3
+  #   replicas: 11
+  restoreToOriginalReplicaCount: false
+  scaledObject:
+    annotations: {}
+  triggers: []
+  # - type: prometheus
+  #   metadata:
+  #     serverAddress: http://<prometheus-host>:9090
+  #     metricName: http_requests_total
+  #     threshold: '100'
+  #     query: sum(rate(http_requests_total{deployment="my-deployment"}[2m]))
+  behavior: {}
+  # scaleDown:
+  #   stabilizationWindowSeconds: 300
+  #   policies:
+  #   - type: Pods
+  #     value: 1
+  #     periodSeconds: 180
+  # scaleUp:
+  #   stabilizationWindowSeconds: 300
+  #   policies:
+  #   - type: Pods
+  #     value: 2
+  #     periodSeconds: 60
+
 # Additional volumes on the output Deployment definition.
 volumes: []
 # - name: foo
--- a/docker/Dockerfile.health_check
+++ b/docker/Dockerfile.health_check
@ -0,0 +1,16 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Copy health check script and requirements
+COPY scripts/health_check/health_check_client.py /app/health_check_client.py
+COPY scripts/health_check/health_check_requirements.txt /app/requirements.txt
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Make script executable
+RUN chmod +x /app/health_check_client.py
+
+# Set entrypoint
+ENTRYPOINT ["python", "/app/health_check_client.py"]
--- a/docker/supervisord.conf
+++ b/docker/supervisord.conf
@ -1,6 +1,8 @@
 [supervisord]
 nodaemon=true
 loglevel=info
+logfile=/tmp/supervisord.log
+pidfile=/tmp/supervisord.pid

 [group:litellm]
 programs=main,health
--- a/docs/my-website/docs/adding_provider/generic_guardrail_api.md
+++ b/docs/my-website/docs/adding_provider/generic_guardrail_api.md
@ -237,6 +237,27 @@ litellm_settings:
          language: "en"
 ```

+### Example: Pillar Security
+
+[Pillar Security](https://pillar.security) uses the Generic Guardrail API to provide comprehensive AI security scanning including prompt injection protection, PII/PCI detection, secret detection, and content moderation.
+
+```yaml
+guardrails:
+  - guardrail_name: "pillar-security"
+    litellm_params:
+      guardrail: generic_guardrail_api
+      mode: [pre_call, post_call]
+      api_base: https://api.pillar.security/api/v1/integrations/litellm
+      api_key: os.environ/PILLAR_API_KEY
+      default_on: true
+      additional_provider_specific_params:
+        plr_mask: true      # Enable automatic masking of sensitive data
+        plr_evidence: true  # Include detection evidence in response
+        plr_scanners: true  # Include scanner details in response
+```
+
+See the [Pillar Security documentation](../proxy/guardrails/pillar_security.md) for full configuration options.
+
 ## Usage

 Users apply your guardrail by name:
--- a/docs/my-website/docs/caching/all_caches.md
+++ b/docs/my-website/docs/caching/all_caches.md
@ -105,6 +105,14 @@ Then simply initialize:
 litellm.cache = Cache(type="redis")
 ```

+:::info
+Use `REDIS_*` environment variables as the primary mechanism for configuring all Redis client library parameters. This approach automatically maps environment variables to Redis client kwargs and is the suggested way to toggle Redis settings.
+:::
+
+:::warning
+If you need to pass non-string Redis parameters (integers, booleans, complex objects), avoid `REDIS_*` environment variables as they may fail during Redis client initialization. Instead, pass them directly as kwargs to the `Cache()` constructor.
+:::
+
 </TabItem>

 <TabItem value="gcs" label="gcs-cache">
--- a/docs/my-website/docs/completion/json_mode.md
+++ b/docs/my-website/docs/completion/json_mode.md
@ -341,4 +341,90 @@ curl http://0.0.0.0:4000/v1/chat/completions \
 ```

 </TabItem>
-</Tabs>
+</Tabs>
+
+## Gemini - Native JSON Schema Format (Gemini 2.0+)
+
+Gemini 2.0+ models automatically use the native `responseJsonSchema` parameter, which provides better compatibility with standard JSON Schema format.
+
+### Benefits (Gemini 2.0+):
+- Standard JSON Schema format (lowercase types like `string`, `object`)
+- Supports `additionalProperties: false` for stricter validation
+- Better compatibility with Pydantic's `model_json_schema()`
+- No `propertyOrdering` required
+
+### Usage
+
+<Tabs>
+<TabItem value="sdk" label="SDK">
+
+```python
+from litellm import completion
+from pydantic import BaseModel
+
+class UserInfo(BaseModel):
+    name: str
+    age: int
+
+response = completion(
+    model="gemini/gemini-2.0-flash",
+    messages=[{"role": "user", "content": "Extract: John is 25 years old"}],
+    response_format={
+        "type": "json_schema",
+        "json_schema": {
+            "name": "user_info",
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "age": {"type": "integer"}
+                },
+                "required": ["name", "age"],
+                "additionalProperties": False  # Supported on Gemini 2.0+
+            }
+        }
+    }
+)
+```
+
+</TabItem>
+<TabItem value="proxy" label="PROXY">
+
+```bash
+curl http://0.0.0.0:4000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $LITELLM_API_KEY" \
+  -d '{
+    "model": "gemini-2.0-flash",
+    "messages": [
+        {"role": "user", "content": "Extract: John is 25 years old"}
+    ],
+    "response_format": {
+        "type": "json_schema",
+        "json_schema": {
+            "name": "user_info",
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "age": {"type": "integer"}
+                },
+                "required": ["name", "age"],
+                "additionalProperties": false
+            }
+        }
+    }
+  }'
+```
+
+</TabItem>
+</Tabs>
+
+### Model Behavior
+
+| Model | Format Used | `additionalProperties` Support |
+|-------|-------------|-------------------------------|
+| Gemini 2.0+ | `responseJsonSchema` (JSON Schema) | ✅ Yes |
+| Gemini 1.5 | `responseSchema` (OpenAPI) | ❌ No |
+
+LiteLLM automatically selects the appropriate format based on the model version.
--- a/docs/my-website/docs/completion/token_usage.md
+++ b/docs/my-website/docs/completion/token_usage.md
@ -100,7 +100,7 @@ from litellm import cost_per_token

 prompt_tokens =  5
 completion_tokens = 10
-prompt_tokens_cost_usd_dollar, completion_tokens_cost_usd_dollar = cost_per_token(model="gpt-3.5-turbo", prompt_tokens=prompt_tokens, completion_tokens=completion_tokens))
+prompt_tokens_cost_usd_dollar, completion_tokens_cost_usd_dollar = cost_per_token(model="gpt-3.5-turbo", prompt_tokens=prompt_tokens, completion_tokens=completion_tokens)

 print(prompt_tokens_cost_usd_dollar, completion_tokens_cost_usd_dollar)
 ```
@ -162,7 +162,7 @@ print(model_cost) # {'gpt-3.5-turbo': {'max_tokens': 4000, 'input_cost_per_token

 **Dictionary**
 ```python
-from litellm import register_model
+import litellm

 litellm.register_model({
        "gpt-4": {
--- a/docs/my-website/docs/contributing.md
+++ b/docs/my-website/docs/contributing.md
@ -1,45 +1,100 @@
 # Contributing - UI

-Here's how to run the LiteLLM UI locally for making changes: 
+Thanks for contributing to the LiteLLM UI! This guide will help you set up your local development environment.
+
+
+## 1. Clone the repo

-## 1. Clone the repo 
 ```bash
 git clone https://github.com/BerriAI/litellm.git
+cd litellm
 ```

-## 2. Start the UI + Proxy 
+## 2. Start the Proxy

-**2.1 Start the proxy on port 4000** 
+Create a config file (e.g., `config.yaml`):

-Tell the proxy where the UI is located
-```bash
-DATABASE_URL = "postgresql://<user>:<password>@<host>:<port>/<dbname>"
-LITELLM_MASTER_KEY = "sk-1234"
-STORE_MODEL_IN_DB = "True"
+```yaml
+model_list:
+  - model_name: gpt-4o
+    litellm_params:
+      model: openai/gpt-4o
+
+general_settings:
+  master_key: sk-1234
+  database_url: postgresql://<user>:<password>@<host>:<port>/<dbname>
+  store_model_in_db: true
 ```

+Start the proxy on port 4000:
+
 ```bash
-cd litellm/litellm/proxy
-python3 proxy_cli.py --config /path/to/config.yaml --port 4000
+poetry run litellm --config config.yaml --port 4000
 ```

-**2.2 Start the UI**
+The UI comes pre-built in the repo. Access it at `http://localhost:4000/ui`

-Set the mode as development (this will assume the proxy is running on localhost:4000)
-```bash
-npm install # install dependencies
-```
+## 3. UI Development
+
+There are two options for UI development:
+
+### Option A: Development Mode (Hot Reload)
+
+This runs the UI on port 3000 with hot reload. The proxy runs on port 4000.

 ```bash
-cd litellm/ui/litellm-dashboard
-
+cd ui/litellm-dashboard
+npm install
 npm run dev
-
-# starts on http://0.0.0.0:3000
 ```

-## 3. Go to local UI 
+**Login flow:**
+1. Go to `http://localhost:3000`
+2. You'll be redirected to `http://localhost:4000/ui` for login
+3. After logging in, manually navigate back to `http://localhost:3000/`
+4. You're now authenticated and can develop with hot reload
+
+:::note
+If you experience redirect loops or authentication issues, clear your browser cookies for localhost or use Build Mode instead.
+:::
+
+### Option B: Build Mode
+
+This builds the UI and copies it to the proxy. Changes require rebuilding.
+
+1. Make your code changes in `ui/litellm-dashboard/src/`
+
+2. Build the UI
+```bash
+cd ui/litellm-dashboard
+npm install
+npm run build
+```
+
+After building, copy the output to the proxy:

 ```bash
-http://0.0.0.0:3000
-```
+cp -r out/* ../../litellm/proxy/_experimental/out/
+```
+
+Then restart the proxy and access the UI at `http://localhost:4000/ui`
+
+## 4. Submitting a PR
+
+1. Create a new branch for your changes:
+```bash
+git checkout -b feat/your-feature-name
+```
+
+2. Stage and commit your changes:
+```bash
+git add .
+git commit -m "feat: description of your changes"
+```
+
+3. Push to your fork:
+```bash
+git push origin feat/your-feature-name
+```
+
+4. Create a Pull Request on GitHub following the [PR template](https://github.com/BerriAI/litellm/blob/main/.github/pull_request_template.md)
--- a/docs/my-website/docs/data_retention.md
+++ b/docs/my-website/docs/data_retention.md
@ -10,7 +10,7 @@ This policy outlines the requirements and controls/procedures LiteLLM Cloud has
 For Customers
 1. Active Accounts

- Customer data is retained for as long as the customer’s account is in active status. This includes data such as prompts, generated content, logs, and usage metrics.
+- Customer data is retained for as long as the customer’s account is in active status. This includes data such as prompts, generated content, logs, and usage metrics. By default, we do not store the message / response content of your API requests or responses. Cloud users need to explicitly opt in to store the message / response content of your API requests or responses.

 2. Voluntary Account Closure

--- a/docs/my-website/docs/image_generation.md
+++ b/docs/my-website/docs/image_generation.md
@ -15,7 +15,7 @@ import TabItem from '@theme/TabItem';
 | Fallbacks | ✅ | Works between supported models |
 | Loadbalancing | ✅ | Works between supported models |
 | Guardrails | ✅ | Applies to input prompts (non-streaming only) |
-| Supported Providers | OpenAI, Azure, Google AI Studio, Vertex AI, AWS Bedrock, Recraft, Xinference, Nscale | |
+| Supported Providers | OpenAI, Azure, Google AI Studio, Vertex AI, AWS Bedrock, Recraft, OpenRouter, Xinference, Nscale | |

 ## Quick Start

@ -238,6 +238,27 @@ print(response)

 See Recraft usage with LiteLLM [here](./providers/recraft.md#image-generation)

+## OpenRouter Image Generation Models
+
+Use this for image generation models available through OpenRouter (e.g., Google Gemini image generation models)
+
+#### Usage
+
+```python showLineNumbers
+from litellm import image_generation
+import os
+
+os.environ['OPENROUTER_API_KEY'] = "your-api-key"
+
+response = image_generation(
+    model="openrouter/google/gemini-2.5-flash-image",
+    prompt="A beautiful sunset over a calm ocean",
+    size="1024x1024",
+    quality="high",
+)
+print(response)
+```
+
 ## OpenAI Compatible Image Generation Models
 Use this for calling `/image_generation` endpoints on OpenAI Compatible Servers, example https://github.com/xorbitsai/inference

@ -301,5 +322,6 @@ print(f"response: {response}")
 | Vertex AI | [Vertex AI Image Generation →](./providers/vertex_image) |
 | AWS Bedrock | [Bedrock Image Generation →](./providers/bedrock) |
 | Recraft | [Recraft Image Generation →](./providers/recraft#image-generation) |
+| OpenRouter | [OpenRouter Image Generation →](./providers/openrouter#image-generation) |
 | Xinference | [Xinference Image Generation →](./providers/xinference#image-generation) |
 | Nscale | [Nscale Image Generation →](./providers/nscale#image-generation) | 
--- a/docs/my-website/docs/mcp.md
+++ b/docs/my-website/docs/mcp.md
@ -21,6 +21,11 @@ LiteLLM Proxy provides an MCP Gateway that allows you to use a fixed endpoint fo
 | Supported MCP Transports | • Streamable HTTP<br/>• SSE<br/>• Standard Input/Output (stdio) |
 | LiteLLM Permission Management | • By Key<br/>• By Team<br/>• By Organization |

+:::caution MCP protocol update
+Starting in LiteLLM v1.80.18, the LiteLLM MCP protocol version is `2025-11-25`.<br/> 
+LiteLLM namespaces multiple MCP servers by prefixing each tool name with its MCP server name, so newly created servers now must use names that comply with SEP-986—noncompliant names cannot be added anymore. Existing servers that still violate SEP-986 only emit warnings today, but future MCP-side rollouts may block those names entirely, so we recommend updating any legacy server names proactively before MCP enforcement makes them unusable.
+:::
+
 ## Adding your MCP

 ### Prerequisites
@ -60,6 +65,8 @@ model_list:

 If `supported_db_objects` is not set, all object types are loaded from the database (default behavior).

+For diagnosing connectivity problems after setup, see the [MCP Troubleshooting Guide](./mcp_troubleshoot.md).
+
 <Tabs>
 <TabItem value="ui" label="LiteLLM UI">

@ -326,6 +333,7 @@ litellm_settings:
 </TabItem>
 </Tabs>

+
 ## Converting OpenAPI Specs to MCP Servers

 LiteLLM can automatically convert OpenAPI specifications into MCP servers, allowing you to expose any REST API as MCP tools. This is useful when you have existing APIs with OpenAPI/Swagger documentation and want to make them available as MCP tools.
@ -502,7 +510,7 @@ Your OpenAPI specification should follow standard OpenAPI/Swagger conventions:

 LiteLLM v 1.77.6 added support for OAuth 2.0 Client Credentials for MCP servers.

-This configuration is currently available on the config.yaml, with UI support coming soon.
+You can configure this either in `config.yaml` or directly from the LiteLLM UI (MCP Servers → Authentication → OAuth).

 ```yaml
 mcp_servers:
@ -1473,3 +1481,17 @@ async with stdio_client(server_params) as (read, write):

 </TabItem>
 </Tabs>
+
+## FAQ
+
+**Q: How do I use OAuth2 client_credentials (machine-to-machine) with MCP servers behind LiteLLM?**
+
+At the moment LiteLLM only forwards whatever `Authorization` header/value you configure for the MCP server; it does not issue OAuth2 tokens by itself. If your MCP requires the Client Credentials grant, obtain the access token directly from the authorization server and set that bearer token as the MCP server’s Authorization header value. LiteLLM does not yet fetch or refresh those machine-to-machine tokens on your behalf, but we plan to add first-class client_credentials support in a future release so the proxy can manage those tokens automatically.
+
+**Q: When I fetch an OAuth token from the LiteLLM UI, where is it stored?**
+
+The UI keeps only transient state in `sessionStorage` so the OAuth redirect flow can finish; the token is not persisted in the server or database.
+
+**Q: I'm seeing MCP connection errors—what should I check?**
+
+Walk through the [MCP Troubleshooting Guide](./mcp_troubleshoot.md) for step-by-step isolation (Client → LiteLLM vs. LiteLLM → MCP), log examples, and verification methods like MCP Inspector and `curl`.
--- a/docs/my-website/docs/mcp_troubleshoot.md
+++ b/docs/my-website/docs/mcp_troubleshoot.md
@ -0,0 +1,99 @@
+import Image from '@theme/IdealImage';
+
+# MCP Troubleshooting Guide
+
+When LiteLLM acts as an MCP proxy, traffic normally flows `Client → LiteLLM Proxy → MCP Server`, while OAuth-enabled setups add an authorization server for metadata discovery.
+
+For provisioning steps, transport options, and configuration fields, refer to [mcp.md](./mcp.md).
+
+## Locate the Error Source
+
+Pin down where the failure occurs before adjusting settings so you do not mix symptoms from separate hops.
+
+### LiteLLM UI / Playground Errors (LiteLLM → MCP)
+Failures shown on the MCP creation form or within the MCP Tool Testing Playground mean the LiteLLM proxy cannot reach the MCP server. Typical causes are misconfiguration (transport, headers, credentials), MCP/server outages, network/firewall blocks, or inaccessible OAuth metadata.
+
+<Image 
+  img={require('../img/mcp_tool_testing_playground.png')}
+  style={{width: '80%', display: 'block', margin: '0'}}
+/>
+
+<br/>
+
+**Actions**
+- Capture LiteLLM proxy logs alongside MCP-server logs (see [Error Log Example](./mcp_troubleshoot#error-log-example-failed-mcp-call)) to inspect the request/response pair and stack traces.
+- From the LiteLLM server, run Method 2 ([`curl` smoke test](./mcp_troubleshoot#curl-smoke-test)) against the MCP endpoint to confirm basic connectivity.
+
+### Client Traffic Issues (Client → LiteLLM)
+If only real client requests fail, determine whether LiteLLM ever reaches the MCP hop.
+
+#### MCP Protocol Sessions
+Clients such as IDEs or agent runtimes speak the MCP protocol directly with LiteLLM.
+
+**Actions**
+- Inspect LiteLLM access logs (see [Access Log Example](./mcp_troubleshoot#access-log-example-successful-mcp-call)) to verify the client request reached the proxy and which MCP server it targeted.
+- Review LiteLLM error logs (see [Error Log Example](./mcp_troubleshoot#error-log-example-failed-mcp-call)) for TLS, authentication, or routing errors that block the request before the MCP call starts.
+- Use the [MCP Inspector](./mcp_troubleshoot#mcp-inspector) to confirm the MCP server is reachable outside of the failing client.
+
+#### Responses/Completions with Embedded MCP Calls
+During `/responses` or `/chat/completions`, LiteLLM may trigger MCP tool calls mid-request. An error could occur before the MCP call begins or after the MCP responds.
+
+**Actions**
+- Check LiteLLM request logs (see [Access Log Example](./mcp_troubleshoot#access-log-example-successful-mcp-call)) to see whether an MCP attempt was recorded; if not, the problem lies in `Client → LiteLLM`.
+- Validate MCP connectivity with the [MCP Inspector](./mcp_troubleshoot#mcp-inspector) to ensure the server responds.
+- Reproduce the same MCP call via the LiteLLM Playground to confirm LiteLLM can complete the MCP hop independently.
+
+<Image 
+  img={require('../img/mcp_playground.png')}
+  style={{width: '80%', display: 'block', margin: '0'}}
+/>
+
+### OAuth Metadata Discovery
+LiteLLM performs metadata discovery per the MCP spec ([section 2.3](https://modelcontextprotocol.info/specification/draft/basic/authorization/#23-server-metadata-discovery)). When OAuth is enabled, confirm the authorization server exposes the metadata URL and that LiteLLM can fetch it.
+
+**Actions**
+- Use `curl <metadata_url>` (or similar) from the LiteLLM host to ensure the discovery document is reachable and contains the expected authorization/token endpoints.
+- Record the exact metadata URL, requested scopes, and any static client credentials so support can replay the discovery step if needed.
+
+## Verify Connectivity
+
+Run lightweight validations before impacting production traffic.
+
+### MCP Inspector
+Use the MCP Inspector when you need to test both `Client → LiteLLM` and `Client → MCP` communications in one place; it makes isolating the failing hop straightforward.
+
+1. Execute `npx @modelcontextprotocol/inspector` on your workstation.
+2. Configure and connect:
+   - **Transport Type:** choose the transport the client uses (Streamable HTTP for LiteLLM).
+   - **URL:** the endpoint under test (LiteLLM MCP URL for `Client → LiteLLM`, or the MCP server URL for `Client → MCP`).
+   - **Custom Headers:** e.g., `Authorization: Bearer <LiteLLM API Key>`.
+3. Open the **Tools** tab and click **List Tools** to verify the MCP alias responds.
+
+### `curl` Smoke Test
+`curl` is ideal on servers where installing the Inspector is impractical. It replicates the MCP tool call LiteLLM would make—swap in the domain of the system under test (LiteLLM or the MCP server).
+
+```bash
+curl -X POST https://your-target-domain.example.com/mcp \
+  -H "Content-Type: application/json" \
+  -H "Accept: application/json, text/event-stream" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
+```
+
+Add `-H "Authorization: Bearer <LiteLLM API Key>"` when the target is a LiteLLM endpoint that requires authentication. Adjust the headers, or payload to target other MCP methods. Matching failures between `curl` and LiteLLM confirm that the MCP server or network/OAuth layer is the culprit.
+
+## Review Logs
+
+Well-scoped logs make it clear whether LiteLLM reached the MCP server and what happened next.
+
+### Access Log Example (successful MCP call)
+```text
+INFO:     127.0.0.1:57230 - "POST /everything/mcp HTTP/1.1" 200 OK
+```
+
+### Error Log Example (failed MCP call)
+```text
+07:22:00 - LiteLLM:ERROR: client.py:224 - MCP client list_tools failed - Error Type: ExceptionGroup, Error: unhandled errors in a TaskGroup (1 sub-exception), Server: http://localhost:3001/mcp, Transport: MCPTransport.http
+  httpcore.ConnectError: All connection attempts failed
+ERROR:LiteLLM:MCP client list_tools failed - Error Type: ExceptionGroup, Error: unhandled errors in a TaskGroup (1 sub-exception)...
+  httpx.ConnectError: All connection attempts failed
+```
--- a/docs/my-website/docs/observability/logfire_integration.md
+++ b/docs/my-website/docs/observability/logfire_integration.md
@ -40,6 +40,10 @@ import os
 # from https://logfire.pydantic.dev/
 os.environ["LOGFIRE_TOKEN"] = ""

+# Optionally customize the base url
+# from https://logfire.pydantic.dev/
+os.environ["LOGFIRE_BASE_URL"] = ""
+
 # LLM API Keys
 os.environ['OPENAI_API_KEY']=""

--- a/docs/my-website/docs/pass_through/vertex_ai.md
+++ b/docs/my-website/docs/pass_through/vertex_ai.md
@ -45,7 +45,7 @@ model_list:
    litellm_params:
      model: vertex_ai/gemini-1.0-pro
      vertex_project: adroit-crow-413218
-      vertex_region: us-central1
+      vertex_location: us-central1
      vertex_credentials: /path/to/credentials.json
      use_in_pass_through: true # 👈 KEY CHANGE
 ```
@ -57,9 +57,9 @@ model_list:
 <TabItem value="yaml" label="Set in config.yaml">

 ```yaml
-default_vertex_config: 
+default_vertex_config:
  vertex_project: adroit-crow-413218
-  vertex_region: us-central1
+  vertex_location: us-central1
  vertex_credentials: /path/to/credentials.json
 ```
 </TabItem>
--- a/docs/my-website/docs/providers/azure_ai/azure_model_router.md
+++ b/docs/my-website/docs/providers/azure_ai/azure_model_router.md
@ -0,0 +1,232 @@
+# Azure Model Router
+
+Azure Model Router is a feature in Azure AI Foundry that automatically routes your requests to the best available model based on your requirements. This allows you to use a single endpoint that intelligently selects the optimal model for each request.
+
+## Key Features
+
+- **Automatic Model Selection**: Azure Model Router dynamically selects the best model for your request
+- **Cost Tracking**: LiteLLM automatically tracks costs based on the actual model used (e.g., `gpt-4.1-nano`), not the router endpoint
+- **Streaming Support**: Full support for streaming responses with accurate cost calculation
+
+## LiteLLM Python SDK
+
+### Basic Usage
+
+```python
+import litellm
+import os
+
+response = litellm.completion(
+    model="azure_ai/azure-model-router",
+    messages=[{"role": "user", "content": "Hello!"}],
+    api_base="https://your-endpoint.cognitiveservices.azure.com/openai/v1/",
+    api_key=os.getenv("AZURE_MODEL_ROUTER_API_KEY"),
+)
+
+print(response)
+```
+
+### Streaming with Usage Tracking
+
+```python
+import litellm
+import os
+
+response = await litellm.acompletion(
+    model="azure_ai/azure-model-router",
+    messages=[{"role": "user", "content": "hi"}],
+    api_base="https://your-endpoint.cognitiveservices.azure.com/openai/v1/",
+    api_key=os.getenv("AZURE_MODEL_ROUTER_API_KEY"),
+    stream=True,
+    stream_options={"include_usage": True},
+)
+
+async for chunk in response:
+    print(chunk)
+```
+
+## LiteLLM Proxy (AI Gateway)
+
+### config.yaml
+
+```yaml
+model_list:
+  - model_name: azure-model-router
+    litellm_params:
+      model: azure_ai/azure-model-router
+      api_base: https://your-endpoint.cognitiveservices.azure.com/openai/v1/
+      api_key: os.environ/AZURE_MODEL_ROUTER_API_KEY
+```
+
+### Start Proxy
+
+```bash
+litellm --config config.yaml
+```
+
+### Test Request
+
+```bash
+curl -X POST http://localhost:4000/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer sk-1234" \
+  -d '{
+    "model": "azure-model-router",
+    "messages": [{"role": "user", "content": "Hello!"}]
+  }'
+```
+
+## Add Azure Model Router via LiteLLM UI
+
+This walkthrough shows how to add an Azure Model Router endpoint to LiteLLM using the Admin Dashboard.
+
+### Select Provider
+
+Navigate to the Models page and select "Azure AI Foundry (Studio)" as the provider.
+
+#### Navigate to Models Page
+
+![Navigate to Models](./img/azure_model_router_01.jpeg)
+
+#### Click Provider Dropdown
+
+![Click Provider](./img/azure_model_router_02.jpeg)
+
+#### Choose Azure AI Foundry
+
+![Select Azure AI Foundry](./img/azure_model_router_03.jpeg)
+
+### Configure Model Name
+
+Set up the model name by entering `azure_ai/` followed by your model router deployment name from Azure.
+
+#### Click Model Name Field
+
+![Click Model Field](./img/azure_model_router_04.jpeg)
+
+#### Select Custom Model Name
+
+![Select Custom Model](./img/azure_model_router_05.jpeg)
+
+#### Enter LiteLLM Model Name
+
+![LiteLLM Model Name](./img/azure_model_router_06.jpeg)
+
+#### Click Custom Model Name Field
+
+![Enter Custom Name Field](./img/azure_model_router_07.jpeg)
+
+#### Type Model Prefix
+
+Type `azure_ai/` as the prefix.
+
+![Type azure_ai prefix](./img/azure_model_router_08.jpeg)
+
+#### Copy Model Name from Azure Portal
+
+Switch to Azure AI Foundry and copy your model router deployment name.
+
+![Azure Portal Model Name](./img/azure_model_router_09.jpeg)
+
+![Copy Model Name](./img/azure_model_router_10.jpeg)
+
+#### Paste Model Name
+
+Paste to get `azure_ai/azure-model-router`.
+
+![Paste Model Name](./img/azure_model_router_11.jpeg)
+
+### Configure API Base and Key
+
+Copy the endpoint URL and API key from Azure portal.
+
+#### Copy API Base URL from Azure
+
+![Copy API Base](./img/azure_model_router_12.jpeg)
+
+#### Enter API Base in LiteLLM
+
+![Click API Base Field](./img/azure_model_router_13.jpeg)
+
+![Paste API Base](./img/azure_model_router_14.jpeg)
+
+#### Copy API Key from Azure
+
+![Copy API Key](./img/azure_model_router_15.jpeg)
+
+#### Enter API Key in LiteLLM
+
+![Enter API Key](./img/azure_model_router_16.jpeg)
+
+### Test and Add Model
+
+Verify your configuration works and save the model.
+
+#### Test Connection
+
+![Test Connection](./img/azure_model_router_17.jpeg)
+
+#### Close Test Dialog
+
+![Close Dialog](./img/azure_model_router_18.jpeg)
+
+#### Add Model
+
+![Add Model](./img/azure_model_router_19.jpeg)
+
+### Verify in Playground
+
+Test your model and verify cost tracking is working.
+
+#### Open Playground
+
+![Go to Playground](./img/azure_model_router_20.jpeg)
+
+#### Select Model
+
+![Select Model](./img/azure_model_router_21.jpeg)
+
+#### Send Test Message
+
+![Send Message](./img/azure_model_router_22.jpeg)
+
+#### View Logs
+
+![View Logs](./img/azure_model_router_23.jpeg)
+
+#### Verify Cost Tracking
+
+Cost is tracked based on the actual model used (e.g., `gpt-4.1-nano`).
+
+![Verify Cost](./img/azure_model_router_24.jpeg)
+
+## Cost Tracking
+
+LiteLLM automatically handles cost tracking for Azure Model Router by:
+
+1. **Detecting the actual model**: When Azure Model Router routes your request to a specific model (e.g., `gpt-4.1-nano-2025-04-14`), LiteLLM extracts this from the response
+2. **Calculating accurate costs**: Costs are calculated based on the actual model used, not the router endpoint name
+3. **Streaming support**: Cost tracking works correctly for both streaming and non-streaming requests
+
+### Example Response with Cost
+
+```python
+import litellm
+
+response = litellm.completion(
+    model="azure_ai/azure-model-router",
+    messages=[{"role": "user", "content": "Hello!"}],
+    api_base="https://your-endpoint.cognitiveservices.azure.com/openai/v1/",
+    api_key="your-api-key",
+)
+
+# The response will show the actual model used
+print(f"Model used: {response.model}")  # e.g., "gpt-4.1-nano-2025-04-14"
+
+# Get cost
+from litellm import completion_cost
+cost = completion_cost(completion_response=response)
+print(f"Cost: ${cost}")
+```
+
+
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_01.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_01.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_02.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_02.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_03.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_03.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_04.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_04.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_05.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_05.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_06.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_06.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_07.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_07.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_08.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_08.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_09.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_09.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_10.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_10.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_11.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_11.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_12.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_12.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_13.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_13.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_14.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_14.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_15.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_15.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_16.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_16.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_17.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_17.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_18.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_18.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_19.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_19.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_20.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_20.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_21.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_21.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_22.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_22.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_23.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_23.jpeg
--- a/docs/my-website/docs/providers/azure_ai/img/azure_model_router_24.jpeg
+++ b/docs/my-website/docs/providers/azure_ai/img/azure_model_router_24.jpeg
--- a/docs/my-website/docs/providers/chatgpt.md
+++ b/docs/my-website/docs/providers/chatgpt.md
@ -0,0 +1,84 @@
+# ChatGPT Subscription
+
+Use ChatGPT Pro/Max subscription models through LiteLLM with OAuth device flow authentication.
+
+| Property | Details |
+|-------|-------|
+| Description | ChatGPT subscription access (Codex + GPT-5.2 family) via ChatGPT backend API |
+| Provider Route on LiteLLM | `chatgpt/` |
+| Supported Endpoints | `/responses`, `/chat/completions` (bridged to Responses for supported models) |
+| API Reference | https://chatgpt.com |
+
+ChatGPT subscription access is native to the Responses API. Chat Completions requests are bridged to Responses for supported models (for example `chatgpt/gpt-5.2`).
+
+Notes:
+- The ChatGPT subscription backend rejects token limit fields (`max_tokens`, `max_output_tokens`, `max_completion_tokens`) and `metadata`. LiteLLM strips these fields for this provider.
+- `/v1/chat/completions` honors `stream`. When `stream` is false (default), LiteLLM aggregates the Responses stream into a single JSON response.
+
+## Authentication
+
+ChatGPT subscription access uses an OAuth device code flow:
+
+1. LiteLLM prints a device code and verification URL
+2. Open the URL, sign in, and enter the code
+3. Tokens are stored locally for reuse
+
+## Usage - LiteLLM Python SDK
+
+### Responses (recommended for Codex models)
+
+```python showLineNumbers title="ChatGPT Responses"
+import litellm
+
+response = litellm.responses(
+    model="chatgpt/gpt-5.2-codex",
+    input="Write a Python hello world"
+)
+
+print(response)
+```
+
+### Chat Completions (bridged to Responses)
+
+```python showLineNumbers title="ChatGPT Chat Completions"
+import litellm
+
+response = litellm.completion(
+    model="chatgpt/gpt-5.2",
+    messages=[{"role": "user", "content": "Write a Python hello world"}]
+)
+
+print(response)
+```
+
+## Usage - LiteLLM Proxy
+
+```yaml showLineNumbers title="config.yaml"
+model_list:
+  - model_name: chatgpt/gpt-5.2
+    model_info:
+      mode: responses
+    litellm_params:
+      model: chatgpt/gpt-5.2
+  - model_name: chatgpt/gpt-5.2-codex
+    model_info:
+      mode: responses
+    litellm_params:
+      model: chatgpt/gpt-5.2-codex
+```
+
+```bash showLineNumbers title="Start LiteLLM Proxy"
+litellm --config config.yaml
+```
+
+## Configuration
+
+### Environment Variables
+
+- `CHATGPT_TOKEN_DIR`: Custom token storage directory
+- `CHATGPT_AUTH_FILE`: Auth file name (default: `auth.json`)
+- `CHATGPT_API_BASE`: Override API base (default: `https://chatgpt.com/backend-api/codex`)
+- `OPENAI_CHATGPT_API_BASE`: Alias for `CHATGPT_API_BASE`
+- `CHATGPT_ORIGINATOR`: Override the `originator` header value
+- `CHATGPT_USER_AGENT`: Override the `User-Agent` header value
+- `CHATGPT_USER_AGENT_SUFFIX`: Optional suffix appended to the `User-Agent` header
--- a/docs/my-website/docs/providers/openai/text_to_speech.md
+++ b/docs/my-website/docs/providers/openai/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",
--- a/docs/my-website/docs/providers/openrouter.md
+++ b/docs/my-website/docs/providers/openrouter.md
@ -93,3 +93,120 @@ response = embedding(
 )
 print(response)
 ```
+
+## Image Generation
+
+OpenRouter supports image generation through select models like Google Gemini image generation models. LiteLLM transforms standard image generation requests to OpenRouter's chat completion format.
+
+### Supported Parameters
+
+- `size`: Maps to OpenRouter's `aspect_ratio` format
+  - `1024x1024` → `1:1` (square)
+  - `1536x1024` → `3:2` (landscape)
+  - `1024x1536` → `2:3` (portrait)
+  - `1792x1024` → `16:9` (wide landscape)
+  - `1024x1792` → `9:16` (tall portrait)
+
+- `quality`: Maps to OpenRouter's `image_size` format (Gemini models)
+  - `low` or `standard` → `1K`
+  - `medium` → `2K`
+  - `high` or `hd` → `4K`
+
+- `n`: Number of images to generate
+
+### Usage
+
+```python
+from litellm import image_generation
+import os
+
+os.environ["OPENROUTER_API_KEY"] = "your-api-key"
+
+# Basic image generation
+response = image_generation(
+    model="openrouter/google/gemini-2.5-flash-image",
+    prompt="A beautiful sunset over a calm ocean",
+)
+print(response)
+```
+
+### Advanced Usage with Parameters
+
+```python
+from litellm import image_generation
+import os
+
+os.environ["OPENROUTER_API_KEY"] = "your-api-key"
+
+# Generate high-quality landscape image
+response = image_generation(
+    model="openrouter/google/gemini-2.5-flash-image",
+    prompt="A serene mountain landscape with a lake",
+    size="1536x1024",  # Landscape format
+    quality="high",     # High quality (4K)
+)
+
+# Access the generated image
+image_data = response.data[0]
+if image_data.b64_json:
+    # Base64 encoded image
+    print(f"Generated base64 image: {image_data.b64_json[:50]}...")
+elif image_data.url:
+    # Image URL
+    print(f"Generated image URL: {image_data.url}")
+```
+
+### Using OpenRouter-Specific Parameters
+
+You can also pass OpenRouter-specific parameters directly using `image_config`:
+
+```python
+from litellm import image_generation
+import os
+
+os.environ["OPENROUTER_API_KEY"] = "your-api-key"
+
+response = image_generation(
+    model="openrouter/google/gemini-2.5-flash-image",
+    prompt="A futuristic cityscape at night",
+    image_config={
+        "aspect_ratio": "16:9",  # OpenRouter native format
+        "image_size": "4K"       # OpenRouter native format
+    }
+)
+print(response)
+```
+
+### Response Format
+
+The response follows the standard LiteLLM ImageResponse format:
+
+```python
+{
+    "created": 1703658209,
+    "data": [{
+        "b64_json": "iVBORw0KGgoAAAANSUhEUgAA...",  # Base64 encoded image
+        "url": None,
+        "revised_prompt": None
+    }],
+    "usage": {
+        "input_tokens": 10,
+        "output_tokens": 1290,
+        "total_tokens": 1300
+    }
+}
+```
+
+### Cost Tracking
+
+OpenRouter provides cost information in the response, which LiteLLM automatically tracks:
+
+```python
+response = image_generation(
+    model="openrouter/google/gemini-2.5-flash-image",
+    prompt="A cute baby sea otter",
+)
+
+# Cost is available in the response metadata
+print(f"Request cost: ${response._hidden_params['additional_headers']['llm_provider-x-litellm-response-cost']}")
+```
--- a/docs/my-website/docs/providers/sap.md
+++ b/docs/my-website/docs/providers/sap.md
@ -12,100 +12,340 @@ LiteLLM supports SAP Generative AI Hub's Orchestration Service.
 | Supported Endpoints | `/chat/completions`, `/embeddings`                                                                                                                                  |
 | API Reference | [SAP AI Core Documentation](https://help.sap.com/docs/sap-ai-core)                                                                                     |

+## Prerequisites
+
+Before you begin, ensure you have:
+
+1. **SAP BTP Account** with access to SAP AI Core
+2. **AI Core Service Instance** provisioned in your subaccount
+3. **Service Key** created for your AI Core instance (this contains your credentials)
+4. **Resource Group** with deployed AI models (check with your SAP administrator)
+
+:::tip Where to Find Your Credentials
+Your credentials come from the **Service Key** you create in SAP BTP Cockpit:
+
+1. Navigate to your **Subaccount** → **Instances and Subscriptions**
+2. Find your **AI Core** instance and click on it
+3. Go to **Service Keys** and create one (or use existing)
+4. The JSON contains all values needed below
+
+The service key JSON looks like this:
+
+```json
+{
+  "clientid": "sb-abc123...",
+  "clientsecret": "xyz789...",
+  "url": "https://myinstance.authentication.eu10.hana.ondemand.com",
+  "serviceurls": {
+    "AI_API_URL": "https://api.ai.prod.eu-central-1.aws.ml.hana.ondemand.com"
+  }
+}
+```
+
+:::info Resource Group
+The resource group is typically configured separately in your AI Core deployment, not in the service key itself. You can set it via the `AICORE_RESOURCE_GROUP` environment variable (defaults to "default").
+:::
+
+## Quick Start
+
+### Step 1: Install LiteLLM
+
+```bash
+pip install litellm
+```
+
+### Step 2: Set Your Credentials
+
+Choose **one** of these authentication methods:
+
+<Tabs>
+<TabItem value="service-key" label="Service Key JSON (Recommended)">
+
+The simplest approach - paste your entire service key as a single environment variable. The service key must be wrapped in a `credentials` object:
+
+```bash
+export AICORE_SERVICE_KEY='{
+  "credentials": {
+    "clientid": "your-client-id",
+    "clientsecret": "your-client-secret",
+    "url": "https://<your-instance>.authentication.sap.hana.ondemand.com",
+    "serviceurls": {
+      "AI_API_URL": "https://api.ai.<your-region>.aws.ml.hana.ondemand.com"
+    }
+  }
+}'
+export AICORE_RESOURCE_GROUP="default"
+```
+
+</TabItem>
+<TabItem value="individual" label="Individual Variables">
+
+Alternatively, instead of using the service key above, you could set each credential separately:
+
+```bash
+export AICORE_AUTH_URL="https://<your-instance>.authentication.sap.hana.ondemand.com/oauth/token"
+export AICORE_CLIENT_ID="your-client-id"
+export AICORE_CLIENT_SECRET="your-client-secret"
+export AICORE_RESOURCE_GROUP="default"
+export AICORE_BASE_URL="https://api.ai.<your-region>.aws.ml.hana.ondemand.com/v2"
+```
+
+</TabItem>
+</Tabs>
+
+### Step 3: Make Your First Request
+
+```python title="test_sap.py"
+from litellm import completion
+
+response = completion(
+    model="sap/gpt-4o",
+    messages=[{"role": "user", "content": "Hello from LiteLLM!"}]
+)
+print(response.choices[0].message.content)
+```
+
+Run it:
+
+```bash
+python test_sap.py
+```
+
+**Expected output:**
+
+```text
+Hello! How can I assist you today?
+```
+
+### Step 4: Verify Your Setup (Optional)
+
+Test that everything is working with this diagnostic script:
+
+```python title="verify_sap_setup.py"
+import os
+import litellm
+
+# Enable debug logging to see what's happening
+import os
+os.environ["LITELLM_LOG"] = "DEBUG"
+
+# Either use AICORE_SERVICE_KEY (contains all credentials including resourcegroup)
+# OR use individual variables (all required together)
+individual_vars = ["AICORE_AUTH_URL", "AICORE_CLIENT_ID", "AICORE_CLIENT_SECRET", "AICORE_BASE_URL", "AICORE_RESOURCE_GROUP"]
+
+print("=== SAP Gen AI Hub Setup Verification ===\n")
+
+# Check for service key method
+if os.environ.get("AICORE_SERVICE_KEY"):
+    print("✓ Using AICORE_SERVICE_KEY authentication (includes resource group)")
+else:
+    # Check individual variables
+    missing = [v for v in individual_vars if not os.environ.get(v)]
+    if missing:
+        print(f"✗ Missing environment variables: {missing}")
+    else:
+        print("✓ Using individual variable authentication")
+        print(f"✓ Resource group: {os.environ.get('AICORE_RESOURCE_GROUP')}")
+
+# Test API connection
+print("\n=== Testing API Connection ===\n")
+try:
+    response = litellm.completion(
+        model="sap/gpt-4o",
+        messages=[{"role": "user", "content": "Say 'Connection successful!' and nothing else."}],
+        max_tokens=20
+    )
+    print(f"✓ API Response: {response.choices[0].message.content}")
+    print("\n🎉 Setup complete! You're ready to use SAP Gen AI Hub with LiteLLM.")
+except Exception as e:
+    print(f"✗ API Error: {e}")
+    print("\nTroubleshooting tips:")
+    print("  1. Verify your service key credentials are correct")
+    print("  2. Check that 'gpt-4o' is deployed in your resource group")
+    print("  3. Ensure your SAP AI Core instance is running")
+```
+
+Run the verification:
+
+```bash
+python verify_sap_setup.py
+```
+
+**Expected output on success:**
+
+```text
+=== SAP Gen AI Hub Setup Verification ===
+
+✓ Using AICORE_SERVICE_KEY authentication
+✓ Resource group: default
+
+=== Testing API Connection ===
+
+✓ API Response: Connection successful!
+
+🎉 Setup complete! You're ready to use SAP Gen AI Hub with LiteLLM.
+```
+
 ## Authentication

-SAP Generative AI Hub uses service key authentication. You can provide credentials via:
+SAP Generative AI Hub uses OAuth2 service keys for authentication. See [Quick Start](#quick-start) for setup instructions.

-1. **Environment variable** - Set `AICORE_SERVICE_KEY` with your service key JSON
-2. **Direct parameter** - Pass `api_key` with the service key JSON string
+### Environment Variables Reference

-```python showLineNumbers title="Environment Variable"
-import os
-os.environ["AICORE_SERVICE_KEY"] = '{"clientid": "...", "clientsecret": "...", ...}'
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `AICORE_SERVICE_KEY` | Yes* | Complete service key JSON (recommended method) |
+| `AICORE_RESOURCE_GROUP` | Yes | Your AI Core resource group name |
+| `AICORE_AUTH_URL` | Yes* | OAuth token URL (alternative to service key) |
+| `AICORE_CLIENT_ID` | Yes* | OAuth client ID (alternative to service key) |
+| `AICORE_CLIENT_SECRET` | Yes* | OAuth client secret (alternative to service key) |
+| `AICORE_BASE_URL` | Yes* | AI Core API base URL (alternative to service key) |
+
+*Choose either `AICORE_SERVICE_KEY` OR the individual variables (`AICORE_AUTH_URL`, `AICORE_CLIENT_ID`, `AICORE_CLIENT_SECRET`, `AICORE_BASE_URL`).
+
+## Model Naming Conventions
+
+Understanding model naming is crucial for using SAP Gen AI Hub correctly. The naming pattern differs depending on whether you're using the SDK directly or through the proxy.
+
+### Direct SDK Usage
+
+When calling LiteLLM's SDK directly, you **must** include the `sap/` prefix in the model name:
+
+```python
+# Correct - includes sap/ prefix
+model="sap/gpt-4o"
+model="sap/anthropic--claude-4.5-sonnet"
+model="sap/gemini-2.5-pro"
+
+# Incorrect - missing prefix
+model="gpt-4o"  # ❌ Won't work
 ```
-3. **Environment variables** - Set the following list of credentials in .env file
-<pre>
-AICORE_AUTH_URL = "https://* * * .authentication.sap.hana.ondemand.com/oauth/token",
-AICORE_CLIENT_ID  = " *** ",
-AICORE_CLIENT_SECRET = " *** ",
-AICORE_RESOURCE_GROUP = " *** ",
-AICORE_BASE_URL = "https://api.ai.***.cfapps.sap.hana.ondemand.com/v2"
-</pre>
-## Usage - LiteLLM Python SDK

-```python showLineNumbers title="SAP Chat Completion"
-from litellm import completion
-import os
+### Proxy Usage

-os.environ["AICORE_SERVICE_KEY"] = '{"clientid": "...", "clientsecret": "...", ...}'
+When using the LiteLLM Proxy, you use the **friendly `model_name`** defined in your configuration. The proxy automatically handles the `sap/` prefix routing.

-response = completion(
-    model="sap/gpt-4",
-    messages=[{"role": "user", "content": "Hello from LiteLLM"}]
+```yaml
+# In config.yaml, define the mapping
+model_list:
+  - model_name: gpt-4o          # ← Use this name in client requests
+    litellm_params:
+      model: sap/gpt-4o         # ← Proxy handles the sap/ prefix
+```
+
+```python
+# Client request - no sap/ prefix needed
+client.chat.completions.create(
+    model="gpt-4o",  # ✓ Correct for proxy usage
+    messages=[...]
 )
-print(response)
 ```

-```python showLineNumbers title="SAP Chat Completion - Streaming"
+### Anthropic Models Special Syntax
+
+Anthropic models use a double-dash (`--`) prefix convention:
+
+| Provider | Model Example | LiteLLM Format |
+|----------|---------------|----------------|
+| OpenAI | GPT-4o | `sap/gpt-4o` |
+| Anthropic | Claude 4.5 Sonnet | `sap/anthropic--claude-4.5-sonnet` |
+| Google | Gemini 2.5 Pro | `sap/gemini-2.5-pro` |
+| Mistral | Mistral Large | `sap/mistral-large` |
+
+### Quick Reference Table
+
+| Usage Type | Model Format | Example |
+|------------|--------------|---------|
+| Direct SDK | `sap/<model-name>` | `sap/gpt-4o` |
+| Direct SDK (Anthropic) | `sap/anthropic--<model>` | `sap/anthropic--claude-4.5-sonnet` |
+| Proxy Client | `<friendly-name>` | `gpt-4o` or `claude-sonnet` |
+
+## Using the Python SDK
+
+The LiteLLM Python SDK automatically detects your authentication method. Simply set your environment variables and make requests.
+
+```python showLineNumbers title="Basic Completion"
 from litellm import completion
-import os
-
-os.environ["AICORE_SERVICE_KEY"] = '{"clientid": "...", "clientsecret": "...", ...}'

+# Assumes AICORE_AUTH_URL, AICORE_CLIENT_ID, etc. are set
 response = completion(
-    model="sap/gpt-4",
-    messages=[{"role": "user", "content": "Hello from LiteLLM"}],
-    stream=True
+    model="sap/anthropic--claude-4.5-sonnet",
+    messages=[{"role": "user", "content": "Explain quantum computing"}]
 )
-
-for chunk in response:
-    print(chunk.choices[0].delta.content or "", end="")
+print(response.choices[0].message.content)
 ```

-```python showLineNumbers title="SAP Embedding"
-from litellm import embedding
-import os
+Both authentication methods (individual variables or service key JSON) work automatically - no code changes required.

-os.environ["AICORE_SERVICE_KEY"] = '{"clientid": "...", "clientsecret": "...", ...}'
+## Using the Proxy Server

-result = embedding(
-    model="sap/text-embedding-3-small", 
-	input="Answer to the ultimate question of life, the universe, and everything is 42")
-print(result.data[0])
-```
+The LiteLLM Proxy provides a unified OpenAI-compatible API for your SAP models.

-## Usage - LiteLLM Proxy
+### Configuration

-Add to your LiteLLM Proxy config:
+Create a `config.yaml` file in your project directory with your model mappings and credentials:

 ```yaml showLineNumbers title="config.yaml"
 model_list:
-  - model_name: "sap/*"
+  # OpenAI models
+  - model_name: gpt-5
    litellm_params:
-      model: "sap/*"
+      model: sap/gpt-5

-general_settings: 
-  master_key: your-proxy-api-key 
+  # Anthropic models (note the double-dash)
+  - model_name: claude-sonnet
+    litellm_params:
+      model: sap/anthropic--claude-4.5-sonnet

+  - model_name: claude-opus
+    litellm_params:
+      model: sap/anthropic--claude-4.5-opus
+
+  # Embeddings
+  - model_name: text-embedding-3-small
+    litellm_params:
+      model: sap/text-embedding-3-small
+
+litellm_settings:
+  drop_params: true
+  set_verbose: false
+  request_timeout: 600
+  num_retries: 2
+  forward_client_headers_to_llm_api: ["anthropic-version"]
+
+general_settings:
+  master_key: "sk-1234" # Enter here your desired master key starting with 'sk-'.
+  
+  # UI Admin is not required but helpful including the management of keys for your team(s). If you are using a database, these parameters are required:
+  database_url: "Enter you database URL."
+  UI_USERNAME: "Your desired UI admin account name"
+  UI_PASSWORD: "Your desired and strong pwd"
+
+# Authentication
 environment_variables:
-  AICORE_SERVICE_KEY: '{"clientid": "...", "clientsecret": "...", ...}'
+  AICORE_SERVICE_KEY: '{"credentials": {"clientid": "...", "clientsecret": "...", "url": "...", "serviceurls": {"AI_API_URL": "..."}}}'
+  AICORE_RESOURCE_GROUP: "default"
 ```

-Start the proxy:
+### Starting the Proxy

 ```bash showLineNumbers title="Start Proxy"
 litellm --config config.yaml
 ```

+The proxy will start on `http://localhost:4000` by default.
+
+### Making Requests
+
 <Tabs>
 <TabItem value="curl" label="cURL">

 ```bash showLineNumbers title="Test Request"
 curl http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your-proxy-api-key" \
+  -H "Authorization: Bearer sk-1234" \
  -d '{
-    "model": "sap/gpt-4",
+    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Hello"}]
  }'
 ```
@ -118,11 +358,11 @@ from openai import OpenAI

 client = OpenAI(
    base_url="http://localhost:4000",
-    api_key="your-proxy-api-key"
+    api_key="sk-1234"
 )

 response = client.chat.completions.create(
-    model="sap/gpt-4",
+    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}]
 )
 print(response.choices[0].message.content)
@ -134,12 +374,14 @@ print(response.choices[0].message.content)
 ```python showLineNumbers title="LiteLLM SDK"
 import os
 import litellm
-os.environ["LITELLM_PROXY_API_KEY"] = "your-proxy-api-key"
-litellm.use_litellm_proxy = True  # it is important to set this parameter
+
+os.environ["LITELLM_PROXY_API_KEY"] = "sk-1234"
+litellm.use_litellm_proxy = True
+
 response = litellm.completion(
-    model="sap/gpt-4o",
-    messages=[{ "content": "Hello, how are you?","role": "user"}],
-    api_base="http://your-proxy-api-base"
+    model="claude-sonnet",
+    messages=[{"content": "Hello, how are you?", "role": "user"}],
+    api_base="http://localhost:4000"
 )

 print(response)
@ -148,15 +390,170 @@ print(response)
 </TabItem>
 </Tabs>

-## Supported Parameters
+## Features

-| Parameter | Description |
-|-----------|-------------|
-| `temperature` | Controls randomness |
-| `max_tokens` | Maximum tokens in response |
-| `top_p` | Nucleus sampling |
-| `tools` | Function calling tools |
-| `tool_choice` | Tool selection behavior |
-| `response_format` | Output format (json_object, json_schema) |
-| `stream` | Enable streaming |
+### Streaming Responses

+Stream responses in real-time for better user experience:
+
+```python showLineNumbers title="Streaming Chat Completion"
+from litellm import completion
+
+response = completion(
+    model="sap/gpt-4o",
+    messages=[{"role": "user", "content": "Count from 1 to 10"}],
+    stream=True
+)
+
+for chunk in response:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="", flush=True)
+```
+
+### Structured Output
+
+#### JSON Schema (Recommended)
+
+Use JSON Schema for structured output with strict validation:
+
+```python showLineNumbers title="JSON Schema Response"
+from litellm import completion
+
+response = completion(
+    model="sap/gpt-4o",
+    messages=[{
+        "role": "user",
+        "content": "Generate info about Tokyo"
+    }],
+    response_format={
+        "type": "json_schema",
+        "json_schema": {
+            "name": "city_info",
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "population": {"type": "number"},
+                    "country": {"type": "string"}
+                },
+                "required": ["name", "population", "country"],
+                "additionalProperties": False
+            },
+            "strict": True
+        }
+    }
+)
+
+print(response.choices[0].message.content)
+# Output: {"name":"Tokyo","population":37000000,"country":"Japan"}
+```
+
+#### JSON Object Format
+
+For flexible JSON output without schema validation:
+
+```python showLineNumbers title="JSON Object Response"
+from litellm import completion
+
+response = completion(
+    model="sap/gpt-4o",
+    messages=[{
+        "role": "user",
+        "content": "Generate a person object in JSON format with name and age"
+    }],
+    response_format={"type": "json_object"}
+)
+
+print(response.choices[0].message.content)
+```
+
+:::note SAP Platform Requirement
+When using `json_object` type, SAP's orchestration service requires the word "json" to appear in your prompt. This ensures explicit intent for JSON formatting. For schema-validated output without this requirement, use `json_schema` instead (recommended).
+:::
+
+### Multi-turn Conversations
+
+Maintain conversation context across multiple turns:
+
+```python showLineNumbers title="Multi-turn Conversation"
+from litellm import completion
+
+response = completion(
+    model="sap/gpt-4o",
+    messages=[
+        {"role": "user", "content": "My name is Alice"},
+        {"role": "assistant", "content": "Hello Alice! Nice to meet you."},
+        {"role": "user", "content": "What is my name?"}
+    ]
+)
+
+print(response.choices[0].message.content)
+# Output: Your name is Alice.
+```
+
+### Embeddings
+
+Generate vector embeddings for semantic search and retrieval:
+
+```python showLineNumbers title="Create Embeddings"
+from litellm import embedding
+
+response = embedding(
+    model="sap/text-embedding-3-small",
+    input=["Hello world", "Machine learning is fascinating"]
+)
+
+print(response.data[0]["embedding"])  # Vector representation
+```
+
+## Reference
+
+### Supported Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `model` | string | Model identifier (with `sap/` prefix for SDK) |
+| `messages` | array | Conversation messages |
+| `temperature` | float | Controls randomness (0-2) |
+| `max_tokens` | integer | Maximum tokens in response |
+| `top_p` | float | Nucleus sampling threshold |
+| `stream` | boolean | Enable streaming responses |
+| `response_format` | object | Output format (`json_object`, `json_schema`) |
+| `tools` | array | Function calling tool definitions |
+| `tool_choice` | string/object | Tool selection behavior |
+
+### Supported Models
+
+For the complete and up-to-date list of available models provided by SAP Gen AI Hub, please refer to the [SAP AI Core Generative AI Hub documentation](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/models-and-scenarios-in-generative-ai-hub).
+
+:::info Model Availability
+Model availability varies by SAP deployment region and your subscription. Contact your SAP administrator to confirm which models are available in your environment.
+:::
+
+### Troubleshooting
+
+**Authentication Errors**
+
+If you receive authentication errors:
+
+1. Verify all required environment variables are set correctly
+2. Check that your service key hasn't expired
+3. Confirm your resource group has access to the desired models
+4. Ensure the `AICORE_AUTH_URL` and `AICORE_BASE_URL` match your SAP region
+
+**Model Not Found**
+
+If a model returns "not found":
+
+1. Verify the model is available in your SAP deployment
+2. Check you're using the correct model name format (`sap/` prefix for SDK)
+3. Confirm your resource group has access to that specific model
+4. For Anthropic models, ensure you're using the `anthropic--` double-dash prefix
+
+**Rate Limiting**
+
+SAP Gen AI Hub enforces rate limits based on your subscription. If you hit limits:
+
+1. Implement exponential backoff retry logic
+2. Consider using the proxy's built-in rate limiting features
+3. Contact your SAP administrator to review quota allocations
--- a/docs/my-website/docs/providers/stability.md
+++ b/docs/my-website/docs/providers/stability.md
@ -173,6 +173,14 @@ Stability AI returns images in base64 format. The response is OpenAI-compatible:

 Stability AI supports various image editing operations including inpainting, upscaling, outpainting, background removal, and more.

+:::info Optional Parameters
+**Important:** Different Stability models have different parameter requirements:
+- Some models don't require a `prompt` (e.g., upscaling, background removal)
+- The `style-transfer` model uses `init_image` and `style_image` instead of `image`
+- The `outpaint` model requires numeric parameters (`left`, `right`, `up`, `down`)
+LiteLLM automatically handles these differences for you.
+:::
+
 ### Usage - LiteLLM Python SDK

 #### Inpainting (Edit with Mask)
@ -217,11 +225,11 @@ response = image_edit(
    creativity=0.3,  # 0-0.35, higher = more creative
 )

-# Fast upscaling - quick upscaling
+# Fast upscaling - quick upscaling (no prompt needed)
 response = image_edit(
    model="stability/stable-fast-upscale-v1:0",
    image=open("low_res_image.png", "rb"),
-    prompt="Quickly upscale this image",
+    # No prompt required for fast upscale
 )
 print(response)
 ```
@ -259,7 +267,7 @@ os.environ['STABILITY_API_KEY'] = "your-api-key"
 response = image_edit(
    model="stability/stable-image-remove-background-v1:0",
    image=open("portrait.png", "rb"),
-    prompt="Remove the background",
+    # No prompt required for fast upscale
 )
 print(response)
 ```
@ -329,10 +337,29 @@ response = image_edit(
    model="stability/stable-image-erase-object-v1:0",
    image=open("scene.png", "rb"),
    mask=open("object_mask.png", "rb"),  # Mask the object to erase
-    prompt="Remove the object",
+    # No prompt needed
 )
 print(response)
 ```
+#### Style Transfer
+
+```python showLineNumbers
+from litellm import image_edit
+import os
+
+os.environ['STABILITY_API_KEY'] = "your-api-key"
+
+# Transfer style from one image to another
+# Note: Uses init_image (via image param) and style_image
+response = image_edit(
+    model="stability/stable-style-transfer-v1:0",
+    image=open("content_image.png", "rb"),  # Maps to init_image
+    style_image=open("style_reference.png", "rb"),  # Style to apply
+    fidelity=0.5,  # 0-1, balance between content and style
+    # No prompt needed
+)
+
+print(response)

 ### Supported Image Edit Models

@ -416,10 +443,26 @@ response = image_edit(
    image=open("original_image.png", "rb"),
    mask=open("mask_image.png", "rb"),
    prompt="Add flowers in the masked area",
-    size="1024x1024",
 )
 print(response)
 ```
+# Fast upscale without prompt
+response = image_edit(
+    model="bedrock/stability.stable-fast-upscale-v1:0",
+    image=open("low_res_image.png", "rb"),
+)
+
+# Outpaint with numeric parameters
+response = image_edit(
+    model="bedrock/stability.stable-outpaint-v1:0",
+    image=open("original_image.png", "rb"),
+    left=100,   # Automatically converted to int
+    right=100,
+    up=50,
+    down=50,
+)
+
+print(response)

 ### Supported Bedrock Stability Models

--- a/docs/my-website/docs/providers/vertex.md
+++ b/docs/my-website/docs/providers/vertex.md
@ -1390,6 +1390,77 @@ model_list:



+### **Workload Identity Federation**
+
+LiteLLM supports [Google Cloud Workload Identity Federation (WIF)](https://cloud.google.com/iam/docs/workload-identity-federation), which allows you to grant on-premises or multi-cloud workloads access to Google Cloud resources without using a service account key. This is the recommended approach for workloads running in other cloud environments (AWS, Azure, etc.) or on-premises.
+
+To use Workload Identity Federation, pass the path to your WIF credentials configuration file via `vertex_credentials`:
+
+<Tabs>
+<TabItem value="sdk" label="SDK">
+
+```python
+from litellm import completion
+
+response = completion(
+    model="vertex_ai/gemini-1.5-pro",
+    messages=[{"role": "user", "content": "Hello!"}],
+    vertex_credentials="/path/to/wif-credentials.json",  # 👈 WIF credentials file
+    vertex_project="your-gcp-project-id",
+    vertex_location="us-central1"
+)
+```
+
+</TabItem>
+<TabItem value="proxy" label="PROXY">
+
+```yaml
+model_list:
+  - model_name: gemini-model
+    litellm_params:
+      model: vertex_ai/gemini-1.5-pro
+      vertex_project: your-gcp-project-id
+      vertex_location: us-central1
+      vertex_credentials: /path/to/wif-credentials.json  # 👈 WIF credentials file
+```
+
+Alternatively, you can create credentials in **LLM Credentials** in the LiteLLM UI and use those to authenticate your models:
+
+```yaml
+model_list:
+  - model_name: gemini-model
+    litellm_params:
+      model: vertex_ai/gemini-1.5-pro
+      vertex_project: your-gcp-project-id
+      vertex_location: us-central1
+      litellm_credential_name: my-vertex-wif-credential  # 👈 Reference credential stored in UI
+```
+
+</TabItem>
+</Tabs>
+
+**WIF Credentials File Format**
+
+Your WIF credentials JSON file typically looks like this (for AWS federation):
+
+```json
+{
+  "type": "external_account",
+  "audience": "//iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/PROVIDER_ID",
+  "subject_token_type": "urn:ietf:params:aws:token-type:aws4_request",
+  "service_account_impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/SERVICE_ACCOUNT_EMAIL:generateAccessToken",
+  "token_url": "https://sts.googleapis.com/v1/token",
+  "credential_source": {
+    "environment_id": "aws1",
+    "region_url": "http://169.254.169.254/latest/meta-data/placement/availability-zone",
+    "url": "http://169.254.169.254/latest/meta-data/iam/security-credentials",
+    "regional_cred_verification_url": "https://sts.{region}.amazonaws.com?Action=GetCallerIdentity&Version=2011-06-15"
+  }
+}
+```
+
+For more details on setting up Workload Identity Federation, see [Google Cloud WIF documentation](https://cloud.google.com/iam/docs/workload-identity-federation).
+
 ### **Environment Variables**

 You can set:
--- a/docs/my-website/docs/proxy/admin_ui_sso.md
+++ b/docs/my-website/docs/proxy/admin_ui_sso.md
@ -73,8 +73,21 @@ GOOGLE_CLIENT_SECRET=
 ```shell
 MICROSOFT_CLIENT_ID="84583a4d-"
 MICROSOFT_CLIENT_SECRET="nbk8Q~"
-MICROSOFT_TENANT="5a39737
+MICROSOFT_TENANT="5a39737"
 ```
+
+**Optional: Custom Microsoft SSO Endpoints**
+
+If you need to use custom Microsoft SSO endpoints (e.g., for a custom identity provider, sovereign cloud, or proxy), you can override the default endpoints:
+
+```shell
+MICROSOFT_AUTHORIZATION_ENDPOINT="https://your-custom-url.com/oauth2/v2.0/authorize"
+MICROSOFT_TOKEN_ENDPOINT="https://your-custom-url.com/oauth2/v2.0/token"
+MICROSOFT_USERINFO_ENDPOINT="https://your-custom-graph-api.com/v1.0/me"
+```
+
+If these are not set, the default Microsoft endpoints are used based on your tenant.
+
 - Set Redirect URI on your App Registration on https://portal.azure.com/
    - Set a redirect url = `<your proxy base url>/sso/callback`
    ```shell
@ -98,6 +111,42 @@ To set up app roles:
 4. Assign users to these roles in your Enterprise Application
 5. When users sign in via SSO, LiteLLM will automatically assign them the corresponding role

+**Advanced: Custom User Attribute Mapping**
+
+For certain Microsoft Entra ID configurations, you may need to override the default user attribute field names. This is useful when your organization uses custom claims or non-standard attribute names in the SSO response.
+
+**Step 1: Debug SSO Response**
+
+First, inspect the JWT fields returned by your Microsoft SSO provider using the [SSO Debug Route](#debugging-sso-jwt-fields).
+
+1. Add `/sso/debug/callback` as a redirect URL in your Azure App Registration
+2. Navigate to `https://<proxy_base_url>/sso/debug/login`
+3. Complete the SSO flow to see the returned user attributes
+
+**Step 2: Identify Field Attribute Names**
+
+From the debug response, identify the field names used for email, display name, user ID, first name, and last name.
+
+**Step 3: Set Environment Variables**
+
+Override the default attribute names by setting these environment variables:
+
+| Environment Variable | Description | Default Value |
+|---------------------|-------------|---------------|
+| `MICROSOFT_USER_EMAIL_ATTRIBUTE` | Field name for user email | `userPrincipalName` |
+| `MICROSOFT_USER_DISPLAY_NAME_ATTRIBUTE` | Field name for display name | `displayName` |
+| `MICROSOFT_USER_ID_ATTRIBUTE` | Field name for user ID | `id` |
+| `MICROSOFT_USER_FIRST_NAME_ATTRIBUTE` | Field name for first name | `givenName` |
+| `MICROSOFT_USER_LAST_NAME_ATTRIBUTE` | Field name for last name | `surname` |
+
+**Step 4: Restart the Proxy**
+
+After setting the environment variables, restart the proxy:
+
+```bash
+litellm --config /path/to/config.yaml
+```
+
 </TabItem>

 <TabItem value="Generic" label="Generic SSO Provider">
--- a/docs/my-website/docs/proxy/caching.md
+++ b/docs/my-website/docs/proxy/caching.md
@ -282,6 +282,10 @@ Set either `REDIS_URL` or the `REDIS_HOST` in your os environment, to enable cac
  ```

 **Additional kwargs**  
+:::info
+Use `REDIS_*` environment variables to configure all Redis client library parameters. This is the suggested mechanism for toggling Redis settings as it automatically maps environment variables to Redis client kwargs.
+:::
+
 You can pass in any additional redis.Redis arg, by storing the variable + value in your os
 environment, like this:

@ -289,6 +293,17 @@ environment, like this:
 REDIS_<redis-kwarg-name> = ""
 ```

+For example:
+```shell
+REDIS_SSL = "True"
+REDIS_SSL_CERT_REQS = "None" 
+REDIS_CONNECTION_POOL_KWARGS = '{"max_connections": 20}'
+```
+
+:::warning
+**Note**: For non-string Redis parameters (like integers, booleans, or complex objects), avoid using `REDIS_*` environment variables as they may fail during Redis client initialization. Instead, use `cache_kwargs` in your router configuration for such parameters.
+:::
+
 [**See how it's read from the environment**](https://github.com/BerriAI/litellm/blob/4d7ff1b33b9991dcf38d821266290631d9bcd2dd/litellm/_redis.py#L40)

 #### Step 3: Run proxy with config
--- a/docs/my-website/docs/proxy/config_settings.md
+++ b/docs/my-website/docs/proxy/config_settings.md
@ -339,7 +339,7 @@ router_settings:
 | stream_timeout | Optional[float] | The default timeout for a streaming request. If not set, the 'timeout' value is used. |
 | debug_level | Literal["DEBUG", "INFO"] | The debug level for the logging library in the router. Defaults to "INFO". |
 | client_ttl | int | Time-to-live for cached clients in seconds. Defaults to 3600. |
-| cache_kwargs | dict | Additional keyword arguments for the cache initialization. |
+| cache_kwargs | dict | Additional keyword arguments for the cache initialization. Use this for non-string Redis parameters that may fail when set via `REDIS_*` environment variables. |
 | routing_strategy_args | dict | Additional keyword arguments for the routing strategy - e.g. lowest latency routing default ttl |
 | model_group_alias | dict | Model group alias mapping. E.g. `{"claude-3-haiku": "claude-3-haiku-20240229"}` |
 | num_retries | int | Number of retries for a request. Defaults to 3. |
@ -449,6 +449,13 @@ router_settings:
 | BRAINTRUST_API_KEY | API key for Braintrust integration
 | BRAINTRUST_API_BASE | Base URL for Braintrust API. Default is https://api.braintrustdata.com/v1
 | CACHED_STREAMING_CHUNK_DELAY | Delay in seconds for cached streaming chunks. Default is 0.02
+| CHATGPT_API_BASE | Base URL for ChatGPT API. Default is https://chatgpt.com/backend-api/codex
+| CHATGPT_AUTH_FILE | Filename for ChatGPT authentication data. Default is "auth.json"
+| CHATGPT_DEFAULT_INSTRUCTIONS | Default system instructions for ChatGPT provider
+| CHATGPT_ORIGINATOR | Originator identifier for ChatGPT API requests. Default is "codex_cli_rs"
+| CHATGPT_TOKEN_DIR | Directory to store ChatGPT authentication tokens. Default is "~/.config/litellm/chatgpt"
+| CHATGPT_USER_AGENT | Custom user agent string for ChatGPT API requests
+| CHATGPT_USER_AGENT_SUFFIX | Suffix to append to the ChatGPT user agent string
 | CIRCLE_OIDC_TOKEN | OpenID Connect token for CircleCI
 | CIRCLE_OIDC_TOKEN_V2 | Version 2 of the OpenID Connect token for CircleCI
 | CLOUDZERO_API_KEY | CloudZero API key for authentication
@ -603,6 +610,7 @@ router_settings:
 | GCS_PATH_SERVICE_ACCOUNT | Path to the Google Cloud service account JSON file
 | GCS_FLUSH_INTERVAL | Flush interval for GCS logging (in seconds). Specify how often you want a log to be sent to GCS. **Default is 20 seconds**
 | GCS_BATCH_SIZE | Batch size for GCS logging. Specify after how many logs you want to flush to GCS. If `BATCH_SIZE` is set to 10, logs are flushed every 10 logs. **Default is 2048**
+| GCS_USE_BATCHED_LOGGING | Enable batched logging for GCS. When enabled (default), multiple log payloads are combined into single GCS object uploads (NDJSON format), dramatically reducing API calls. When disabled, sends each log individually as separate GCS objects (legacy behavior). **Default is true**
 | GCS_PUBSUB_TOPIC_ID | PubSub Topic ID to send LiteLLM SpendLogs to.
 | GCS_PUBSUB_PROJECT_ID | PubSub Project ID to send LiteLLM SpendLogs to.
 | GENERIC_AUTHORIZATION_ENDPOINT | Authorization endpoint for generic OAuth providers
@ -744,6 +752,7 @@ router_settings:
 | LITELLM_PRINT_STANDARD_LOGGING_PAYLOAD | If true, prints the standard logging payload to the console - useful for debugging
 | LITELM_ENVIRONMENT | Environment for LiteLLM Instance. This is currently only logged to DeepEval to determine the environment for DeepEval integration.
 | LOGFIRE_TOKEN | Token for Logfire logging service
+| LOGFIRE_BASE_URL | Base URL for Logfire logging service (useful for self hosted deployments)
 | LOGGING_WORKER_CONCURRENCY | Maximum number of concurrent coroutine slots for the logging worker on the asyncio event loop. Default is 100. Setting too high will flood the event loop with logging tasks which will lower the overall latency of the requests.
 | LOGGING_WORKER_MAX_QUEUE_SIZE | Maximum size of the logging worker queue. When the queue is full, the worker aggressively clears tasks to make room instead of dropping logs. Default is 50,000
 | LOGGING_WORKER_MAX_TIME_PER_COROUTINE | Maximum time in seconds allowed for each coroutine in the logging worker before timing out. Default is 20.0
@ -754,6 +763,7 @@ router_settings:
 | LOGGING_WORKER_AGGRESSIVE_CLEAR_COOLDOWN_SECONDS | Cooldown time in seconds before allowing another aggressive clear operation when the queue is full. Default is 0.5 
 | MAX_STRING_LENGTH_PROMPT_IN_DB | Maximum length for strings in spend logs when sanitizing request bodies. Strings longer than this will be truncated. Default is 1000
 | MAX_IN_MEMORY_QUEUE_FLUSH_COUNT | Maximum count for in-memory queue flush operations. Default is 1000
+| MAX_IMAGE_URL_DOWNLOAD_SIZE_MB | Maximum size in MB for downloading images from URLs. Prevents memory issues from downloading very large images. Images exceeding this limit will be rejected before download. Set to 0 to completely disable image URL handling (all image_url requests will be blocked). Default is 50MB (matching [OpenAI's limit](https://platform.openai.com/docs/guides/images-vision?api-mode=chat#image-input-requirements))
 | MAX_LONG_SIDE_FOR_IMAGE_HIGH_RES | Maximum length for the long side of high-resolution images. Default is 2000
 | MAX_REDIS_BUFFER_DEQUEUE_COUNT | Maximum count for Redis buffer dequeue operations. Default is 100
 | MAX_SHORT_SIDE_FOR_IMAGE_HIGH_RES | Maximum length for the short side of high-resolution images. Default is 768
@ -771,10 +781,18 @@ router_settings:
 | MINIMUM_PROMPT_CACHE_TOKEN_COUNT | Minimum token count for caching a prompt. Default is 1024
 | MISTRAL_API_BASE | Base URL for Mistral API. Default is https://api.mistral.ai
 | MISTRAL_API_KEY | API key for Mistral API
+| MICROSOFT_AUTHORIZATION_ENDPOINT | Custom authorization endpoint URL for Microsoft SSO (overrides default Microsoft OAuth authorization endpoint)
 | MICROSOFT_CLIENT_ID | Client ID for Microsoft services
 | MICROSOFT_CLIENT_SECRET | Client secret for Microsoft services
-| MICROSOFT_TENANT | Tenant ID for Microsoft Azure
 | MICROSOFT_SERVICE_PRINCIPAL_ID | Service Principal ID for Microsoft Enterprise Application. (This is an advanced feature if you want litellm to auto-assign members to Litellm Teams based on their Microsoft Entra ID Groups)
+| MICROSOFT_TENANT | Tenant ID for Microsoft Azure
+| MICROSOFT_TOKEN_ENDPOINT | Custom token endpoint URL for Microsoft SSO (overrides default Microsoft OAuth token endpoint)
+| MICROSOFT_USER_DISPLAY_NAME_ATTRIBUTE | Field name for user display name in Microsoft SSO response. Default is `displayName`
+| MICROSOFT_USER_EMAIL_ATTRIBUTE | Field name for user email in Microsoft SSO response. Default is `userPrincipalName`
+| MICROSOFT_USER_FIRST_NAME_ATTRIBUTE | Field name for user first name in Microsoft SSO response. Default is `givenName`
+| MICROSOFT_USER_ID_ATTRIBUTE | Field name for user ID in Microsoft SSO response. Default is `id`
+| MICROSOFT_USER_LAST_NAME_ATTRIBUTE | Field name for user last name in Microsoft SSO response. Default is `surname`
+| MICROSOFT_USERINFO_ENDPOINT | Custom userinfo endpoint URL for Microsoft SSO (overrides default Microsoft Graph userinfo endpoint)
 | NO_DOCS | Flag to disable Swagger UI documentation
 | NO_REDOC | Flag to disable Redoc documentation
 | NO_PROXY | List of addresses to bypass proxy
@ -783,6 +801,7 @@ router_settings:
 | OPENAI_BASE_URL | Base URL for OpenAI API
 | OPENAI_API_BASE | Base URL for OpenAI API. Default is https://api.openai.com/
 | OPENAI_API_KEY | API key for OpenAI services
+| OPENAI_CHATGPT_API_BASE | Alternative to CHATGPT_API_BASE. Base URL for ChatGPT API
 | OPENAI_FILE_SEARCH_COST_PER_1K_CALLS | Cost per 1000 calls for OpenAI file search. Default is 0.0025
 | OPENAI_ORGANIZATION | Organization identifier for OpenAI
 | OPENID_BASE_URL | Base URL for OpenID Connect services
--- a/docs/my-website/docs/proxy/customer_usage.md
+++ b/docs/my-website/docs/proxy/customer_usage.md
@ -22,19 +22,22 @@ Customer Usage enables you to track spend and usage for individual customers (en

 ## How to Track Spend

-Track customer spend by including a `user` field in your API requests. The customer ID will be automatically tracked and associated with all spend from that request.
+Track customer spend by including a `user` field in your API requests or by passing a customer ID header. The customer ID will be automatically tracked and associated with all spend from that request.

-### Example using cURL
+<Tabs>
+<TabItem value="body" label="Request Body" default>
+
+### Using Request Body

 Make a `/chat/completions` call with the `user` field containing your customer ID:

-```bash showLineNumbers title="Track spend with customer ID"
+```bash showLineNumbers title="Track spend with customer ID in body"
 curl -X POST 'http://0.0.0.0:4000/chat/completions' \
  --header 'Content-Type: application/json' \
-  --header 'Authorization: Bearer sk-1234' \ # 👈 YOUR PROXY KEY
+  --header 'Authorization: Bearer sk-1234' \
  --data '{
    "model": "gpt-3.5-turbo",
-    "user": "customer-123", # 👈 CUSTOMER ID
+    "user": "customer-123",
    "messages": [
      {
        "role": "user",
@ -44,7 +47,49 @@ curl -X POST 'http://0.0.0.0:4000/chat/completions' \
  }'
 ```

-The customer ID (`customer-123`) will be automatically upserted into the database with the new spend. If the customer ID already exists, spend will be incremented.
+</TabItem>
+<TabItem value="header" label="Request Header">
+
+### Using Request Headers
+
+You can also pass the customer ID via HTTP headers. This is useful for tools that support custom headers but don't allow modifying the request body (like Claude Code with `ANTHROPIC_CUSTOM_HEADERS`).
+
+LiteLLM automatically recognizes these standard headers (no configuration required):
+- `x-litellm-customer-id`
+- `x-litellm-end-user-id`
+
+```bash showLineNumbers title="Track spend with customer ID in header"
+curl -X POST 'http://0.0.0.0:4000/chat/completions' \
+  --header 'Content-Type: application/json' \
+  --header 'Authorization: Bearer sk-1234' \
+  --header 'x-litellm-customer-id: customer-123' \
+  --data '{
+    "model": "gpt-3.5-turbo",
+    "messages": [
+      {
+        "role": "user",
+        "content": "What is the capital of France?"
+      }
+    ]
+  }'
+```
+
+#### Using with Claude Code
+
+Claude Code supports custom headers via the `ANTHROPIC_CUSTOM_HEADERS` environment variable. Set it to pass your customer ID:
+
+```bash title="Configure Claude Code with customer tracking"
+export ANTHROPIC_BASE_URL="http://0.0.0.0:4000/v1/messages"
+export ANTHROPIC_API_KEY="sk-1234"
+export ANTHROPIC_CUSTOM_HEADERS="x-litellm-customer-id: my-customer-id"
+```
+
+Now all requests from Claude Code will automatically track spend under `my-customer-id`.
+
+</TabItem>
+</Tabs>
+
+The customer ID will be automatically upserted into the database with the new spend. If the customer ID already exists, spend will be incremented.

 ### Example using OpenWebUI

--- a/docs/my-website/docs/proxy/deleted_keys_teams.md
+++ b/docs/my-website/docs/proxy/deleted_keys_teams.md
@ -0,0 +1,106 @@
+import Image from '@theme/IdealImage';
+
+# Deleted Keys & Teams Audit Logs
+
+<Image img={require('../../img/ui_deleted_keys_table.png')} />
+
+View deleted API keys and teams along with their spend and budget information at the time of deletion for auditing and compliance purposes.
+
+## Overview
+
+The Deleted Keys & Teams feature provides a comprehensive audit trail for deleted entities in your LiteLLM proxy. This feature was implemented to easily allow audits of which key or team was deleted along with the spend/budget at the time of deletion.
+
+When a key or team is deleted, LiteLLM automatically captures:
+
+- **Deletion timestamp** - When the entity was deleted
+- **Deleted by** - Who performed the deletion action
+- **Spend at deletion** - The total spend accumulated at the time of deletion
+- **Original budget** - The budget that was set for the entity before deletion
+- **Entity details** - Key or team identification information
+
+This information is preserved even after deletion, allowing you to maintain accurate financial records and audit trails for compliance purposes.
+
+## Viewing Deleted Keys
+
+### Step 1: Navigate to API Keys Page
+
+Navigate to the API Keys page in the LiteLLM UI:
+
+```
+http://localhost:4000/ui/?login=success&page=api-keys
+```
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-17/73b97ba9-0ab5-4140-aee2-05fa90463461/ascreenshot_5e6d9f05d452405c83d7a368349d087d_text_export.jpeg)
+
+### Step 2: Access Logs Section
+
+Click on the "Logs" menu item in the navigation.
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-17/73b97ba9-0ab5-4140-aee2-05fa90463461/ascreenshot_8ebab354b1e542e59e1082e519927edd_text_export.jpeg)
+
+### Step 3: View Deleted Keys
+
+Click on "Deleted Keys" to view the table of all deleted API keys.
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-17/00668558-9326-4a6f-8e87-159d54b17a72/ascreenshot_d0e50e49e9aa43d4a22ada6f12a78b12_text_export.jpeg)
+
+### Step 4: Review Deletion Information
+
+The Deleted Keys table includes comprehensive information about each deleted key:
+
+- **When** the key was deleted (timestamp)
+- **Who** deleted the key (user/admin information)
+- **Key identification** details
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-17/8538f7c4-634e-44c8-8d7d-fafbd6da0b02/ascreenshot_6b73f9c6a52d4e40a2368ef441cf6c8f_text_export.jpeg)
+
+### Step 5: View Financial Information
+
+The table also displays financial information captured at the time of deletion:
+
+- **Spend at deletion** - Total spend accumulated when the key was deleted
+- **Original budget** - The budget limit that was set for the key
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-17/f8b03850-b17c-490c-a507-c3b0b6c050ab/ascreenshot_070b139f111844bba38fbed8835b097b_text_export.jpeg)
+
+## Viewing Deleted Teams
+
+### Step 1: Access Deleted Teams
+
+From the Logs section, click on "Deleted Teams" to view all deleted teams.
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-17/716ce26f-09af-4a6d-99c5-921d6b6a8555/ascreenshot_d36c16f1cf894340aa8bc20ada5922ac_text_export.jpeg)
+
+### Step 2: Review Team Deletion Information
+
+The Deleted Teams table provides detailed information about each deleted team:
+
+- **When** the team was deleted (timestamp)
+- **Who** deleted the team (user/admin information)
+- **Team identification** details
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-17/0a3f2d3f-179a-4ad7-916e-b77a13dca01d/ascreenshot_ded5970762d54528ae656421148116c4_text_export.jpeg)
+
+### Step 3: View Team Financial Information
+
+Similar to deleted keys, the Deleted Teams table shows financial information:
+
+- **Spend at deletion** - Total spend accumulated when the team was deleted
+- **Original budget** - The budget limit that was set for the team
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-17/5b24871f-b57e-404d-8fbe-a4b27cb2a6a0/ascreenshot_3121fbafbd6b4abf90993ce6c03c608d_text_export.jpeg)
+
+## Use Cases
+
+This feature is particularly useful for:
+
+- **Financial Auditing** - Track spend and budgets for deleted entities
+- **Compliance** - Maintain records of who deleted what and when
+- **Cost Analysis** - Understand spending patterns before deletion
+- **Accountability** - Identify which admin or user performed deletions
+- **Historical Records** - Preserve financial data even after entity deletion
+
+## Related Features
+
+- [Audit Logs](./multiple_admins.md) - View comprehensive audit logs for all entity changes
+- [UI Logs](./ui_logs.md) - View request logs and spend tracking
--- a/docs/my-website/docs/proxy/deploy.md
+++ b/docs/my-website/docs/proxy/deploy.md
@ -4,6 +4,10 @@ import Image from '@theme/IdealImage';

 # Docker, Helm, Terraform

+:::info No Limits on LiteLLM OSS
+There are **no limits** on the number of users, keys, or teams you can create on LiteLLM OSS.
+:::
+
 You can find the Dockerfile to build litellm proxy [here](https://github.com/BerriAI/litellm/blob/main/Dockerfile)

 > Note: Production requires at least 4 CPU cores and 8 GB RAM.
--- a/docs/my-website/docs/proxy/fallback_management.md
+++ b/docs/my-website/docs/proxy/fallback_management.md
@ -0,0 +1,267 @@
+# [New] Fallback Management Endpoints
+
+Dedicated endpoints for managing model fallbacks separately from the general configuration.
+
+## Overview
+
+These endpoints allow you to configure, retrieve, and delete fallback models without modifying the entire proxy configuration. This provides a cleaner and safer way to manage fallbacks compared to using the `/config/update` endpoint.
+
+## Prerequisites
+
+- Database storage must be enabled: Set `STORE_MODEL_IN_DB=True` in your environment
+- Models must exist in the router before configuring fallbacks
+
+## Endpoints
+
+### POST /fallback
+
+Create or update fallbacks for a specific model.
+
+**Request Body:**
+```json
+{
+  "model": "gpt-3.5-turbo",
+  "fallback_models": ["gpt-4", "claude-3-haiku"],
+  "fallback_type": "general"
+}
+```
+
+**Parameters:**
+- `model` (string, required): The primary model name to configure fallbacks for
+- `fallback_models` (array of strings, required): List of fallback model names in priority order
+- `fallback_type` (string, optional): Type of fallback. Options:
+  - `"general"` (default): Standard fallbacks for any error
+  - `"context_window"`: Fallbacks for context window exceeded errors
+  - `"content_policy"`: Fallbacks for content policy violations
+
+**Response:**
+```json
+{
+  "model": "gpt-3.5-turbo",
+  "fallback_models": ["gpt-4", "claude-3-haiku"],
+  "fallback_type": "general",
+  "message": "Fallback configuration created successfully"
+}
+```
+
+**Example using cURL:**
+```bash
+curl -X POST "http://localhost:4000/fallback" \
+  -H "Authorization: Bearer sk-1234" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gpt-3.5-turbo",
+    "fallback_models": ["gpt-4", "claude-3-haiku"],
+    "fallback_type": "general"
+  }'
+```
+
+**Example using Python:**
+```python
+import requests
+
+response = requests.post(
+    "http://localhost:4000/fallback",
+    headers={
+        "Authorization": "Bearer sk-1234",
+        "Content-Type": "application/json"
+    },
+    json={
+        "model": "gpt-3.5-turbo",
+        "fallback_models": ["gpt-4", "claude-3-haiku"],
+        "fallback_type": "general"
+    }
+)
+
+print(response.json())
+```
+
+### GET /fallback/\{model\}
+
+Get fallback configuration for a specific model.
+
+**Parameters:**
+- `model` (path parameter, required): The model name to get fallbacks for
+- `fallback_type` (query parameter, optional): Type of fallback to retrieve (default: "general")
+
+**Response:**
+```json
+{
+  "model": "gpt-3.5-turbo",
+  "fallback_models": ["gpt-4", "claude-3-haiku"],
+  "fallback_type": "general"
+}
+```
+
+**Example using cURL:**
+```bash
+curl -X GET "http://localhost:4000/fallback/gpt-3.5-turbo?fallback_type=general" \
+  -H "Authorization: Bearer sk-1234"
+```
+
+**Example using Python:**
+```python
+import requests
+
+response = requests.get(
+    "http://localhost:4000/fallback/gpt-3.5-turbo",
+    headers={"Authorization": "Bearer sk-1234"},
+    params={"fallback_type": "general"}
+)
+
+print(response.json())
+```
+
+### DELETE /fallback/\{model\}
+
+Delete fallback configuration for a specific model.
+
+**Parameters:**
+- `model` (path parameter, required): The model name to delete fallbacks for
+- `fallback_type` (query parameter, optional): Type of fallback to delete (default: "general")
+
+**Response:**
+```json
+{
+  "model": "gpt-3.5-turbo",
+  "fallback_type": "general",
+  "message": "Fallback configuration deleted successfully"
+}
+```
+
+**Example using cURL:**
+```bash
+curl -X DELETE "http://localhost:4000/fallback/gpt-3.5-turbo?fallback_type=general" \
+  -H "Authorization: Bearer sk-1234"
+```
+
+**Example using Python:**
+```python
+import requests
+
+response = requests.delete(
+    "http://localhost:4000/fallback/gpt-3.5-turbo",
+    headers={"Authorization": "Bearer sk-1234"},
+    params={"fallback_type": "general"}
+)
+
+print(response.json())
+```
+
+### Test fallback
+
+```bash
+curl -X POST 'http://0.0.0.0:4000/chat/completions' \
+-H 'Content-Type: application/json' \
+-H 'Authorization: Bearer sk-1234' \
+-d '{
+  "model": "gpt-3.5-turbo",
+  "messages": [
+    {
+      "role": "user",
+      "content": "ping"
+    }
+  ],
+  "mock_testing_fallbacks": true
+}
+'
+```
+
+
+
+## Validation
+
+The endpoints perform the following validations:
+
+1. **Model Existence**: Verifies that the primary model exists in the router
+2. **Fallback Model Existence**: Ensures all fallback models exist in the router
+3. **No Self-Fallback**: Prevents a model from being its own fallback
+4. **No Duplicates**: Ensures no duplicate models in the fallback list
+5. **Database Enabled**: Requires `STORE_MODEL_IN_DB=True` to be set
+
+## Error Responses
+
+### 400 Bad Request
+```json
+{
+  "detail": {
+    "error": "Invalid fallback models: ['non-existent-model']",
+    "available_models": ["gpt-3.5-turbo", "gpt-4", "claude-3-haiku"]
+  }
+}
+```
+
+### 404 Not Found
+```json
+{
+  "detail": {
+    "error": "Model 'gpt-3.5-turbo' not found in router",
+    "available_models": ["gpt-4", "claude-3-haiku"]
+  }
+}
+```
+
+### 500 Internal Server Error
+```json
+{
+  "detail": {
+    "error": "Router not initialized"
+  }
+}
+```
+
+## Fallback Types Explained
+
+### General Fallbacks
+Used for any type of error that occurs during model invocation. This is the most common type of fallback.
+
+**Use Case:** When a model is unavailable, rate-limited, or returns an error.
+
+```json
+{
+  "model": "gpt-3.5-turbo",
+  "fallback_models": ["gpt-4", "claude-3-haiku"],
+  "fallback_type": "general"
+}
+```
+
+### Context Window Fallbacks
+Specifically triggered when a context window exceeded error occurs.
+
+**Use Case:** When the input is too long for the primary model, fallback to a model with a larger context window.
+
+```json
+{
+  "model": "gpt-3.5-turbo",
+  "fallback_models": ["gpt-4-32k", "claude-3-opus"],
+  "fallback_type": "context_window"
+}
+```
+
+### Content Policy Fallbacks
+Specifically triggered when content policy violations occur.
+
+**Use Case:** When the primary model rejects content due to safety filters, fallback to a model with different content policies.
+
+```json
+{
+  "model": "gpt-4",
+  "fallback_models": ["claude-3-haiku"],
+  "fallback_type": "content_policy"
+}
+```
+
+## Benefits Over /config/update
+
+1. **Safety**: Only modifies fallback configuration, won't accidentally change other settings
+2. **Simplicity**: Focused API with clear validation messages
+3. **Granularity**: Manage fallbacks per model and per type
+4. **Validation**: Comprehensive checks ensure configuration is valid before applying
+5. **Clarity**: Clear error messages with available models listed
+
+## Notes
+
+- Fallbacks are triggered after the configured number of retries fails
+- Fallbacks are attempted in the order specified in `fallback_models`
+- The maximum number of fallbacks attempted is controlled by the router's `max_fallbacks` setting
+- Changes take effect immediately and are persisted to the database
--- a/docs/my-website/docs/proxy/guardrails/panw_prisma_airs.md
+++ b/docs/my-website/docs/proxy/guardrails/panw_prisma_airs.md
@ -206,6 +206,7 @@ Expected successful response:
 | `mode` | No | When to run the guardrail | `pre_call` |
 | `fallback_on_error` | No | Action when PANW API is unavailable: `"block"` (fail-closed, default) or `"allow"` (fail-open). Config errors always block. | `block` |
 | `timeout` | No | PANW API call timeout in seconds (1-60) | `10.0` |
+| `violation_message_template` | No | Custom template for error message when request is blocked. Supports `{guardrail_name}`, `{category}`, `{action_type}`, `{default_message}` placeholders. | - |

 ### Regional Endpoints

@ -449,6 +450,33 @@ LiteLLM does not alter or configure your PANW security profile. To change what c
 The guardrail is **fail-closed** by default - if the PANW API is unavailable, requests are blocked to ensure no unscanned content reaches your LLM. This provides maximum security.
 :::

+### Custom Violation Messages
+
+You can customize the error message returned to the user when a request is blocked by configuring the `violation_message_template` parameter. This is useful for providing user-friendly feedback instead of technical details.
+
+```yaml
+guardrails:
+  - guardrail_name: "panw-custom-message"
+    litellm_params:
+      guardrail: panw_prisma_airs
+      api_key: os.environ/PANW_PRISMA_AIRS_API_KEY
+      # Simple message
+      violation_message_template: "Your request was blocked by our AI Security Policy."
+
+  - guardrail_name: "panw-detailed-message"
+    litellm_params:
+      guardrail: panw_prisma_airs
+      api_key: os.environ/PANW_PRISMA_AIRS_API_KEY
+      # Message with placeholders
+      violation_message_template: "{action_type} blocked due to {category} violation. Please contact support."
+```
+
+**Supported Placeholders:**
+- `{guardrail_name}`: Name of the guardrail (e.g. "panw-custom-message")
+- `{category}`: Violation category (e.g. "malicious", "injection", "dlp")
+- `{action_type}`: "Prompt" or "Response"
+- `{default_message}`: The original technical error message
+
 ### Fail-Open Configuration

 By default, the PANW guardrail operates in **fail-closed** mode for maximum security. If the PANW API is unavailable (timeout, rate limit, network error), requests are blocked. You can configure **fail-open** mode for high-availability scenarios where service continuity is critical.
--- a/docs/my-website/docs/proxy/guardrails/pillar_security.md
+++ b/docs/my-website/docs/proxy/guardrails/pillar_security.md
--- a/docs/my-website/docs/proxy/guardrails/quick_start.md
+++ b/docs/my-website/docs/proxy/guardrails/quick_start.md
@ -59,6 +59,18 @@ guardrails:
      presidio_score_thresholds:  # minimum confidence scores for keeping detections
        CREDIT_CARD: 0.8
        EMAIL_ADDRESS: 0.6
+
+# Example Pillar Security config via Generic Guardrail API
+  - guardrail_name: "pillar-security"
+    litellm_params:
+      guardrail: generic_guardrail_api
+      mode: [pre_call, post_call]
+      api_base: https://api.pillar.security/api/v1/integrations/litellm
+      api_key: os.environ/PILLAR_API_KEY
+      additional_provider_specific_params:
+        plr_mask: true
+        plr_evidence: true
+        plr_scanners: true
 ```


--- a/docs/my-website/docs/proxy/logging.md
+++ b/docs/my-website/docs/proxy/logging.md
@ -1827,6 +1827,64 @@ This approach allows you to:
 - Share callbacks across different environments
 - Version control callback files in cloud storage

+#### Step 2c - Mounting Custom Callbacks in Helm/Kubernetes (Alternative)
+
+When deploying with Helm or Kubernetes, you can mount custom callback Python files alongside your `config.yaml` using `subPath` to avoid overwriting the config directory.
+
+**The Problem:**
+Mounting a volume to a directory (e.g., `/app/`) would normally hide all existing files in that directory, including your `config.yaml`.
+
+**The Solution:**
+Use `subPath` in your `volumeMounts` to mount individual files without overwriting the entire directory.
+
+**Example - Helm values.yaml:**
+
+```yaml
+# values.yaml
+volumes:
+  - name: callback-files
+    configMap:
+      name: litellm-callback-files
+
+volumeMounts:
+  - name: callback-files
+    mountPath: /app/custom_callbacks.py  # Mount to specific FILE path
+    subPath: custom_callbacks.py         # Required to avoid overwriting directory
+```
+
+**Create the ConfigMap with your callback file:**
+
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: litellm-callback-files
+data:
+  custom_callbacks.py: |
+    from litellm.integrations.custom_logger import CustomLogger
+    
+    class MyCustomHandler(CustomLogger):
+        async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
+            print(f"Success! Model: {kwargs.get('model')}")
+    
+    proxy_handler_instance = MyCustomHandler()
+```
+
+**Reference in your config.yaml:**
+
+```yaml
+litellm_settings:
+  callbacks: custom_callbacks.proxy_handler_instance
+```
+
+**How it works:**
+1. The `subPath` parameter tells Kubernetes to mount only the specific file
+2. This places `custom_callbacks.py` in `/app/` alongside your existing `config.yaml`
+3. LiteLLM automatically finds the callback file in the same directory as the config
+4. No files are overwritten or hidden
+
+**Note:** You can mount multiple callback files by adding more `volumeMounts` entries, each with its own `subPath`.
+
 #### Step 3 - Start proxy + test request

 ```shell
--- a/docs/my-website/docs/proxy/spend_logs_deletion.md
+++ b/docs/my-website/docs/proxy/spend_logs_deletion.md
@ -30,6 +30,9 @@ general_settings:
  # Optional: set how frequently cleanup should run - default is daily
  maximum_spend_logs_retention_interval: "1d"  # Run cleanup daily

+  # Optional: set exact time for cleanup (Cron syntax)
+  maximum_spend_logs_cleanup_cron: "0 4 * * *" # Run at 04:00 AM daily
+
 litellm_settings:
  cache: true
  cache_params:
@ -51,6 +54,15 @@ How long logs should be kept before deletion. Supported formats:

 How often the cleanup job should run. Uses the same format as above. If not set, cleanup will run every 24 hours if and only if `maximum_spend_logs_retention_period` is set.

+#### `maximum_spend_logs_cleanup_cron` (optional)
+
+Schedule the cleanup using standard cron syntax. This takes precedence over `maximum_spend_logs_retention_interval`.
+
+Examples:
+- `"0 4 * * *"` – Run at 04:00 AM daily
+- `"0 0 * * 0"` – Run at midnight every Sunday
+- `"*/30 * * * *"` – Run every 30 minutes
+
 ## How it works

 ### Step 1. Lock Acquisition (Optional with Redis)
--- a/docs/my-website/docs/routing.md
+++ b/docs/my-website/docs/routing.md
@ -1333,6 +1333,10 @@ router = Router(model_list: Optional[list] = None,
 				 cache_responses=True)
 ```

+:::info
+When configuring Redis caching in router settings, use `cache_kwargs` to pass additional Redis parameters, especially for non-string values that may fail when set via `REDIS_*` environment variables.
+:::
+
 ## Pre-Call Checks (Context Window, EU-Regions)

 Enable pre-call checks to filter out:
--- 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",
--- a/docs/my-website/docs/troubleshoot.md
+++ b/docs/my-website/docs/troubleshoot.md
@ -1,12 +1,60 @@
-# Support & Talk with founders
+# Troubleshooting & Support
+
+## Information to Provide When Seeking Help
+
+When reporting issues, please include as much of the following as possible. It's okay if you can't provide everything—especially in production scenarios where the trigger might be unknown. Sharing most of this information will help us assist you more effectively.
+
+### 1. LiteLLM Configuration File
+
+Your `config.yaml` file (redact sensitive info like API keys). Include number of workers if not in config.
+
+### 2. Initialization Command
+
+The command used to start LiteLLM (e.g., `litellm --config config.yaml --num_workers 8 --detailed_debug`).
+
+### 3. LiteLLM Version
+
+- Current version  
+- Version when the issue first appeared (if different)  
+- If upgraded, the version changed from → to
+
+### 4. Environment Variables
+
+Non-sensitive environment variables not in your config (e.g., `NUM_WORKERS`, `LITELLM_LOG`, `LITELLM_MODE`). Do not include passwords or API keys.
+
+### 5. Server Specifications
+
+CPU cores, RAM, OS, number of instances/replicas, etc.
+
+### 6. Database and Redis Usage
+
+- **Database:** Using database? (`DATABASE_URL` set), database type and version
+- **Redis:** Using Redis? Redis version, configuration type (Standalone/Cluster/Sentinel).
+
+### 7. Endpoints
+
+The endpoint(s) you're using that are experiencing issues (e.g., `/chat/completions`, `/embeddings`).
+
+### 8. Request Example
+
+A realistic example of the request causing issues, including expected vs. actual response and any error messages.
+
+### 9. Error Logs, Stack Traces, and Metrics
+
+Full error logs, stack traces, and any images from service metrics (CPU, memory, request rates, etc.) that might help diagnose the issue.
+
+---
+
+## Support Channels
+
 [Schedule Demo 👋](https://calendly.com/d/4mp-gd3-k5k/berriai-1-1-onboarding-litellm-hosted-version)

 [Community Discord 💭](https://discord.gg/wuPM9dRgDw)
 [Community Slack 💭](https://www.litellm.ai/support)

-Our numbers 📞 +1 (770) 8783-106 / ‭+1 (412) 618-6238‬
+Our numbers 📞 +1 (770) 8783-106 / +1 (412) 618-6238

 Our emails ✉️ ishaan@berri.ai / krrish@berri.ai

-[![Chat on WhatsApp](https://img.shields.io/static/v1?label=Chat%20on&message=WhatsApp&color=success&logo=WhatsApp&style=flat-square)](https://wa.link/huol9n) [![Chat on Discord](https://img.shields.io/static/v1?label=Chat%20on&message=Discord&color=blue&logo=Discord&style=flat-square)](https://discord.gg/wuPM9dRgDw) 
+[![Chat on WhatsApp](https://img.shields.io/static/v1?label=Chat%20on&message=WhatsApp&color=success&logo=WhatsApp&style=flat-square)](https://wa.link/huol9n) [![Chat on Discord](https://img.shields.io/static/v1?label=Chat%20on&message=Discord&color=blue&logo=Discord&style=flat-square)](https://discord.gg/wuPM9dRgDw)

--- a/docs/my-website/docs/troubleshoot/cpu_issues.md
+++ b/docs/my-website/docs/troubleshoot/cpu_issues.md
@ -0,0 +1,31 @@
+# CPU Issue Classification & Reproduction
+
+## 1. Classify the CPU Issue
+
+Select the options that best describes the CPU behavior observed.
+
+- [ ] CPU scales with traffic (RPS-driven)
+- [ ] CPU increases without a traffic increase
+- [ ] CPU increases after a LiteLLM upgrade
+
+## 2. Can you reproduce the issue?
+
+Before escalating, verify whether the CPU issue can be reproduced in a test environment that mirrors your production setup.  
+
+If reproducible, provide **detailed reproduction steps** along with any relevant requests or configuration used.  
+For guidance on the type of information we're looking for, see the [LiteLLM Troubleshooting Guide](../troubleshoot).
+
+## 3. Issue Cannot Be Reproduced
+
+If the CPU issue cannot be reproduced in a test environment that mirrors your production setup, please provide:
+
+1. **Information from Section 1 and 2**  
+   - CPU classification (Section 1)  
+   - Reproduction attempts and environment details (Section 2)  
+
+2. **Additional context** to help investigate:  
+   - **Workload:** A realistic sample of requests processed before and during the spike, including any recent configuration changes.  
+   - **Metrics:** CPU usage, P50/P99 latency, memory usage. Please include **screenshots** of the metrics whenever possible.  
+   - **Logs / Alerts:** Any relevant logs or alerts captured **before and during the spike**.
+
+> Providing this information allows the team to analyze patterns, correlate spikes with traffic or configuration, and attempt to reproduce the issue internally. Without it, our engineers won't have enough information to look into the problem.
--- a/docs/my-website/docs/troubleshoot/memory_issues.md
+++ b/docs/my-website/docs/troubleshoot/memory_issues.md
@ -0,0 +1,37 @@
+# Memory Issue Classification & Reproduction
+
+## 1. Classify the Memory Issue
+
+Select the option(s) that best describe the memory behavior observed:
+
+- [ ] Memory scales with traffic (RPS-driven)  
+- [ ] Memory increases without a traffic increase  
+- [ ] Memory increases after a LiteLLM upgrade  
+- [ ] Memory leak (memory continuously grows over time)  
+- [ ] Out of Memory (OOM) events or pod restarts
+
+---
+
+## 2. Can you reproduce the issue?
+
+Before escalating, verify whether the memory or OOM issue can be reproduced in a test environment that mirrors your production deployment.  
+
+If reproducible, provide **detailed reproduction steps** along with any relevant requests, workloads, or configuration used.  
+For guidance on the type of information we’re looking for, see the [LiteLLM Troubleshooting Guide](../troubleshoot).
+
+---
+
+## 3. Issue Cannot Be Reproduced
+
+If the memory or OOM issue cannot be reproduced in a test environment that mirrors production, please provide:
+
+1. **Information from Sections 1 and 2**  
+   - Memory/issue classification (Section 1)  
+   - Reproduction attempts and environment details (Section 2)  
+
+2. **Additional context** to help investigate:  
+   - **Workload:** A realistic sample of requests processed before and during the spike, including any recent configuration changes.  
+   - **Metrics:** Memory usage, CPU usage, P50/P99 latency, and any pod restarts or OOM events. Please include **screenshots** of the metrics whenever possible.  
+   - **Logs / Alerts:** Any relevant logs or alerts captured **before and during the spike**, including OOM errors or stack traces if available.
+
+> Providing this information allows the team to analyze patterns, correlate memory spikes or OOMs with traffic or configuration, and attempt to reproduce the issue internally. Without it, our engineers will not have enough information to investigate the problem.
--- a/docs/my-website/docs/tutorials/claude_code_customer_tracking.md
+++ b/docs/my-website/docs/tutorials/claude_code_customer_tracking.md
@ -0,0 +1,99 @@
+# Claude Code - Granular Cost Tracking
+
+Track Claude Code usage by customer or tags using LiteLLM proxy. This enables granular cost attribution for billing, budgeting, and analytics.
+
+## How It Works
+
+Claude Code supports custom headers via `ANTHROPIC_CUSTOM_HEADERS`. LiteLLM automatically tracks requests with specific headers for cost attribution.
+
+## Tracking Options
+
+Choose how you want to attribute costs:
+
+| Track By | Header | Use Case |
+|----------|--------|----------|
+| Customer | `x-litellm-customer-id` | Bill customers, per-user budgets |
+| Tags | `x-litellm-tags` | Project tracking, cost centers, environments |
+
+## Environment Variables
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `ANTHROPIC_BASE_URL` | LiteLLM proxy URL | `http://localhost:4000` |
+| `ANTHROPIC_API_KEY` | LiteLLM API key | `sk-1234` |
+| `ANTHROPIC_CUSTOM_HEADERS` | Custom headers (`header-name: value` format) | See examples below |
+
+## Option 1: Track by Customer
+
+Use this to attribute costs to specific customers or end-users.
+
+```bash
+export ANTHROPIC_BASE_URL=http://localhost:4000
+export ANTHROPIC_API_KEY=sk-1234
+export ANTHROPIC_CUSTOM_HEADERS="x-litellm-customer-id: claude-ishaan-local"
+```
+
+## Option 2: Track by Tags
+
+Use this to attribute costs to projects, cost centers, or environments. Pass comma-separated tags.
+
+```bash
+export ANTHROPIC_BASE_URL=http://localhost:4000
+export ANTHROPIC_API_KEY=sk-1234
+export ANTHROPIC_CUSTOM_HEADERS="x-litellm-tags: project:acme,env:prod,team:backend"
+```
+
+
+## Quick Start
+
+### 1. Set Environment Variables
+
+```bash
+export ANTHROPIC_BASE_URL=http://localhost:4000
+export ANTHROPIC_API_KEY=sk-1234
+export ANTHROPIC_CUSTOM_HEADERS="x-litellm-customer-id: claude-ishaan-local"
+```
+
+### 2. Use Claude Code
+
+```bash
+claude
+```
+
+All requests will now be tracked under the customer ID `claude-ishaan-local`.
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-16/8f45872e-2d00-4d01-bf3d-4d6ae11d1396/ascreenshot_d2a745b8da4f4a56aaf2cac02871ef53_text_export.jpeg)
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-16/dd41eae3-2592-4bc9-a8d2-d6d02614cd2d/ascreenshot_43ec9ee48ad946cca49732f007e786fc_text_export.jpeg)
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-16/0c30309e-7117-4999-a3df-d22a2d5629c1/ascreenshot_d76a48c53b9a4fad8f6727baf4aa6a9c_text_export.jpeg)
+
+### 3. View Usage in LiteLLM UI
+
+Navigate to the **Logs** tab in the LiteLLM UI.
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-16/ff774392-69f5-483e-83e2-fb749c94ee90/ascreenshot_d264fc04c9ee47edb047f61b6eb8c4d7_text_export.jpeg)
+
+Click on a request to see details.
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-16/5f71589b-5fdd-4759-9b6e-e6874be0eb21/ascreenshot_92dd86dadccb4764b1169c29c10dfe65_text_export.jpeg)
+
+Filter by customer ID to see all requests for that customer.
+
+![](https://colony-recorder.s3.amazonaws.com/files/2026-01-16/dd1c8aba-e75b-4714-9eee-c785e9db99af/ascreenshot_36aaec0fe12f4189b64f704a551e6729_text_export.jpeg)
+
+## Supported Headers
+
+| Header | Description |
+|--------|-------------|
+| `x-litellm-customer-id` | Track by customer/end-user ID |
+| `x-litellm-end-user-id` | Alternative customer ID header |
+| `x-litellm-tags` | Comma-separated tags for cost attribution |
+
+## Related
+
+- [Claude Code Quickstart](./claude_responses_api.md)
+- [Customer Budgets](../proxy/customers.md)
+- [Tag Budgets](../proxy/tag_budgets.md)
+- [Track Usage for Coding Tools](./cost_tracking_coding.md)
+
--- a/docs/my-website/docs/tutorials/claude_code_plugin_marketplace.md
+++ 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
+
+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.
+
+<Image img={require('../../img/claude_code_marketplace/step1_navigate_plugins.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+### 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.
+
+<Image img={require('../../img/claude_code_marketplace/step3_plugins_list.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+### Step 3: Add a New Plugin
+
+Click **+ Add New Plugin** to register a plugin in your marketplace.
+
+<Image img={require('../../img/claude_code_marketplace/step4_add_plugin.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+### 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
+
+<Image img={require('../../img/claude_code_marketplace/step5_plugin_form.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+### Step 5: Submit the Plugin
+
+After filling in the details, click **Add Plugin** to register it.
+
+<Image img={require('../../img/claude_code_marketplace/step9_submit.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+### 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.
+
+<Image img={require('../../img/claude_code_marketplace/step11_enable_plugin.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+## 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
+```
+
+<Image img={require('../../img/claude_code_marketplace/step12_cli_marketplace.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+### 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
+```
+
+<Image img={require('../../img/claude_code_marketplace/step15_cli_paste.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+### Step 4: Verify Installation
+
+The plugin is now installed and ready to use:
+
+<Image img={require('../../img/claude_code_marketplace/step16_cli_complete.jpeg')} style={{ width: '800px', height: 'auto' }} />
+
+## 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
+
+<Tabs>
+<TabItem value="github" label="GitHub">
+
+```json
+{
+  "name": "my-plugin",
+  "source": {
+    "source": "github",
+    "repo": "organization/repository"
+  }
+}
+```
+
+</TabItem>
+<TabItem value="url" label="Git URL">
+
+```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.
+
+</TabItem>
+</Tabs>
+
+## 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. Share with Your Team
+
+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
--- a/docs/my-website/docs/tutorials/claude_code_websearch.md
+++ b/docs/my-website/docs/tutorials/claude_code_websearch.md
@ -0,0 +1,203 @@
+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.
+
+<Image img={require('../../img/claude_code_websearch.png')} />
+
+## Proxy Configuration
+
+Add WebSearch interception to your `litellm_config.yaml`:
+
+```yaml showLineNumbers title="litellm_config.yaml"
+model_list:
+  - model_name: bedrock-sonnet
+    litellm_params:
+      model: bedrock/us.anthropic.claude-sonnet-4-5-20250929-v1:0
+      aws_region_name: us-east-1
+
+# Enable WebSearch interception for providers
+litellm_settings:
+  callbacks:
+    - websearch_interception:
+        enabled_providers:
+          - bedrock
+          - azure
+          - vertex_ai
+        search_tool_name: perplexity-search  # Optional: specific search tool
+
+# Configure search provider
+search_tools:
+  - search_tool_name: perplexity-search
+    litellm_params:
+      search_provider: perplexity
+      api_key: os.environ/PERPLEXITY_API_KEY
+```
+
+## Quick Start
+
+### 1. Configure LiteLLM Proxy
+
+Create `config.yaml`:
+
+```yaml showLineNumbers title="config.yaml"
+model_list:
+  - model_name: bedrock-sonnet
+    litellm_params:
+      model: bedrock/us.anthropic.claude-sonnet-4-5-20250929-v1:0
+      aws_region_name: us-east-1
+
+litellm_settings:
+  callbacks:
+    - websearch_interception:
+        enabled_providers: [bedrock]
+
+search_tools:
+  - search_tool_name: perplexity-search
+    litellm_params:
+      search_provider: perplexity
+      api_key: os.environ/PERPLEXITY_API_KEY
+```
+
+### 2. Start Proxy
+
+```bash showLineNumbers title="Start LiteLLM Proxy"
+export PERPLEXITY_API_KEY=your-key
+litellm --config config.yaml
+```
+
+### 3. Use with Claude Code
+
+```bash showLineNumbers title="Configure Claude Code"
+export ANTHROPIC_BASE_URL=http://localhost:4000
+export ANTHROPIC_API_KEY=sk-1234
+claude
+```
+
+Now use web search in Claude Code - it works with any provider!
+
+## How It Works
+
+When Claude Code sends a web search request, LiteLLM:
+1. Intercepts the native `web_search` tool
+2. Converts it to LiteLLM's standard format
+3. Executes the search via Perplexity/Tavily
+4. Returns the final answer to Claude Code
+
+```mermaid
+sequenceDiagram
+    participant CC as Claude Code
+    participant LP as LiteLLM Proxy
+    participant B as Bedrock/Azure/etc
+    participant P as Perplexity/Tavily
+
+    CC->>LP: Request with web_search tool
+    Note over LP: Convert native tool<br/>to LiteLLM format
+    LP->>B: Request with converted tool
+    B-->>LP: Response: tool_use
+    Note over LP: Detect web search<br/>tool_use
+    LP->>P: Execute search
+    P-->>LP: Search results
+    LP->>B: Follow-up with results
+    B-->>LP: Final answer
+    LP-->>CC: Final answer with search results
+```
+
+**Result**: One API call from Claude Code → Complete answer with search results
+
+## Supported Providers
+
+| Provider | Native Web Search | With LiteLLM |
+|----------|-------------------|--------------|
+| **Anthropic** | ✅ Yes | ✅ Yes |
+| **Bedrock** | ❌ No | ✅ Yes |
+| **Azure** | ❌ No | ✅ Yes |
+| **Vertex AI** | ❌ No | ✅ Yes |
+| **Other Providers** | ❌ No | ✅ Yes |
+
+## Search Providers
+
+Configure which search provider to use. LiteLLM supports multiple search providers:
+
+| 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 detailed setup instructions and provider-specific parameters.
+
+## Configuration Options
+
+### WebSearch Interception Parameters
+
+| Parameter | Type | Required | Description | Example |
+|-----------|------|----------|-------------|---------|
+| `enabled_providers` | List[String] | Yes | List of providers to enable web search interception for | `[bedrock, azure, vertex_ai]` |
+| `search_tool_name` | String | No | Specific search tool from `search_tools` config. If not set, uses first available search tool. | `perplexity-search` |
+
+### Supported Provider Values
+
+Use these values in `enabled_providers`:
+
+| Provider | Value | Description |
+|----------|-------|-------------|
+| AWS Bedrock | `bedrock` | Amazon Bedrock Claude models |
+| Azure OpenAI | `azure` | Azure-hosted models |
+| Google Vertex AI | `vertex_ai` | Google Cloud Vertex AI |
+| Any Other | Provider name | Any LiteLLM-supported provider |
+
+### Complete Configuration Example
+
+```yaml showLineNumbers title="Complete config.yaml"
+model_list:
+  - model_name: bedrock-sonnet
+    litellm_params:
+      model: bedrock/us.anthropic.claude-sonnet-4-5-20250929-v1:0
+      aws_region_name: us-east-1
+
+  - model_name: azure-gpt4
+    litellm_params:
+      model: azure/gpt-4
+      api_base: https://my-azure.openai.azure.com
+      api_key: os.environ/AZURE_API_KEY
+
+litellm_settings:
+  callbacks:
+    - websearch_interception:
+        enabled_providers:
+          - bedrock        # Enable for AWS Bedrock
+          - azure          # Enable for Azure OpenAI
+          - vertex_ai      # Enable for Google Vertex
+        search_tool_name: perplexity-search  # Optional: use specific search tool
+
+# Configure search tools
+search_tools:
+  - search_tool_name: perplexity-search
+    litellm_params:
+      search_provider: perplexity
+      api_key: os.environ/PERPLEXITY_API_KEY
+
+  - search_tool_name: tavily-search
+    litellm_params:
+      search_provider: tavily
+      api_key: os.environ/TAVILY_API_KEY
+```
+
+**How search tool selection works:**
+- If `search_tool_name` is specified → Uses that specific search tool
+- If `search_tool_name` is not specified → Uses first search tool in `search_tools` list
+- In example above: Without `search_tool_name`, would use `perplexity-search` (first in list)
+
+## Related
+
+- [Claude Code Quickstart](./claude_responses_api.md)
+- [Claude Code Cost Tracking](./claude_code_customer_tracking.md)
+- [Using Non-Anthropic Models](./claude_non_anthropic_models.md)
--- a/docs/my-website/docs/tutorials/claude_mcp.md
+++ b/docs/my-website/docs/tutorials/claude_mcp.md
@ -0,0 +1,93 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Use Claude Code with MCPs
+
+This tutorial shows how to connect MCP servers to Claude Code via LiteLLM Proxy.
+
+Note: LiteLLM supports OAuth for MCP servers as well. [Learn more](https://docs.litellm.ai/docs/mcp#mcp-oauth)
+
+## Connecting MCP Servers
+
+You can also connect MCP servers to Claude Code via LiteLLM Proxy.
+
+
+1. Add the MCP server to your `config.yaml`
+
+<Tabs>
+<TabItem value="github" label="GitHub MCP">
+
+In this example, we'll add the Github MCP server to our `config.yaml`
+
+```yaml title="config.yaml" showLineNumbers
+mcp_servers:
+  github_mcp:
+    url: "https://api.githubcopilot.com/mcp"
+    auth_type: oauth2
+    client_id: os.environ/GITHUB_OAUTH_CLIENT_ID
+    client_secret: os.environ/GITHUB_OAUTH_CLIENT_SECRET
+```
+
+</TabItem>
+<TabItem value="atlassian" label="Atlassian MCP">
+
+In this example, we'll add the Atlassian MCP server to our `config.yaml`
+
+```yaml title="config.yaml" showLineNumbers
+atlassian_mcp:
+  server_id: atlassian_mcp_id
+  url: "https://mcp.atlassian.com/v1/sse"
+  transport: "sse"
+  auth_type: oauth2
+```
+
+</TabItem>
+</Tabs>
+
+2. Start LiteLLM Proxy
+
+```bash
+litellm --config /path/to/config.yaml
+
+# RUNNING on http://0.0.0.0:4000
+```
+
+3. Use the MCP server in Claude Code
+
+```bash
+claude mcp add --transport http litellm_proxy http://0.0.0.0:4000/github_mcp/mcp --header "Authorization: Bearer sk-LITELLM_VIRTUAL_KEY"
+```
+
+For MCP servers that require dynamic client registration (such as Atlassian), please set `x-litellm-api-key: Bearer sk-LITELLM_VIRTUAL_KEY` instead of using `Authorization: Bearer LITELLM_VIRTUAL_KEY`.
+
+4. Authenticate via Claude Code
+
+a. Start Claude Code
+
+```bash
+claude
+```
+
+b. Authenticate via Claude Code
+
+```bash
+/mcp
+```
+
+c. Select the MCP server
+
+```bash
+> litellm_proxy
+```
+
+d. Start Oauth flow via Claude Code
+
+```bash
+> 1. Authenticate
+ 2. Reconnect
+ 3. Disable             
+```
+
+e. Once completed, you should see this success message:
+
+<img src={require('../../img/oauth_2_success.png').default} alt="OAuth 2.0 Success" style={{ width: '500px', height: 'auto' }} />
--- a/docs/my-website/docs/tutorials/claude_non_anthropic_models.md
+++ b/docs/my-website/docs/tutorials/claude_non_anthropic_models.md
@ -0,0 +1,316 @@
+import Image from '@theme/IdealImage';
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Use Claude Code with Non-Anthropic Models
+
+This tutorial shows how to use Claude Code with non-Anthropic models like OpenAI, Gemini, and other LLM providers through LiteLLM proxy.
+
+:::info 
+
+LiteLLM automatically translates between different provider formats, allowing you to use any supported LLM provider with Claude Code while maintaining the Anthropic Messages API format.
+
+:::
+
+## Prerequisites
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) installed
+- API keys for your chosen providers (OpenAI, Vertex AI, etc.)
+
+## Installation
+
+First, install LiteLLM with proxy support:
+
+```bash
+pip install 'litellm[proxy]'
+```
+
+## Configuration
+
+### 1. Setup config.yaml
+
+Create a configuration file with your preferred non-Anthropic models:
+
+<Tabs>
+<TabItem value="openai" label="OpenAI">
+
+```yaml
+model_list:
+  # OpenAI GPT-4o
+  - model_name: gpt-4o
+    litellm_params:
+      model: openai/gpt-4o
+      api_key: os.environ/OPENAI_API_KEY
+  
+  # OpenAI GPT-4o-mini
+  - model_name: gpt-4o-mini
+    litellm_params:
+      model: openai/gpt-4o-mini
+      api_key: os.environ/OPENAI_API_KEY
+```
+
+Set your environment variables:
+
+```bash
+export OPENAI_API_KEY="your-openai-api-key"
+export LITELLM_MASTER_KEY="sk-1234567890"  # Generate a secure key
+```
+
+</TabItem>
+<TabItem value="gemini" label="Google AI Studio">
+
+```yaml
+model_list:
+  # Google Gemini
+  - model_name: gemini-3.0-flash-exp
+    litellm_params:
+      model: gemini/gemini-3.0-flash-exp
+      api_key: os.environ/GEMINI_API_KEY
+```
+
+Set your environment variables:
+
+```bash
+export GEMINI_API_KEY="your-gemini-api-key"
+export LITELLM_MASTER_KEY="sk-1234567890"  # Generate a secure key
+```
+
+</TabItem>
+<TabItem value="vertex_ai" label="Vertex AI">
+
+```yaml
+model_list:
+  # Google Gemini
+  - model_name: vertex-gemini-3-flash-preview
+    litellm_params:
+      model: vertex_ai/gemini-3-flash-preview
+      vertex_credentials: os.environ/VERTEX_FILE_PATH_ENV_VAR # os.environ["VERTEX_FILE_PATH_ENV_VAR"] = "/path/to/service_account.json" 
+      vertex_project: "my-test-project"
+      vertex_location: "us-east-1"
+
+  # Anthropic Claude
+  - model_name: anthropic-vertex
+    litellm_params:
+      model: vertex_ai/claude-3-sonnet@20240229
+      vertex_ai_project: "my-test-project"
+      vertex_ai_location: "us-east-1"
+      vertex_credentials: os.environ/VERTEX_FILE_PATH_ENV_VAR # os.environ["VERTEX_FILE_PATH_ENV_VAR"] = "/path/to/service_account.json" 
+```
+
+Set your environment variables:
+
+```bash
+export VERTEX_FILE_PATH_ENV_VAR="/path/to/service_account.json"
+export LITELLM_MASTER_KEY="sk-1234567890"  
+```
+
+</TabItem>
+<TabItem value="multi" label="Azure OpenAI">
+
+```yaml
+model_list:
+  # Azure OpenAI
+  - model_name: azure-gpt-4
+    litellm_params:
+      model: azure/gpt-4
+      api_key: os.environ/AZURE_API_KEY
+      api_base: os.environ/AZURE_API_BASE
+      api_version: "2024-02-01"
+```
+
+Set your environment variables:
+
+```bash
+export AZURE_API_KEY="your-azure-api-key"
+export AZURE_API_BASE="https://your-resource.openai.azure.com"
+export LITELLM_MASTER_KEY="sk-1234567890"
+```
+
+</TabItem>
+</Tabs>
+
+### 2. Start LiteLLM Proxy
+
+```bash
+litellm --config /path/to/config.yaml
+
+# RUNNING on http://0.0.0.0:4000
+```
+
+### 3. Verify Setup
+
+Test that your proxy is working correctly:
+
+<Tabs>
+<TabItem value="openai-test" label="OpenAI">
+
+```bash
+curl -X POST http://0.0.0.0:4000/v1/messages \
+-H "Authorization: Bearer $LITELLM_MASTER_KEY" \
+-H "Content-Type: application/json" \
+-d '{
+    "model": "gpt-4o",
+    "max_tokens": 1000,
+    "messages": [{"role": "user", "content": "What is the capital of France?"}]
+}'
+```
+
+</TabItem>
+<TabItem value="gemini-test" label="Google AI Studio">
+
+```bash
+curl -X POST http://0.0.0.0:4000/v1/messages \
+-H "Authorization: Bearer $LITELLM_MASTER_KEY" \
+-H "Content-Type: application/json" \
+-d '{
+    "model": "gemini-3.0-flash-exp",
+    "max_tokens": 1000,
+    "messages": [{"role": "user", "content": "What is the capital of France?"}]
+}'
+```
+
+</TabItem>
+<TabItem value="vertex-test" label="Vertex AI">
+
+```bash
+curl -X POST http://0.0.0.0:4000/v1/messages \
+-H "Authorization: Bearer $LITELLM_MASTER_KEY" \
+-H "Content-Type: application/json" \
+-d '{
+    "model": "gemini-3.0-flash-exp",
+    "max_tokens": 1000,
+    "messages": [{"role": "user", "content": "What is the capital of France?"}]
+}'
+```
+
+</TabItem>
+<TabItem value="azure-test" label="Azure OpenAI">
+
+```bash
+curl -X POST http://0.0.0.0:4000/v1/messages \
+-H "Authorization: Bearer $LITELLM_MASTER_KEY" \
+-H "Content-Type: application/json" \
+-d '{
+    "model": "azure-gpt-4",
+    "max_tokens": 1000,
+    "messages": [{"role": "user", "content": "What is the capital of France?"}]
+}'
+```
+
+</TabItem>
+</Tabs>
+
+### 4. Configure Claude Code
+
+Configure Claude Code to use your LiteLLM proxy:
+
+```bash
+export ANTHROPIC_BASE_URL="http://0.0.0.0:4000"
+export ANTHROPIC_AUTH_TOKEN="$LITELLM_MASTER_KEY"
+```
+
+:::tip
+The `LITELLM_MASTER_KEY` gives Claude Code access to all proxy models. You can also create virtual keys in the LiteLLM UI to limit access to specific models.
+:::
+
+### 5. Use Claude Code with Non-Anthropic Models
+
+Start Claude Code and specify which model to use:
+
+```bash
+# Use OpenAI GPT-4o
+claude --model gpt-4o
+
+# Use OpenAI GPT-4o-mini for faster responses
+claude --model gpt-4o-mini
+
+# Use Google Gemini
+claude --model gemini-3.0-flash-exp
+
+# Use Vertex AI Gemini
+claude --model vertex-gemini-3-flash-preview
+
+# Use Vertex AI Anthropic Claude
+claude --model anthropic-vertex
+
+# Use Azure OpenAI
+claude --model azure-gpt-4
+```
+
+## How It Works
+
+LiteLLM acts as a unified interface that:
+
+1. **Receives requests** from Claude Code in Anthropic Messages API format
+2. **Translates** the request to the target provider's format (OpenAI, Gemini, etc.)
+3. **Forwards** the request to the actual provider
+4. **Translates** the response back to Anthropic Messages API format
+5. **Returns** the response to Claude Code
+
+This allows you to use Claude Code's interface with any LLM provider supported by LiteLLM.
+
+## Advanced Features
+
+### Load Balancing and Fallbacks
+
+Configure multiple deployments with automatic fallback:
+
+```yaml
+model_list:
+  - model_name: gpt-4o  # virtual model name
+    litellm_params:
+      model: openai/gpt-4o
+      api_key: os.environ/OPENAI_API_KEY
+  
+  - model_name: gpt-4o  # same virtual name
+    litellm_params:
+      model: azure/gpt-4o
+      api_key: os.environ/AZURE_API_KEY
+      api_base: os.environ/AZURE_API_BASE
+
+router_settings:
+  routing_strategy: simple-shuffle  # Load balance between deployments
+  num_retries: 2
+  timeout: 30
+```
+
+### Usage Tracking and Budgets
+
+Track usage and set budgets through the LiteLLM UI:
+
+```yaml
+litellm_settings:
+  master_key: os.environ/LITELLM_MASTER_KEY
+  database_url: "postgresql://..."  # Enable database for tracking
+  
+general_settings:
+  store_model_in_db: true
+```
+
+Start the proxy with the UI:
+
+```bash
+litellm --config /path/to/config.yaml --detailed_debug
+```
+
+Access the UI at `http://0.0.0.0:4000/ui` to:
+- View usage analytics
+- Set budget limits per user/key
+- Monitor costs across different providers
+- Create virtual keys with specific permissions
+
+
+## Supported Providers
+
+LiteLLM supports 100+ providers. Here are some popular ones for use with Claude Code:
+
+- **OpenAI**: GPT-4o, GPT-4o-mini, o1, o3-mini
+- **Google**: Gemini 2.0 Flash, Gemini 1.5 Pro/Flash
+- **Azure OpenAI**: All OpenAI models via Azure
+- **AWS Bedrock**: Llama, Mistral, and other models
+- **Vertex AI**: Gemini, Claude, and other models on Google Cloud
+- **Groq**: Fast inference for Llama and Mixtral
+- **Together AI**: Llama, Mixtral, and other open source models
+- **Deepseek**: Deepseek-chat, Deepseek-coder
+
+[View full list of supported providers →](https://docs.litellm.ai/docs/providers)
--- a/docs/my-website/docs/tutorials/claude_responses_api.md
+++ b/docs/my-website/docs/tutorials/claude_responses_api.md
@ -2,7 +2,7 @@ import Image from '@theme/IdealImage';
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';

-# Claude Code
+# Claude Code Quickstart

 This tutorial shows how to call Claude models through LiteLLM proxy from Claude Code.

@ -142,7 +142,7 @@ Common issues and solutions:
 - Ensure the model name in Claude Code matches exactly with your `config.yaml`
 - Check LiteLLM logs for detailed error messages

-## Using Multiple Models
+## Using Bedrock/Vertex AI/Azure Foundry Models

 Expand your configuration to support multiple providers and models:

@ -151,25 +151,6 @@ Expand your configuration to support multiple providers and models:

 ```yaml
 model_list:
-  # OpenAI models
-  - model_name: codex-mini
-    litellm_params:  
-      model: openai/codex-mini
-      api_key: os.environ/OPENAI_API_KEY
-      api_base: https://api.openai.com/v1
-
-  - model_name: o3-pro
-    litellm_params:
-      model: openai/o3-pro
-      api_key: os.environ/OPENAI_API_KEY
-      api_base: https://api.openai.com/v1
-
-  - model_name: gpt-4o
-    litellm_params:
-      model: openai/gpt-4o
-      api_key: os.environ/OPENAI_API_KEY
-      api_base: https://api.openai.com/v1
-
  # Anthropic models
  - model_name: claude-3-5-sonnet-20241022
    litellm_params:
@ -189,6 +170,24 @@ model_list:
      aws_secret_access_key: os.environ/AWS_SECRET_ACCESS_KEY
      aws_region_name: us-east-1

+  # Azure Foundry
+  - model_name: claude-4-azure
+    litellm_params:
+      model: azure_ai/claude-opus-4-1
+      api_key: os.environ/AZURE_AI_API_KEY
+      api_base: os.environ/AZURE_AI_API_BASE # https://my-resource.services.ai.azure.com/anthropic
+
+  # Google Vertex AI
+  - model_name: anthropic-vertex
+    litellm_params:
+      model: vertex_ai/claude-haiku-4-5@20251001
+      vertex_ai_project: "my-test-project"
+      vertex_ai_location: "us-east-1"
+      vertex_credentials: os.environ/VERTEX_FILE_PATH_ENV_VAR # os.environ["VERTEX_FILE_PATH_ENV_VAR"] = "/path/to/service_account.json" 
+
+
+
+
 litellm_settings:
  master_key: os.environ/LITELLM_MASTER_KEY
 ```
@ -204,6 +203,12 @@ claude --model claude-3-5-haiku-20241022

 # Use Bedrock deployment
 claude --model claude-bedrock
+
+# Use Azure Foundry deployment
+claude --model claude-4-azure
+
+# Use Vertex AI deployment
+claude --model anthropic-vertex
 ```

 </TabItem>
@ -211,96 +216,3 @@ claude --model claude-bedrock

 <Image img={require('../../img/release_notes/claude_code_demo.png')} style={{ width: '500px', height: 'auto' }} />

-
-## Connecting MCP Servers
-
-You can also connect MCP servers to Claude Code via LiteLLM Proxy.
-
-:::note
-
-Limitations:
-
- Currently, only HTTP MCP servers are supported
-
-:::
-
-1. Add the MCP server to your `config.yaml`
-
-<Tabs>
-<TabItem value="github" label="GitHub MCP">
-
-In this example, we'll add the Github MCP server to our `config.yaml`
-
-```yaml title="config.yaml" showLineNumbers
-mcp_servers:
-  github_mcp:
-    url: "https://api.githubcopilot.com/mcp"
-    auth_type: oauth2
-    client_id: os.environ/GITHUB_OAUTH_CLIENT_ID
-    client_secret: os.environ/GITHUB_OAUTH_CLIENT_SECRET
-```
-
-</TabItem>
-<TabItem value="atlassian" label="Atlassian MCP">
-
-In this example, we'll add the Atlassian MCP server to our `config.yaml`
-
-```yaml title="config.yaml" showLineNumbers
-atlassian_mcp:
-  server_id: atlassian_mcp_id
-  url: "https://mcp.atlassian.com/v1/sse"
-  transport: "sse"
-  auth_type: oauth2
-```
-
-</TabItem>
-</Tabs>
-
-2. Start LiteLLM Proxy
-
-```bash
-litellm --config /path/to/config.yaml
-
-# RUNNING on http://0.0.0.0:4000
-```
-
-3. Use the MCP server in Claude Code
-
-```bash
-claude mcp add --transport http litellm_proxy http://0.0.0.0:4000/github_mcp/mcp --header "Authorization: Bearer sk-LITELLM_VIRTUAL_KEY"
-```
-
-For MCP servers that require dynamic client registration (such as Atlassian), please set `x-litellm-api-key: Bearer sk-LITELLM_VIRTUAL_KEY` instead of using `Authorization: Bearer LITELLM_VIRTUAL_KEY`.
-
-4. Authenticate via Claude Code
-
-a. Start Claude Code
-
-```bash
-claude
-```
-
-b. Authenticate via Claude Code
-
-```bash
-/mcp
-```
-
-c. Select the MCP server
-
-```bash
-> litellm_proxy
-```
-
-d. Start Oauth flow via Claude Code
-
-```bash
-> 1. Authenticate
- 2. Reconnect
- 3. Disable             
-```
-
-e. Once completed, you should see this success message:
-
-<Image img={require('../../img/oauth_2_success.png')} style={{ width: '500px', height: 'auto' }} />
-
--- 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.
+
+<Image img={require('../../img/cursor_mcp_installed.png')} />
+
 ## Troubleshooting

 | Issue | Solution |
--- a/docs/my-website/img/claude_code_marketplace/step10_plugin_added.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step10_plugin_added.jpeg
--- a/docs/my-website/img/claude_code_marketplace/step11_enable_plugin.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step11_enable_plugin.jpeg
--- a/docs/my-website/img/claude_code_marketplace/step12_cli_marketplace.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step12_cli_marketplace.jpeg
--- a/docs/my-website/img/claude_code_marketplace/step13_cli_add.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step13_cli_add.jpeg
--- a/docs/my-website/img/claude_code_marketplace/step14_cli_enter.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step14_cli_enter.jpeg
--- a/docs/my-website/img/claude_code_marketplace/step15_cli_paste.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step15_cli_paste.jpeg
--- a/docs/my-website/img/claude_code_marketplace/step16_cli_complete.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step16_cli_complete.jpeg
--- a/docs/my-website/img/claude_code_marketplace/step1_navigate_plugins.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step1_navigate_plugins.jpeg
--- a/docs/my-website/img/claude_code_marketplace/step2_click_plugins.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step2_click_plugins.jpeg
--- a/docs/my-website/img/claude_code_marketplace/step3_plugins_list.jpeg
+++ b/docs/my-website/img/claude_code_marketplace/step3_plugins_list.jpeg
--- a/Show more
+++ b/Show more