Zum Hauptinhalt springen

✨ Enterprise Features

Tipp

Um eine Lizenz zu erhalten, nehmen Sie hier mit uns Kontakt auf.

Funktionen

Sicherheit​

Audit-Protokolle​

Speichern von Audit-Protokollen für Erstellungs-, Aktualisierungs- und Löschvorgänge, die an Teams und Virtuellen Schlüsseln durchgeführt wurden

Schritt 1 Audit-Protokolle aktivieren

litellm_settings:
  store_audit_logs: true

Starten Sie den LiteLLM-Proxy mit dieser Konfiguration

Schritt 2 Testen Sie es - Erstellen Sie ein Team

curl --location 'http://0.0.0.0:4000/team/new' \
    --header 'Authorization: Bearer sk-1234' \
    --header 'Content-Type: application/json' \
    --data '{
        "max_budget": 2
    }'

Schritt 3 Erwartetes Protokoll

{
 "id": "e1760e10-4264-4499-82cd-c08c86c8d05b",
 "updated_at": "2024-06-06T02:10:40.836420+00:00",
 "changed_by": "109010464461339474872",
 "action": "created",
 "table_name": "LiteLLM_TeamTable",
 "object_id": "82e725b5-053f-459d-9a52-867191635446",
 "before_value": null,
 "updated_values": {
   "team_id": "82e725b5-053f-459d-9a52-867191635446",
   "admins": [],
   "members": [],
   "members_with_roles": [
     {
       "role": "admin",
       "user_id": "109010464461339474872"
     }
   ],
   "max_budget": 2.0,
   "models": [],
   "blocked": false
 }
}

Web-Crawler blockieren​

Um zu verhindern, dass Web-Crawler die Endpunkte des Proxy-Servers indizieren, setzen Sie die Einstellung block_robots auf true in Ihrer litellm_config.yaml-Datei.

litellm_config.yaml
general_settings:
  block_robots: true

Wie es funktioniert​

Wenn dies aktiviert ist, gibt der Endpunkt /robots.txt einen 200-Statuscode mit dem folgenden Inhalt zurück:

robots.txt
User-agent: *
Disallow: /

Erforderliche Parameter für LLM-Anfragen​

Verwenden Sie dies, wenn Sie erzwingen möchten, dass alle Anfragen bestimmte Parameter enthalten. Beispiel: Sie benötigen, dass alle Anfragen die Parameter user und ["metadata"]["generation_name"] enthalten.

Schritt 1 Alle Parameter definieren, die Sie in der Konfiguration erzwingen möchten

Dies bedeutet, dass ["user"] und ["metadata"]["generation_name"] in allen LLM-Anfragen an LiteLLM erforderlich sind.

general_settings:
  master_key: sk-1234
  enforced_params:  
    - user
    - metadata.generation_name

Schritt 2 Überprüfen Sie, ob dies funktioniert

curl --location 'https://:4000/chat/completions' \
    --header 'Authorization: Bearer sk-5fmYeaUEbAMpwBNT-QpxyA' \
    --header 'Content-Type: application/json' \
    --data '{
    "model": "gpt-3.5-turbo",
    "messages": [
        {
        "role": "user",
        "content": "hi"
        }
    ]
}'

Erwartete Antwort

{"error":{"message":"Authentication Error, BadRequest please pass param=user in request body. This is a required param","type":"auth_error","param":"None","code":401}}%

Verfügbare öffentliche, private Routen steuern​

Bestimmte Endpunkte des Proxys einschränken

Info

❓ Verwenden Sie dies, wenn Sie:

  • eine vorhandene private Route -> öffentlich machen möchten
  • bestimmte Routen als Admin-only-Routen festlegen möchten

Verwendung - Öffentliche, Admin-only-Routen definieren​

Schritt 1 - In config.yaml festlegen

RoutentypOptionalBenötigt virtuelle SchlüsselauthentifizierungAdmin kann zugreifenAlle Rollen können zugreifenBeschreibung
public_routes✅❌✅✅Routen, auf die ohne Authentifizierung zugegriffen werden kann
admin_only_routes✅✅✅❌Routen, auf die nur von einem Proxy-Administrator zugegriffen werden kann
allowed_routes✅✅✅✅Routen, die auf dem Proxy verfügbar sind. Wenn nicht gesetzt, sind alle Routen verfügbar.

LiteLLMRoutes.public_routes ist eine ENUM, die den Standard-öffentlichen Routen in LiteLLM entspricht. Sie können dies hier sehen

general_settings:
  master_key: sk-1234
  public_routes: ["LiteLLMRoutes.public_routes", "/spend/calculate"]     # routes that can be accessed without any auth
  admin_only_routes: ["/key/generate"]  # Optional - routes that can only be accessed by Proxy Admin
  allowed_routes: ["/chat/completions", "/spend/calculate", "LiteLLMRoutes.public_routes"] # Optional - routes that can be accessed by anyone after Authentication

Schritt 2 - Proxy starten

litellm --config config.yaml

Schritt 3 - Testen

curl --request POST \
  --url 'https://:4000/spend/calculate' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "gpt-4",
    "messages": [{"role": "user", "content": "Hey, how'\''s it going?"}]
  }'

🎉 Erwarten Sie, dass dieser Endpunkt ohne Autorisierung / Bearer-Token funktioniert

Ausgabenverfolgung​

Benutzerdefinierte Tags​

Anforderungen

Verwendung - /chat/completions-Anfragen mit Anfrage-Tags​

curl -L -X POST 'http://0.0.0.0:4000/key/generate' \
-H 'Authorization: Bearer sk-1234' \
-H 'Content-Type: application/json' \
-d '{
    "metadata": {
        "tags": ["tag1", "tag2", "tag3"]
    }
}

'

Ausgaben pro Tag anzeigen​

/spend/tags Anfrageformat​

curl -X GET "http://0.0.0.0:4000/spend/tags" \
-H "Authorization: Bearer sk-1234"

/spend/tagsAntwortformat​

[
  {
    "individual_request_tag": "model-anthropic-claude-v2.1",
    "log_count": 6,
    "total_spend": 0.000672
  },
  {
    "individual_request_tag": "app-ishaan-local",
    "log_count": 4,
    "total_spend": 0.000448
  },
  {
    "individual_request_tag": "app-ishaan-prod",
    "log_count": 2,
    "total_spend": 0.000224
  }
]

Ausgaben mit benutzerdefinierten Metadaten verfolgen​

Anforderungen

Verwendung - /chat/completions-Anfragen mit speziellen Ausgabenprotokoll-Metadaten​

curl -L -X POST 'http://0.0.0.0:4000/key/generate' \
-H 'Authorization: Bearer sk-1234' \
-H 'Content-Type: application/json' \
-d '{
    "metadata": {
      "spend_logs_metadata": {
          "hello": "world"
      }
    }
}

'

Ausgaben mit benutzerdefinierten Metadaten anzeigen​

/spend/logs Anfrageformat​

curl -X GET "http://0.0.0.0:4000/spend/logs?request_id=<your-call-id" \ # e.g.: chatcmpl-9ZKMURhVYSi9D6r6PJ9vLcayIK0Vm
-H "Authorization: Bearer sk-1234"

/spend/logs Antwortformat​

[
    {
        "request_id": "chatcmpl-9ZKMURhVYSi9D6r6PJ9vLcayIK0Vm",
        "call_type": "acompletion",
        "metadata": {
            "user_api_key": "88dc28d0f030c55ed4ab77ed8faf098196cb1c05df778539800c9f1243fe6b4b",
            "user_api_key_alias": null,
            "spend_logs_metadata": { # 👈 LOGGED CUSTOM METADATA
                "hello": "world"
            },
            "user_api_key_team_id": null,
            "user_api_key_user_id": "116544810872468347480",
            "user_api_key_team_alias": null
        },
    }
]

Guardrails - Geheimniserkennung/Redaktion​

❓ Verwenden Sie dies, um API-Schlüssel und Geheimnisse, die in Anfragen an ein LLM gesendet werden, zu REDAKTIEREN.

Beispiel: Wenn Sie den Wert von OPENAI_API_KEY in der folgenden Anfrage redigieren möchten

Eingehende Anfrage​

{
    "messages": [
        {
            "role": "user",
            "content": "Hey, how's it going, API_KEY = 'sk_1234567890abcdef'",
        }
    ]
}

Anfrage nach Moderation​

{
    "messages": [
        {
            "role": "user",
            "content": "Hey, how's it going, API_KEY = '[REDACTED]'",
        }
    ]
}

Verwendung

Schritt 1 Fügen Sie dies zu Ihrer config.yaml hinzu

litellm_settings:
  callbacks: ["hide_secrets"]

Schritt 2 Führen Sie den LiteLLM-Proxy mit --detailed_debug aus, um die Serverprotokolle anzuzeigen

litellm --config config.yaml --detailed_debug

Schritt 3 Testen Sie es mit einer Anfrage

Senden Sie diese Anfrage

curl --location 'https://:4000/chat/completions' \
    --header 'Authorization: Bearer sk-1234' \
    --header 'Content-Type: application/json' \
    --data '{
    "model": "llama3",
    "messages": [
        {
        "role": "user",
        "content": "what is the value of my open ai key? openai_api_key=sk-1234998222"
        }
    ]
}'

Erwarten Sie eine Warnung in Ihren LiteLLM-Serverprotokollen

LiteLLM Proxy:WARNING: secret_detection.py:88 - Detected and redacted secrets in message: ['Secret Keyword']

Sie können auch die Rohdaten der vom LiteLLM an den API-Anbieter gesendeten Anfrage sehen

POST Request Sent from LiteLLM:
curl -X POST \
https://api.groq.com/openai/v1/ \
-H 'Authorization: Bearer gsk_mySVchjY********************************************' \
-d {
  "model": "llama3-8b-8192",
  "messages": [
    {
      "role": "user",
      "content": "what is the time today, openai_api_key=[REDACTED]"
    }
  ],
  "stream": false,
  "extra_body": {}
}

Geheimniserkennung Ein/Aus pro API-Schlüssel​

❓ Verwenden Sie dies, wenn Sie Guardrails pro API-Schlüssel ein-/ausschalten müssen

Schritt 1 Schlüssel mit deaktivierter hide_secrets erstellen

👉 Setzen Sie "permissions": {"hide_secrets": false} entweder mit /key/generate oder /key/update

Dies bedeutet, dass die hide_secrets-Guardrail für alle Anfragen von diesem API-Schlüssel deaktiviert ist.

curl --location 'http://0.0.0.0:4000/key/generate' \
    --header 'Authorization: Bearer sk-1234' \
    --header 'Content-Type: application/json' \
    --data '{
        "permissions": {"hide_secrets": false}
}'
# {"permissions":{"hide_secrets":false},"key":"sk-jNm1Zar7XfNdZXp49Z1kSQ"}

Schritt 2 Mit neuem Schlüssel testen

curl --location 'http://0.0.0.0:4000/chat/completions' \
    --header 'Authorization: Bearer sk-jNm1Zar7XfNdZXp49Z1kSQ' \
    --header 'Content-Type: application/json' \
    --data '{
    "model": "llama3",
    "messages": [
        {
        "role": "user",
        "content": "does my openai key look well formatted OpenAI_API_KEY=sk-1234777"
        }
    ]
}'

Erwarten Sie, sk-1234777 in Ihren Serverprotokollen bei Ihrem Rückruf zu sehen.

Info

Die hide_secrets-Guardrail-Prüfung wurde für diese Anfrage nicht durchgeführt, da der API-Schlüssel=sk-jNm1Zar7XfNdZXp49Z1kSQ "permissions": {"hide_secrets": false} hat.

Inhaltsmoderation​

Inhaltsmoderation mit LLM Guard​

Legen Sie die LLM Guard API-Basis in Ihrer Umgebung fest

LLM_GUARD_API_BASE = "http://0.0.0.0:8192" # deployed llm guard api

Fügen Sie llmguard_moderations als Rückruf hinzu

litellm_settings:
    callbacks: ["llmguard_moderations"]

Jetzt können Sie es einfach testen

  • Einen regulären /chat/completion-Aufruf tätigen

  • Überprüfen Sie Ihre Proxy-Protokolle auf Aussagen mit LLM Guard:

Erwartete Ergebnisse

LLM Guard: Received response - {"sanitized_prompt": "hello world", "is_valid": true, "scanners": { "Regex": 0.0 }}

Pro Schlüssel ein-/ausschalten​

1. Konfiguration aktualisieren

litellm_settings:
    callbacks: ["llmguard_moderations"]
    llm_guard_mode: "key-specific"

2. Neuen Schlüssel erstellen

curl --location 'https://:4000/key/generate' \
--header 'Authorization: Bearer sk-1234' \
--header 'Content-Type: application/json' \
--data '{
    "models": ["fake-openai-endpoint"],
    "permissions": {
        "enable_llm_guard_check": true # 👈 KEY CHANGE
    }
}'

# Returns {..'key': 'my-new-key'}

3. Testen!

curl --location 'http://0.0.0.0:4000/v1/chat/completions' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer my-new-key' \ # 👈 TEST KEY
--data '{"model": "fake-openai-endpoint", "messages": [
        {"role": "system", "content": "Be helpful"},
        {"role": "user", "content": "What do you know?"}
    ]
    }'

Pro Anfrage ein-/ausschalten​

1. Konfiguration aktualisieren

litellm_settings:
    callbacks: ["llmguard_moderations"]
    llm_guard_mode: "request-specific"

2. Neuen Schlüssel erstellen

curl --location 'https://:4000/key/generate' \
--header 'Authorization: Bearer sk-1234' \
--header 'Content-Type: application/json' \
--data '{
    "models": ["fake-openai-endpoint"],
}'

# Returns {..'key': 'my-new-key'}

3. Testen!

import openai
client = openai.OpenAI(
    api_key="sk-1234",
    base_url="http://0.0.0.0:4000"
)

# request sent to model set on litellm proxy, `litellm --model`
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages = [
        {
            "role": "user",
            "content": "this is a test request, write a short poem"
        }
    ],
    extra_body={ # pass in any provider-specific param, if not supported by openai, https://docs.litellm.de/docs/completion/input#provider-specific-params
        "metadata": {
            "permissions": {
                "enable_llm_guard_check": True # 👈 KEY CHANGE
            },
        }
    }
)

print(response)

Inhaltsmoderation mit LlamaGuard​

Funktioniert derzeit mit dem LlamaGuard-Endpunkt von Sagemaker.

Wie Sie dies in Ihrer config.yaml aktivieren

litellm_settings:
   callbacks: ["llamaguard_moderations"]
   llamaguard_model_name: "sagemaker/jumpstart-dft-meta-textgeneration-llama-guard-7b"

Stellen Sie sicher, dass Sie die relevanten Schlüssel in Ihrer Umgebung haben, z. B.

os.environ["AWS_ACCESS_KEY_ID"] = ""
os.environ["AWS_SECRET_ACCESS_KEY"] = ""
os.environ["AWS_REGION_NAME"] = ""

LlamaGuard-Prompt anpassen​

Um die unsicheren Kategorien, gegen die Llama Guard bewertet, zu ändern, erstellen Sie einfach Ihre eigene Version von dieser Kategorieliste

Verweisen Sie Ihren Proxy darauf

callbacks: ["llamaguard_moderations"]
  llamaguard_model_name: "sagemaker/jumpstart-dft-meta-textgeneration-llama-guard-7b"
  llamaguard_unsafe_content_categories: /path/to/llamaguard_prompt.txt

Inhaltsmoderation mit Google Text Moderation​

Erfordert, dass Ihre GOOGLE_APPLICATION_CREDENTIALS in Ihrem .env gesetzt sind (wie bei VertexAI).

Wie Sie dies in Ihrer config.yaml aktivieren

litellm_settings:
   callbacks: ["google_text_moderation"]

Benutzerdefinierte Konfidenzschwellenwerte festlegen​

Google Moderations prüft den Test anhand mehrerer Kategorien. Quelle

Globalen Standard-Konfidenzschwellenwert festlegen​

Standardmäßig ist dieser auf 0.8 eingestellt. Sie können dies jedoch in Ihrer config.yaml überschreiben.

litellm_settings: 
    google_moderation_confidence_threshold: 0.4

Kategorie-spezifischen Konfidenzschwellenwert festlegen​

Legen Sie einen kategorie-spezifischen Konfidenzschwellenwert in Ihrer config.yaml fest. Wenn keiner festgelegt ist, wird der globale Standard verwendet.

litellm_settings: 
    toxic_confidence_threshold: 0.1

Hier sind die kategorie-spezifischen Werte

KategorieEinstellung
"toxic"toxic_confidence_threshold: 0.1
"insult"insult_confidence_threshold: 0.1
"profanity"profanity_confidence_threshold: 0.1
"derogatory"derogatory_confidence_threshold: 0.1
"sexual"sexual_confidence_threshold: 0.1
"death_harm_and_tragedy"death_harm_and_tragedy_threshold: 0.1
"violent"violent_threshold: 0.1
"firearms_and_weapons"firearms_and_weapons_threshold: 0.1
"public_safety"public_safety_threshold: 0.1
"health"health_threshold: 0.1
"religion_and_belief"religion_and_belief_threshold: 0.1
"illicit_drugs"illicit_drugs_threshold: 0.1
"war_and_conflict"war_and_conflict_threshold: 0.1
"politics"politics_threshold: 0.1
"finance"finance_threshold: 0.1
"legal"legal_threshold: 0.1

Swagger Docs - Benutzerdefinierte Routen + Branding​

Info

Erfordert einen LiteLLM Enterprise-Schlüssel. Holen Sie sich hier eine kostenlose 2-wöchige Lizenz hier

LiteLLM-Schlüssel in Ihrer Umgebung festlegen

LITELLM_LICENSE=""

Titel + Beschreibung anpassen​

Stellen Sie in Ihrer Umgebung ein

DOCS_TITLE="TotalGPT"
DOCS_DESCRIPTION="Sample Company Description"

Routen anpassen​

Admin-Routen vor Benutzern ausblenden.

Stellen Sie in Ihrer Umgebung ein

DOCS_FILTERED="True" # only shows openai routes to user

Blockierte Benutzerlisten aktivieren​

Wenn ein Aufruf an den Proxy mit dieser Benutzer-ID erfolgt, wird er abgelehnt – verwenden Sie dies, wenn Benutzer sich von KI-Funktionen abmelden möchten.

litellm_settings: 
     callbacks: ["blocked_user_check"] 
     blocked_user_list: ["user_id_1", "user_id_2", ...]  # can also be a .txt filepath e.g. `/relative/path/blocked_list.txt`

Testen​

Setzen Sie user=<user_id> auf die Benutzer-ID des Benutzers, der sich möglicherweise abgemeldet hat.

import openai
client = openai.OpenAI(
    api_key="sk-1234",
    base_url="http://0.0.0.0:4000"
)

# request sent to model set on litellm proxy, `litellm --model`
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages = [
        {
            "role": "user",
            "content": "this is a test request, write a short poem"
        }
    ],
    user="user_id_1"
)

print(response)
Info

Schlagen Sie eine Verbesserung vor

Nutzung per API​

Alle Aufrufe für eine Kunden-ID blockieren

curl -X POST "http://0.0.0.0:4000/customer/block" \
-H "Authorization: Bearer sk-1234" \ 
-D '{
"user_ids": [<user_id>, ...] 
}'

Aufrufe für eine Benutzer-ID freigeben

curl -X POST "http://0.0.0.0:4000/user/unblock" \
-H "Authorization: Bearer sk-1234" \ 
-D '{
"user_ids": [<user_id>, ...] 
}'

Gesperrte Schlüsselwortliste aktivieren​

litellm_settings: 
     callbacks: ["banned_keywords"]
     banned_keywords_list: ["hello"] # can also be a .txt file - e.g.: `/relative/path/keywords.txt`

Testen Sie dies​

curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "gpt-3.5-turbo",
      "messages": [
        {
          "role": "user",
          "content": "Hello world!"
        }
      ]
    }
'

Öffentlicher Modell-Hub​

Teilen Sie eine öffentliche Seite mit verfügbaren Modellen für Benutzer

[BETA]AWS Key Manager - Schlüsselentschlüsselung​

Dies ist eine Beta-Funktion und Änderungen vorbehalten.

Schritt 1. Fügen Sie USE_AWS_KMS zur Umgebung hinzu

USE_AWS_KMS="True"

Schritt 2. Fügen Sie LITELLM_SECRET_AWS_KMS_ zu den verschlüsselten Schlüsseln in der Umgebung hinzu

LITELLM_SECRET_AWS_KMS_DATABASE_URL="AQICAH.."

LiteLLM findet dies und verwendet den entschlüsselten Wert DATABASE_URL="postgres://.." zur Laufzeit.

Schritt 3. Proxy starten

$ litellm

Wie funktioniert es?

  • Die Schlüsselentschlüsselung läuft, bevor der Server gestartet wird. Code
  • Es fügt den entschlüsselten Wert zu os.environ für den Python-Prozess hinzu.

Hinweis: Das Setzen einer Umgebungsvariable in einem Python-Skript mit os.environ macht diese Variable nicht über SSH-Sitzungen oder andere Prozesse zugänglich, die unabhängig vom Python-Skript gestartet werden. Auf diese Weise gesetzte Umgebungsvariablen beeinflussen nur den aktuellen Prozess und seine Kindprozesse.

Maximale Anfrage-/Antwortgröße auf LiteLLM Proxy festlegen​

Verwenden Sie dies, wenn Sie eine maximale Anfragemenge/Antwortgröße für Ihren Proxy-Server festlegen möchten. Wenn eine Anfragemenge über der Größe liegt, wird sie abgelehnt + eine Alarmbenachrichtigung ausgelöst.

Verwendung​

Schritt 1. Setzen Sie max_request_size_mb und max_response_size_mb

In diesem Beispiel setzen wir ein sehr niedriges Limit für max_request_size_mb und erwarten, dass es abgelehnt wird.

Info

In der Produktion empfehlen wir, ein max_request_size_mb / max_response_size_mb von etwa 32 MB festzulegen.

model_list:
  - model_name: fake-openai-endpoint
    litellm_params:
      model: openai/fake
      api_key: fake-key
      api_base: https://exampleopenaiendpoint-production.up.railway.app/
general_settings: 
  master_key: sk-1234

  # Security controls
  max_request_size_mb: 0.000000001 # 👈 Key Change - Max Request Size in MB. Set this very low for testing 
  max_response_size_mb: 100 # 👈 Key Change - Max Response Size in MB

Schritt 2. Testen Sie es mit einer /chat/completions-Anfrage

curl https://:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-1234" \
  -d '{
    "model": "fake-openai-endpoint",
    "messages": [
      {"role": "user", "content": "Hello, Claude!"}
    ]
  }'

Erwartete Antwort von der Anfrage Wir erwarten, dass dies fehlschlägt, da die Anfragemenge über max_request_size_mb liegt.

{"error":{"message":"Request size is too large. Request size is 0.0001125335693359375 MB. Max size is 1e-09 MB","type":"bad_request_error","param":"content-length","code":400}}