Zum Hauptinhalt springen

Protokollierung

Protokoll-Proxy-Eingabe, -Ausgabe und -Ausnahmen mit

  • Langfuse
  • OpenTelemetry
  • GCS, s3, Azure (Blob) Buckets
  • Lunary
  • MLflow
  • Benutzerdefinierte Rückrufe - Benutzerdefinierter Code und API-Endpunkte
  • Langsmith
  • DataDog
  • DynamoDB
  • usw.

Abrufen der LiteLLM Call ID​

LiteLLM generiert eine eindeutige call_id für jede Anfrage. Diese call_id kann verwendet werden, um die Anfrage im gesamten System zu verfolgen. Dies kann sehr nützlich sein, um die Informationen für eine bestimmte Anfrage in einem Protokollierungssystem wie einem der auf dieser Seite genannten Systeme zu finden.

curl -i -sSL --location 'http://0.0.0.0:4000/chat/completions' \
    --header 'Authorization: Bearer sk-1234' \
    --header 'Content-Type: application/json' \
    --data '{
      "model": "gpt-3.5-turbo",
      "messages": [{"role": "user", "content": "what llm are you"}]
    }' | grep 'x-litellm'

Die Ausgabe davon ist

x-litellm-call-id: b980db26-9512-45cc-b1da-c511a363b83f
x-litellm-model-id: cb41bc03f4c33d310019bae8c5afdb1af0a8f97b36a234405a9807614988457c
x-litellm-model-api-base: https://x-example-1234.openai.azure.com
x-litellm-version: 1.40.21
x-litellm-response-cost: 2.85e-05
x-litellm-key-tpm-limit: None
x-litellm-key-rpm-limit: None

Eine Reihe dieser Header könnten für die Fehlerbehebung nützlich sein, aber die x-litellm-call-id ist die nützlichste für die Verfolgung einer Anfrage über Komponenten in Ihrem System hinweg, einschließlich in Protokollierungstools.

Protokollierungsfunktionen​

Bedingte Protokollierung nach virtuellen Schlüsseln, Teams​

Verwenden Sie dies, um

  1. Protokollierung für einige virtuelle Schlüssel/Teams bedingt zu aktivieren
  2. Unterschiedliche Protokollierungsanbieter für verschiedene virtuelle Schlüssel/Teams festzulegen

👉 Erste Schritte - Team-/Schlüsselbasierte Protokollierung

Redigieren von UserAPIKeyInfo​

Informationen über den API-Schlüssel des Benutzers (gehaschter Token, Benutzer-ID, Team-ID usw.) aus Protokollen redigieren.

Derzeit unterstützt für Langfuse, OpenTelemetry, Logfire, ArizeAI Protokollierung.

litellm_settings: 
  callbacks: ["langfuse"]
  redact_user_api_key_info: true

Nachrichten, Antwortinhalte redigieren​

Setzen Sie litellm.turn_off_message_logging=True. Dies verhindert, dass Nachrichten und Antworten an Ihren Protokollierungsanbieter protokolliert werden, aber Metadaten der Anfrage - z. B. Kosten - werden weiterhin verfolgt.

1. config.yaml einrichten

model_list:
 - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
litellm_settings:
  success_callback: ["langfuse"]
  turn_off_message_logging: True # 👈 Key Change

2. Anfrage senden

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": "what llm are you"
        }
    ]
}'

3. Protokollierungstool + Kosteneinblicke prüfen

Protokollierungstool

Kosteneinblicke

Nachrichtenredigierung deaktivieren​

Wenn litellm.turn_on_message_logging aktiviert ist, können Sie dies für bestimmte Anfragen überschreiben, indem Sie den Anfrage-Header LiteLLM-Disable-Message-Redaction: true setzen.

curl --location 'http://0.0.0.0:4000/chat/completions' \
    --header 'Content-Type: application/json' \
    --header 'LiteLLM-Disable-Message-Redaction: true' \
    --data '{
    "model": "gpt-3.5-turbo",
    "messages": [
        {
        "role": "user",
        "content": "what llm are you"
        }
    ]
}'

Gesamte Verfolgung/Protokollierung deaktivieren​

Für einige Anwendungsfälle möchten Sie möglicherweise die gesamte Verfolgung/Protokollierung deaktivieren. Sie können dies tun, indem Sie no-log=True im Anfragekörper übergeben.

Info

Deaktivieren Sie dies, indem Sie global_disable_no_log_param:true in Ihrer config.yaml-Datei festlegen.

litellm_settings:
  global_disable_no_log_param: True
curl -L -X POST 'http://0.0.0.0:4000/v1/chat/completions' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer <litellm-api-key>' \
-d '{
    "model": "openai/gpt-3.5-turbo",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "What'\''s in this image?"
          }
        ]
      }
    ],
    "max_tokens": 300,
    "no-log": true # 👈 Key Change
}'

Erwartete Konsolenprotokollierung 

LiteLLM.Info: "no-log request, skipping logging"

Was wird protokolliert?​

Gefunden unter kwargs["standard_logging_object"]. Dies ist eine Standardnutzlast, die für jede Antwort protokolliert wird.

👉 Standard Logging Payload Spezifikation

Langfuse​

Wir verwenden --config, um litellm.success_callback = ["langfuse"] einzustellen. Dies protokolliert alle erfolgreichen LLM-Aufrufe in Langfuse. Stellen Sie sicher, dass Sie LANGFUSE_PUBLIC_KEY und LANGFUSE_SECRET_KEY in Ihrer Umgebung festlegen.

Schritt 1 Langfuse installieren

pip install langfuse>=2.0.0

Schritt 2: Erstellen Sie eine config.yaml-Datei und legen Sie litellm_settings fest: success_callback

model_list:
 - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
litellm_settings:
  success_callback: ["langfuse"]

Schritt 3: Erforderliche Umgebungsvariablen für die Protokollierung nach Langfuse festlegen

export LANGFUSE_PUBLIC_KEY="pk_kk"
export LANGFUSE_SECRET_KEY="sk_ss"
# Optional, defaults to https://cloud.langfuse.com
export LANGFUSE_HOST="https://xxx.langfuse.com"

Schritt 4: Den Proxy starten, eine Testanfrage stellen

Proxy starten

litellm --config config.yaml --debug

Testanfrage

litellm --test

Erwartete Ausgabe auf Langfuse

Protokollierung von Metadaten nach Langfuse​

Übergeben Sie metadata als Teil des Anfragekörpers

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": "what llm are you"
        }
    ],
    "metadata": {
        "generation_name": "ishaan-test-generation",
        "generation_id": "gen-id22",
        "trace_id": "trace-id22",
        "trace_user_id": "user-id2"
    }
}'

Benutzerdefinierte Tags​

Setzen Sie tags als Teil Ihres Anfragekörpers

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

response = client.chat.completions.create(
    model="llama3",
    messages = [
        {
            "role": "user",
            "content": "this is a test request, write a short poem"
        }
    ],
    user="palantir",
    extra_body={
        "metadata": {
            "tags": ["jobID:214590dsff09fds", "taskName:run_page_classification"]
        }
    }
)

print(response)

LiteLLM Tags - cache_hit, cache_key​

Verwenden Sie dies, wenn Sie steuern möchten, welche LiteLLM-spezifischen Felder als Tags vom LiteLLM-Proxy protokolliert werden. Standardmäßig protokolliert der LiteLLM-Proxy keine LiteLLM-spezifischen Felder.

LiteLLM-spezifisches FeldBeschreibungBeispielwert
cache_hitGibt an, ob ein Cache-Treffer aufgetreten ist (True) oder nicht (False).true, false
cache_keyDer Cache-Schlüssel, der für diese Anfrage verwendet wurde.d2b758c****
proxy_base_urlDie Basis-URL für den Proxy-Server, der Wert der Umgebungsvariable PROXY_BASE_URL auf Ihrem Server.https://proxy.example.com
user_api_key_aliasEin Alias für den LiteLLM Virtual Key.prod-app1
user_api_key_user_idDie eindeutige ID, die einem API-Schlüssel eines Benutzers zugeordnet ist.user_123, user_456
user_api_key_user_emailDie E-Mail-Adresse, die einem API-Schlüssel eines Benutzers zugeordnet ist.user@example.com, admin@example.com
user_api_key_team_aliasEin Alias für ein Team, das einem API-Schlüssel zugeordnet ist.team_alpha, dev_team

Verwendung

Geben Sie langfuse_default_tags an, um zu steuern, welche LiteLLM-Felder auf Langfuse protokolliert werden.

Beispiel config.yaml

model_list:
  - model_name: gpt-4
    litellm_params:
      model: openai/fake
      api_key: fake-key
      api_base: https://exampleopenaiendpoint-production.up.railway.app/

litellm_settings:
  success_callback: ["langfuse"]

  # 👇 Key Change
  langfuse_default_tags: ["cache_hit", "cache_key", "proxy_base_url", "user_api_key_alias", "user_api_key_user_id", "user_api_key_user_email", "user_api_key_team_alias", "semantic-similarity", "proxy_base_url"]

POST-Anfrage von LiteLLM an den Anbieter anzeigen​

Verwenden Sie dies, wenn Sie die RAW-Curl-Anfrage anzeigen möchten, die von LiteLLM an die LLM-API gesendet wird.

Übergeben Sie metadata als Teil des Anfragekörpers

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": "what llm are you"
        }
    ],
    "metadata": {
        "log_raw_request": true
    }
}'

Erwartete Ausgabe auf Langfuse

Sie sehen raw_request in Ihren Langfuse Metadaten. Dies ist der RAW-CURL-Befehl, der von LiteLLM an Ihren LLM-API-Anbieter gesendet wird.

OpenTelemetry​

Info

[Optional]Passen Sie OTEL-Servicename und OTEL-TRACER NAME an, indem Sie die folgenden Variablen in Ihrer Umgebung festlegen.

OTEL_TRACER_NAME=<your-trace-name>     # default="litellm"
OTEL_SERVICE_NAME=<your-service-name>` # default="litellm"

Schritt 1: Rückrufe und Umgebungsvariablen festlegen

Fügen Sie Ihrer Umgebung Folgendes hinzu

OTEL_EXPORTER="console"

Fügen Sie otel als Rückruf zu Ihrer litellm_config.yaml hinzu

litellm_settings:
  callbacks: ["otel"]

Schritt 2: Den Proxy starten, eine Testanfrage stellen

Proxy starten

litellm --config config.yaml --detailed_debug

Testanfrage

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": "what llm are you"
        }
    ]
    }'

Schritt 3: Erwarten Sie, Folgendes in Ihren Serverprotokollen / Ihrer Konsole protokolliert zu sehen

Dies ist der Span von der OTEL-Protokollierung.

{
    "name": "litellm-acompletion",
    "context": {
        "trace_id": "0x8d354e2346060032703637a0843b20a3",
        "span_id": "0xd8d3476a2eb12724",
        "trace_state": "[]"
    },
    "kind": "SpanKind.INTERNAL",
    "parent_id": null,
    "start_time": "2024-06-04T19:46:56.415888Z",
    "end_time": "2024-06-04T19:46:56.790278Z",
    "status": {
        "status_code": "OK"
    },
    "attributes": {
        "model": "llama3-8b-8192"
    },
    "events": [],
    "links": [],
    "resource": {
        "attributes": {
            "service.name": "litellm"
        },
        "schema_url": ""
    }
}

🎉 Erwarten Sie, diese Spur in Ihrem OTEL-Collector protokolliert zu sehen.

Nachrichten, Antwortinhalte redigieren​

Setzen Sie message_logging=False für otel, keine Nachrichten / Antworten werden protokolliert.

litellm_settings:
  callbacks: ["otel"]

## 👇 Key Change
callback_settings:
  otel:
    message_logging: False

Traceparent-Header​

Kontextweitergabe über Dienste hinweg Traceparent HTTP-Header​

❓ Verwenden Sie dies, wenn Sie Informationen über die eingehende Anfrage in einem verteilten Tracing-System übergeben möchten.

✅ Wichtige Änderung: Übergeben Sie den traceparent-Header in Ihren Anfragen. Lesen Sie mehr über Traceparent-Header hier.

traceparent: 00-80e1afed08e019fc1110464cfa66635c-7a085853722dc6d2-01

Beispielverwendung

  1. Anfrage an LiteLLM Proxy mit traceparent-Header stellen
import openai
import uuid

client = openai.OpenAI(api_key="sk-1234", base_url="http://0.0.0.0:4000")
example_traceparent = f"00-80e1afed08e019fc1110464cfa66635c-02e80198930058d4-01"
extra_headers = {
    "traceparent": example_traceparent
}
_trace_id = example_traceparent.split("-")[1]

print("EXTRA HEADERS: ", extra_headers)
print("Trace ID: ", _trace_id)

response = client.chat.completions.create(
    model="llama3",
    messages=[
        {"role": "user", "content": "this is a test request, write a short poem"}
    ],
    extra_headers=extra_headers,
)

print(response)
# EXTRA HEADERS:  {'traceparent': '00-80e1afed08e019fc1110464cfa66635c-02e80198930058d4-01'}
# Trace ID:  80e1afed08e019fc1110464cfa66635c
  1. Trace-ID im OTEL Logger nachschlagen

Suchen Sie nach Trace=80e1afed08e019fc1110464cfa66635c in Ihrem OTEL Collector.

Traceparent HTTP-Header an LLM-APIs weiterleiten​

Verwenden Sie dies, wenn Sie die Traceparent-Header an Ihre selbst gehosteten LLMs wie vLLM weiterleiten möchten.

Setzen Sie forward_traceparent_to_llm_provider: True in Ihrer config.yaml. Dies leitet den traceparent-Header an Ihre LLM-API weiter.

Danger

Verwenden Sie dies nur für selbst gehostete LLMs, dies kann dazu führen, dass Bedrock, VertexAI-Aufrufe fehlschlagen.

litellm_settings:
  forward_traceparent_to_llm_provider: True

Google Cloud Storage Buckets​

LLM-Logs nach Google Cloud Storage Buckets protokollieren.

Info

✨ Dies ist eine reine Enterprise-Funktion Starten Sie hier mit Enterprise

EigenschaftDetails
BeschreibungLLM-Eingabe/Ausgabe in Cloud-Speicher-Buckets protokollieren
Lasttest-Benchmarks ladenBenchmarks
Google Docs zu Cloud StorageGoogle Cloud Storage

Verwendung​

  1. Fügen Sie gcs_bucket zur LiteLLM Config.yaml hinzu.
model_list:
- litellm_params:
    api_base: https://exampleopenaiendpoint-production.up.railway.app/
    api_key: my-fake-key
    model: openai/my-fake-model
  model_name: fake-openai-endpoint

litellm_settings:
  callbacks: ["gcs_bucket"] # 👈 KEY CHANGE # 👈 KEY CHANGE
  1. Erforderliche Umgebungsvariablen festlegen
GCS_BUCKET_NAME="<your-gcs-bucket-name>"
GCS_PATH_SERVICE_ACCOUNT="/Users/ishaanjaffer/Downloads/adroit-crow-413218-a956eef1a2a8.json" # Add path to service account.json
  1. Proxy starten
litellm --config /path/to/config.yaml
  1. Testen Sie es!
curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "fake-openai-endpoint",
      "messages": [
        {
          "role": "user",
          "content": "what llm are you"
        }
      ],
    }
'

Erwartete Protokolle in GCS-Buckets​

Felder, die in GCS-Buckets protokolliert werden​

Das Standard-Protokollierungsobjekt wird im GCS-Bucket protokolliert.

service_account.json von der Google Cloud Console erhalten​

  1. Gehen Sie zur Google Cloud Console.
  2. Suchen Sie nach IAM & Admin.
  3. Klicken Sie auf Dienstkonten.
  4. Wählen Sie ein Dienstkonto aus.
  5. Klicken Sie auf "Schlüssel" -> Schlüssel hinzufügen -> Neuen Schlüssel erstellen -> JSON.
  6. Speichern Sie die JSON-Datei und fügen Sie den Pfad zu GCS_PATH_SERVICE_ACCOUNT hinzu.

Google Cloud Storage - PubSub-Thema​

LLM-Logs/SpendLogs nach Google Cloud Storage PubSub-Thema protokollieren.

Info

✨ Dies ist eine reine Enterprise-Funktion Starten Sie hier mit Enterprise

EigenschaftDetails
BeschreibungProtokollieren Sie die LiteLLM SpendLogs-Tabelle in ein Google Cloud Storage PubSub-Thema.

Wann sollte gcs_pubsub verwendet werden?

  • Wenn Ihre LiteLLM-Datenbank über 1 Million Kosteneinblicke überschritten hat und Sie SpendLogs an ein PubSub-Thema senden möchten, das von GCS BigQuery verarbeitet werden kann.

Verwendung​

  1. Fügen Sie gcs_pubsub zur LiteLLM Config.yaml hinzu.
model_list:
- litellm_params:
    api_base: https://exampleopenaiendpoint-production.up.railway.app/
    api_key: my-fake-key
    model: openai/my-fake-model
  model_name: fake-openai-endpoint

litellm_settings:
  callbacks: ["gcs_pubsub"] # 👈 KEY CHANGE # 👈 KEY CHANGE
  1. Erforderliche Umgebungsvariablen festlegen
GCS_PUBSUB_TOPIC_ID="litellmDB"
GCS_PUBSUB_PROJECT_ID="reliableKeys"
  1. Proxy starten
litellm --config /path/to/config.yaml
  1. Testen Sie es!
curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "fake-openai-endpoint",
      "messages": [
        {
          "role": "user",
          "content": "what llm are you"
        }
      ],
    }
'

s3 Buckets​

Wir werden --config verwenden, um Folgendes einzustellen:

  • litellm.success_callback = ["s3"]

Dies protokolliert alle erfolgreichen LLM-Aufrufe in einen s3 Bucket.

Schritt 1 AWS-Anmeldeinformationen in .env festlegen

AWS_ACCESS_KEY_ID = ""
AWS_SECRET_ACCESS_KEY = ""
AWS_REGION_NAME = ""

Schritt 2: Erstellen Sie eine config.yaml-Datei und legen Sie litellm_settings fest: success_callback

model_list:
 - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
litellm_settings:
  success_callback: ["s3"]
  s3_callback_params:
    s3_bucket_name: logs-bucket-litellm   # AWS Bucket Name for S3
    s3_region_name: us-west-2              # AWS Region Name for S3
    s3_aws_access_key_id: os.environ/AWS_ACCESS_KEY_ID  # us os.environ/<variable name> to pass environment variables. This is AWS Access Key ID for S3
    s3_aws_secret_access_key: os.environ/AWS_SECRET_ACCESS_KEY  # AWS Secret Access Key for S3
    s3_path: my-test-path # [OPTIONAL] set path in bucket you want to write logs to
    s3_endpoint_url: https://s3.amazonaws.com  # [OPTIONAL] S3 endpoint URL, if you want to use Backblaze/cloudflare s3 buckets

Schritt 3: Den Proxy starten, eine Testanfrage stellen

Proxy starten

litellm --config config.yaml --debug

Testanfrage

curl --location 'http://0.0.0.0:4000/chat/completions' \
    --header 'Content-Type: application/json' \
    --data ' {
    "model": "Azure OpenAI GPT-4 East",
    "messages": [
        {
        "role": "user",
        "content": "what llm are you"
        }
    ]
    }'

Ihre Protokolle sollten im angegebenen s3 Bucket verfügbar sein.

Team-Alias-Präfix im Objekt-Schlüssel​

Dies ist eine Vorschau-Funktion.

Sie können den Team-Alias zum Objekt-Schlüssel hinzufügen, indem Sie team_alias in der config.yaml-Datei festlegen. Dies wird den Objekt-Schlüssel mit dem Team-Alias voranstellen.

litellm_settings:
  callbacks: ["s3"]
  enable_preview_features: true
  s3_callback_params:
    s3_bucket_name: logs-bucket-litellm
    s3_region_name: us-west-2
    s3_aws_access_key_id: os.environ/AWS_ACCESS_KEY_ID
    s3_aws_secret_access_key: os.environ/AWS_SECRET_ACCESS_KEY
    s3_path: my-test-path
    s3_endpoint_url: https://s3.amazonaws.com
    s3_use_team_prefix: true

Im s3 Bucket sehen Sie den Objekt-Schlüssel als my-test-path/my-team-alias/....

Azure Blob Storage​

LLM-Logs nach Azure Data Lake Storage protokollieren.

Info

✨ Dies ist eine reine Enterprise-Funktion Starten Sie hier mit Enterprise

EigenschaftDetails
BeschreibungLLM-Ein-/Ausgabe in Azure Blob Storage (Bucket) protokollieren.
Azure Docs zu Data Lake StorageAzure Data Lake Storage

Verwendung​

  1. Fügen Sie azure_storage zur LiteLLM Config.yaml hinzu.
model_list:
  - model_name: fake-openai-endpoint
    litellm_params:
      model: openai/fake
      api_key: fake-key
      api_base: https://exampleopenaiendpoint-production.up.railway.app/

litellm_settings:
  callbacks: ["azure_storage"] # 👈 KEY CHANGE # 👈 KEY CHANGE
  1. Erforderliche Umgebungsvariablen festlegen
# Required Environment Variables for Azure Storage
AZURE_STORAGE_ACCOUNT_NAME="litellm2" # The name of the Azure Storage Account to use for logging
AZURE_STORAGE_FILE_SYSTEM="litellm-logs" # The name of the Azure Storage File System to use for logging.  (Typically the Container name)

# Authentication Variables
# Option 1: Use Storage Account Key
AZURE_STORAGE_ACCOUNT_KEY="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # The Azure Storage Account Key to use for Authentication

# Option 2: Use Tenant ID + Client ID + Client Secret
AZURE_STORAGE_TENANT_ID="985efd7cxxxxxxxxxx" # The Application Tenant ID to use for Authentication
AZURE_STORAGE_CLIENT_ID="abe66585xxxxxxxxxx" # The Application Client ID to use for Authentication
AZURE_STORAGE_CLIENT_SECRET="uMS8Qxxxxxxxxxx" # The Application Client Secret to use for Authentication
  1. Proxy starten
litellm --config /path/to/config.yaml
  1. Testen Sie es!
curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "fake-openai-endpoint",
      "messages": [
        {
          "role": "user",
          "content": "what llm are you"
        }
      ],
    }
'

Erwartete Protokolle auf Azure Data Lake Storage​

Felder, die auf Azure Data Lake Storage protokolliert werden​

Das Standard-Protokollierungsobjekt wird auf Azure Data Lake Storage protokolliert.

DataDog​

LiteLLM unterstützt die Protokollierung für die folgenden Datdog-Integrationen:

Wir verwenden --config, um litellm.callbacks = ["datadog"] einzustellen. Dies protokolliert alle erfolgreichen LLM-Aufrufe nach DataDog.

Schritt 1: Erstellen Sie eine config.yaml-Datei und legen Sie litellm_settings fest: success_callback

model_list:
 - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
litellm_settings:
  callbacks: ["datadog"] # logs llm success + failure logs on datadog
  service_callback: ["datadog"] # logs redis, postgres failures on datadog

Schritt 2: Erforderliche Umgebungsvariablen für Datadog festlegen

DD_API_KEY="5f2d0f310***********" # your datadog API Key
DD_SITE="us5.datadoghq.com"       # your datadog base url
DD_SOURCE="litellm_dev"       # [OPTIONAL] your datadog source. use to differentiate dev vs. prod deployments

Schritt 3: Den Proxy starten, eine Testanfrage stellen

Proxy starten

litellm --config config.yaml --debug

Testanfrage

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": "what llm are you"
        }
    ],
    "metadata": {
        "your-custom-metadata": "custom-field",
    }
}'

Erwartete Ausgabe auf Datadog

Datadog Tracing​

Verwenden Sie ddtrace-run, um Datadog Tracing auf dem litellm-Proxy zu aktivieren.

Übergeben Sie USE_DDTRACE=true an den Docker-Run-Befehl. Wenn USE_DDTRACE=true, führt der Proxy ddtrace-run litellm als ENTRYPOINT anstelle von nur litellm aus.

docker run \
    -v $(pwd)/litellm_config.yaml:/app/config.yaml \
    -e USE_DDTRACE=true \
    -p 4000:4000 \
    ghcr.io/berriai/litellm:main-latest \
    --config /app/config.yaml --detailed_debug

DD-Variablen festlegen (DD_SERVICE etc.)​

LiteLLM unterstützt die Anpassung der folgenden Datadog-Umgebungsvariablen.

UmgebungsvariableBeschreibungStandardwertErforderlich
DD_API_KEYIhr Datadog API-Schlüssel zur Authentifizierung.Keiner✅ Ja
DD_SITEIhre Datadog-Site (z. B. "us5.datadoghq.com").Keiner✅ Ja
DD_ENVUmgebungs-Tag für Ihre Protokolle (z. B. "production", "staging")."unbekannt"❌ Nein
DD_SERVICEServicename für Ihre Protokolle."litellm-server"❌ Nein
DD_SOURCEQuellenname für Ihre Protokolle."litellm"❌ Nein
DD_VERSIONVersions-Tag für Ihre Protokolle."unbekannt"❌ Nein
HOSTNAMEHostname-Tag für Ihre Protokolle.""❌ Nein
POD_NAMEPod-Name-Tag (nützlich für Kubernetes-Bereitstellungen)."unbekannt"❌ Nein

Lunary​

Schritt 1: Abhängigkeiten installieren und Umgebungsvariablen festlegen​

Abhängigkeiten installieren

pip install litellm lunary

Holen Sie Ihren Lunary öffentlichen Schlüssel von https://app.lunary.ai/settings.

export LUNARY_PUBLIC_KEY="<your-public-key>"

Schritt 2: Eine config.yaml erstellen und lunary-Rückrufe festlegen​

model_list:
  - model_name: "*"
    litellm_params:
      model: "*"
litellm_settings:
  success_callback: ["lunary"]
  failure_callback: ["lunary"]

Schritt 3: Den LiteLLM-Proxy starten​

litellm --config config.yaml

Schritt 4: Eine Anfrage stellen​

curl -X POST 'http://0.0.0.0:4000/chat/completions' \
-H 'Content-Type: application/json' \
-d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "system",
        "content": "You are a helpful math tutor. Guide the user through the solution step by step."
      },
      {
        "role": "user",
        "content": "how can I solve 8x + 7 = -23"
      }
    ]
}'

MLflow​

Schritt 1: Abhängigkeiten installieren​

Abhängigkeiten installieren.

pip install litellm mlflow

Schritt 2: Eine config.yaml mit mlflow-Rückruf erstellen​

model_list:
  - model_name: "*"
    litellm_params:
      model: "*"
litellm_settings:
  success_callback: ["mlflow"]
  failure_callback: ["mlflow"]

Schritt 3: Den LiteLLM-Proxy starten​

litellm --config config.yaml

Schritt 4: Eine Anfrage stellen​

curl -X POST 'http://0.0.0.0:4000/chat/completions' \
-H 'Content-Type: application/json' \
-d '{
    "model": "gpt-4o-mini",
    "messages": [
      {
        "role": "user",
        "content": "What is the capital of France?"
      }
    ]
}'

Schritt 5: Spuren überprüfen​

Führen Sie den folgenden Befehl aus, um die MLflow UI zu starten und die aufgezeichneten Spuren zu überprüfen.

mlflow ui

Benutzerdefinierte Callback-Klasse[Async]​

Verwenden Sie dies, wenn Sie benutzerdefinierte Rückrufe in python ausführen möchten.

Schritt 1 - Erstellen Sie Ihre benutzerdefinierte litellm-Callback-Klasse​

Wir verwenden litellm.integrations.custom_logger hierfür, weitere Details zu litellm benutzerdefinierten Rückrufen finden Sie hier.

Definieren Sie Ihre benutzerdefinierte Callback-Klasse in einer Python-Datei.

Hier ist ein Beispiel für einen benutzerdefinierten Logger zur Verfolgung von key, user, model, prompt, response, tokens, cost. Wir erstellen eine Datei namens custom_callbacks.py und initialisieren proxy_handler_instance.

from litellm.integrations.custom_logger import CustomLogger
import litellm

# This file includes the custom callbacks for LiteLLM Proxy
# Once defined, these can be passed in proxy_config.yaml
class MyCustomHandler(CustomLogger):
    def log_pre_api_call(self, model, messages, kwargs): 
        print(f"Pre-API Call")
    
    def log_post_api_call(self, kwargs, response_obj, start_time, end_time): 
        print(f"Post-API Call")
        
    def log_success_event(self, kwargs, response_obj, start_time, end_time): 
        print("On Success")

    def log_failure_event(self, kwargs, response_obj, start_time, end_time): 
        print(f"On Failure")

    async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
        print(f"On Async Success!")
        # log: key, user, model, prompt, response, tokens, cost
        # Access kwargs passed to litellm.completion()
        model = kwargs.get("model", None)
        messages = kwargs.get("messages", None)
        user = kwargs.get("user", None)

        # Access litellm_params passed to litellm.completion(), example access `metadata`
        litellm_params = kwargs.get("litellm_params", {})
        metadata = litellm_params.get("metadata", {})   # headers passed to LiteLLM proxy, can be found here

        # Calculate cost using  litellm.completion_cost()
        cost = litellm.completion_cost(completion_response=response_obj)
        response = response_obj
        # tokens used in response 
        usage = response_obj["usage"]

        print(
            f"""
                Model: {model},
                Messages: {messages},
                User: {user},
                Usage: {usage},
                Cost: {cost},
                Response: {response}
                Proxy Metadata: {metadata}
            """
        )
        return

    async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time): 
        try:
            print(f"On Async Failure !")
            print("\nkwargs", kwargs)
            # Access kwargs passed to litellm.completion()
            model = kwargs.get("model", None)
            messages = kwargs.get("messages", None)
            user = kwargs.get("user", None)

            # Access litellm_params passed to litellm.completion(), example access `metadata`
            litellm_params = kwargs.get("litellm_params", {})
            metadata = litellm_params.get("metadata", {})   # headers passed to LiteLLM proxy, can be found here

            # Access Exceptions & Traceback
            exception_event = kwargs.get("exception", None)
            traceback_event = kwargs.get("traceback_exception", None)

            # Calculate cost using  litellm.completion_cost()
            cost = litellm.completion_cost(completion_response=response_obj)
            print("now checking response obj")
            
            print(
                f"""
                    Model: {model},
                    Messages: {messages},
                    User: {user},
                    Cost: {cost},
                    Response: {response_obj}
                    Proxy Metadata: {metadata}
                    Exception: {exception_event}
                    Traceback: {traceback_event}
                """
            )
        except Exception as e:
            print(f"Exception: {e}")

proxy_handler_instance = MyCustomHandler()

# Set litellm.callbacks = [proxy_handler_instance] on the proxy
# need to set litellm.callbacks = [proxy_handler_instance] # on the proxy

Schritt 2 - Übergeben Sie Ihre benutzerdefinierte Callback-Klasse in config.yaml​

Wir übergeben die in Schritt 1 definierte benutzerdefinierte Callback-Klasse an die config.yaml. Setzen Sie callbacks auf python_filename.logger_instance_name.

In der folgenden Konfiguration übergeben wir

  • python_filename: custom_callbacks.py
  • logger_instance_name: proxy_handler_instance. Diese ist in Schritt 1 definiert.

callbacks: custom_callbacks.proxy_handler_instance

model_list:
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo

litellm_settings:
  callbacks: custom_callbacks.proxy_handler_instance # sets litellm.callbacks = [proxy_handler_instance]

Schritt 3 - Proxy starten + Testanfrage​

litellm --config proxy_config.yaml
curl --location 'http://0.0.0.0:4000/chat/completions' \
    --header 'Authorization: Bearer sk-1234' \
    --data ' {
    "model": "gpt-3.5-turbo",
    "messages": [
        {
        "role": "user",
        "content": "good morning good sir"
        }
    ],
    "user": "ishaan-app",
    "temperature": 0.2
    }'

Ergebnisprotokoll auf dem Proxy​

On Success
    Model: gpt-3.5-turbo,
    Messages: [{'role': 'user', 'content': 'good morning good sir'}],
    User: ishaan-app,
    Usage: {'completion_tokens': 10, 'prompt_tokens': 11, 'total_tokens': 21},
    Cost: 3.65e-05,
    Response: {'id': 'chatcmpl-8S8avKJ1aVBg941y5xzGMSKrYCMvN', 'choices': [{'finish_reason': 'stop', 'index': 0, 'message': {'content': 'Good morning! How can I assist you today?', 'role': 'assistant'}}], 'created': 1701716913, 'model': 'gpt-3.5-turbo-0613', 'object': 'chat.completion', 'system_fingerprint': None, 'usage': {'completion_tokens': 10, 'prompt_tokens': 11, 'total_tokens': 21}}
    Proxy Metadata: {'user_api_key': None, 'headers': Headers({'host': '0.0.0.0:4000', 'user-agent': 'curl/7.88.1', 'accept': '*/*', 'authorization': 'Bearer sk-1234', 'content-length': '199', 'content-type': 'application/x-www-form-urlencoded'}), 'model_group': 'gpt-3.5-turbo', 'deployment': 'gpt-3.5-turbo-ModelID-gpt-3.5-turbo'}

Protokollierung von Proxy-Anfrageobjekt, Header, URL​

Hier erfahren Sie, wie Sie auf die url, headers und den request body zugreifen können, die für jede Anfrage an den Proxy gesendet werden.

class MyCustomHandler(CustomLogger):
    async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
        print(f"On Async Success!")

        litellm_params = kwargs.get("litellm_params", None)
        proxy_server_request = litellm_params.get("proxy_server_request")
        print(proxy_server_request)

Erwartete Ausgabe

{
  "url": "http://testserver/chat/completions",
  "method": "POST",
  "headers": {
    "host": "testserver",
    "accept": "*/*",
    "accept-encoding": "gzip, deflate",
    "connection": "keep-alive",
    "user-agent": "testclient",
    "authorization": "Bearer None",
    "content-length": "105",
    "content-type": "application/json"
  },
  "body": {
    "model": "Azure OpenAI GPT-4 Canada",
    "messages": [
      {
        "role": "user",
        "content": "hi"
      }
    ],
    "max_tokens": 10
  }
}

Protokollierung von model_info, das in config.yaml festgelegt ist​

Hier erfahren Sie, wie Sie die in Ihrer Proxy-config.yaml festgelegte model_info protokollieren. Informationen zur Einstellung von model_info in config.yaml.

class MyCustomHandler(CustomLogger):
    async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
        print(f"On Async Success!")

        litellm_params = kwargs.get("litellm_params", None)
        model_info = litellm_params.get("model_info")
        print(model_info)

Erwartete Ausgabe

{'mode': 'embedding', 'input_cost_per_token': 0.002}
Antworten vom Proxy protokollieren​

Sowohl /chat/completions als auch /embeddings Antworten sind als response_obj verfügbar.

Hinweis: Für /chat/completions sind sowohl stream=True als auch nicht-stream Antworten als response_obj verfügbar.

class MyCustomHandler(CustomLogger):
    async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
        print(f"On Async Success!")
        print(response_obj)

Erwartete Ausgabe /chat/completion[für beide Antwortearten: stream und nicht-stream]

ModelResponse(
    id='chatcmpl-8Tfu8GoMElwOZuj2JlHBhNHG01PPo',
    choices=[
        Choices(
            finish_reason='stop',
            index=0,
            message=Message(
                content='As an AI language model, I do not have a physical body and therefore do not possess any degree or educational qualifications. My knowledge and abilities come from the programming and algorithms that have been developed by my creators.',
                role='assistant'
            )
        )
    ],
    created=1702083284,
    model='chatgpt-v-2',
    object='chat.completion',
    system_fingerprint=None,
    usage=Usage(
        completion_tokens=42,
        prompt_tokens=5,
        total_tokens=47
    )
)

Erwartete Ausgabe /embeddings

{
    'model': 'ada',
    'data': [
        {
            'embedding': [
                -0.035126980394124985, -0.020624293014407158, -0.015343423001468182,
                -0.03980357199907303, -0.02750781551003456, 0.02111034281551838,
                -0.022069307044148445, -0.019442008808255196, -0.00955679826438427,
                -0.013143060728907585, 0.029583381488919258, -0.004725852981209755,
                -0.015198921784758568, -0.014069183729588985, 0.00897879246622324,
                0.01521205808967352,
                # ... (truncated for brevity)
            ]
        }
    ]
}

Benutzerdefinierte Callback-APIs[Async]​

LiteLLM-Protokolle an einen benutzerdefinierten API-Endpunkt senden.

Info

Dies ist eine reine Enterprise-Funktion Starten Sie hier mit Enterprise.

EigenschaftDetails
BeschreibungLLM-Ein-/Ausgabe an einen benutzerdefinierten API-Endpunkt protokollieren.
Protokollierte NutzlastList[StandardLoggingPayload] LiteLLM protokolliert eine Liste von StandardLoggingPayload-Objekten an Ihren Endpunkt.

Verwenden Sie dies, wenn Sie

  • Benutzerdefinierte Rückrufe in einer anderen Programmiersprache als Python verwenden möchten.
  • Möchten, dass Ihre Rückrufe auf einem anderen Microservice ausgeführt werden.

Verwendung​

  1. Setzen Sie success_callback: ["generic_api"] in der litellm config.yaml.
litellm config.yaml
model_list:
  - model_name: openai/gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: os.environ/OPENAI_API_KEY

litellm_settings:
  success_callback: ["generic_api"]
  1. Umgebungsvariablen für den benutzerdefinierten API-Endpunkt festlegen.
UmgebungsvariableDetailsErforderlich
GENERIC_LOGGER_ENDPOINTDer Endpunkt + Route, an die Callback-Protokolle gesendet werden sollen.Ja
GENERIC_LOGGER_HEADERSOptional: Header festlegen, die an den benutzerdefinierten API-Endpunkt gesendet werden sollen.Nein, dies ist optional.
.env
GENERIC_LOGGER_ENDPOINT="https://webhook-test.com/30343bc33591bc5e6dc44217ceae3e0a"


# Optional: Set headers to be sent to the custom API endpoint
GENERIC_LOGGER_HEADERS="Authorization=Bearer <your-api-key>"
# if multiple headers, separate by commas
GENERIC_LOGGER_HEADERS="Authorization=Bearer <your-api-key>,X-Custom-Header=custom-header-value"
  1. Starten Sie den Proxy
litellm --config /path/to/config.yaml
  1. Testanfrage stellen.
curl -i --location 'http://0.0.0.0:4000/chat/completions' \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer sk-1234' \
    --data '{
    "model": "openai/gpt-4o",
    "messages": [
        {
        "role": "user",
        "content": "what llm are you"
        }
    ]
}'

Langsmith​

  1. Setzen Sie success_callback: ["langsmith"] in der litellm config.yaml.

Wenn Sie eine benutzerdefinierte LangSmith-Instanz verwenden, können Sie die Umgebungsvariable LANGSMITH_BASE_URL setzen, um auf Ihre Instanz zu verweisen.

litellm_settings:
  success_callback: ["langsmith"]

environment_variables:
  LANGSMITH_API_KEY: "lsv2_pt_xxxxxxxx"
  LANGSMITH_PROJECT: "litellm-proxy"

  LANGSMITH_BASE_URL: "https://api.smith.langchain.com" # (Optional - only needed if you have a custom Langsmith instance)
  1. Proxy starten
litellm --config /path/to/config.yaml
  1. Testen Sie es!
curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "fake-openai-endpoint",
      "messages": [
        {
          "role": "user",
          "content": "Hello, Claude gm!"
        }
      ],
    }
'

Erwarten Sie, Ihr Protokoll auf Langfuse zu sehen.

Arize AI​

  1. Setzen Sie success_callback: ["arize"] in der litellm config.yaml.
model_list:
  - model_name: gpt-4
    litellm_params:
      model: openai/fake
      api_key: fake-key
      api_base: https://exampleopenaiendpoint-production.up.railway.app/

litellm_settings:
  callbacks: ["arize"]

environment_variables:
    ARIZE_SPACE_KEY: "d0*****"
    ARIZE_API_KEY: "141a****"
    ARIZE_ENDPOINT: "https://otlp.arize.com/v1" # OPTIONAL - your custom arize GRPC api endpoint
    ARIZE_HTTP_ENDPOINT: "https://otlp.arize.com/v1" # OPTIONAL - your custom arize HTTP api endpoint. Set either this or ARIZE_ENDPOINT
  1. Proxy starten
litellm --config /path/to/config.yaml
  1. Testen Sie es!
curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "fake-openai-endpoint",
      "messages": [
        {
          "role": "user",
          "content": "Hello, Claude gm!"
        }
      ],
    }
'

Erwarten Sie, Ihr Protokoll auf Langfuse zu sehen.

Langtrace​

  1. Setzen Sie success_callback: ["langtrace"] in der litellm config.yaml.
model_list:
  - model_name: gpt-4
    litellm_params:
      model: openai/fake
      api_key: fake-key
      api_base: https://exampleopenaiendpoint-production.up.railway.app/

litellm_settings:
  callbacks: ["langtrace"]

environment_variables:
    LANGTRACE_API_KEY: "141a****"
  1. Proxy starten
litellm --config /path/to/config.yaml
  1. Testen Sie es!
curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "fake-openai-endpoint",
      "messages": [
        {
          "role": "user",
          "content": "Hello, Claude gm!"
        }
      ],
    }
'

Galileo​

[BETA]

LLM I/O nach www.rungalileo.io protokollieren.

Info

Beta-Integration

Erforderliche Umgebungsvariablen

export GALILEO_BASE_URL=""  # For most users, this is the same as their console URL except with the word 'console' replaced by 'api' (e.g. http://www.console.galileo.myenterprise.com -> http://www.api.galileo.myenterprise.com)
export GALILEO_PROJECT_ID=""
export GALILEO_USERNAME=""
export GALILEO_PASSWORD=""

Schnellstart​

  1. Zur Config.yaml hinzufügen
model_list:
- litellm_params:
    api_base: https://exampleopenaiendpoint-production.up.railway.app/
    api_key: my-fake-key
    model: openai/my-fake-model
  model_name: fake-openai-endpoint

litellm_settings:
  success_callback: ["galileo"] # 👈 KEY CHANGE
  1. Proxy starten
litellm --config /path/to/config.yaml
  1. Testen Sie es!
curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "fake-openai-endpoint",
      "messages": [
        {
          "role": "user",
          "content": "what llm are you"
        }
      ],
    }
'

🎉 Das war's - Erwarten Sie, Ihre Protokolle auf Ihrem Galileo-Dashboard zu sehen.

OpenMeter​

Kunden nach ihrer LLM-API-Nutzung mit OpenMeter abrechnen.

Erforderliche Umgebungsvariablen

# from https://openmeter.cloud
export OPENMETER_API_ENDPOINT="" # defaults to https://openmeter.cloud
export OPENMETER_API_KEY=""
Schnellstart​
  1. Zur Config.yaml hinzufügen
model_list:
- litellm_params:
    api_base: https://openai-function-calling-workers.tasslexyz.workers.dev/
    api_key: my-fake-key
    model: openai/my-fake-model
  model_name: fake-openai-endpoint

litellm_settings:
  success_callback: ["openmeter"] # 👈 KEY CHANGE
  1. Proxy starten
litellm --config /path/to/config.yaml
  1. Testen Sie es!
curl --location 'http://0.0.0.0:4000/chat/completions' \
--header 'Content-Type: application/json' \
--data ' {
      "model": "fake-openai-endpoint",
      "messages": [
        {
          "role": "user",
          "content": "what llm are you"
        }
      ],
    }
'

DynamoDB​

Wir werden --config verwenden, um Folgendes einzustellen:

  • litellm.success_callback = ["dynamodb"]
  • litellm.dynamodb_table_name = "Ihr-Tabellenname"

Dies protokolliert alle erfolgreichen LLM-Aufrufe nach DynamoDB.

Schritt 1 AWS-Anmeldeinformationen in .env festlegen

AWS_ACCESS_KEY_ID = ""
AWS_SECRET_ACCESS_KEY = ""
AWS_REGION_NAME = ""

Schritt 2: Erstellen Sie eine config.yaml-Datei und legen Sie litellm_settings fest: success_callback

model_list:
 - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
litellm_settings:
  success_callback: ["dynamodb"]
  dynamodb_table_name: your-table-name

Schritt 3: Den Proxy starten, eine Testanfrage stellen

Proxy starten

litellm --config config.yaml --debug

Testanfrage

curl --location 'http://0.0.0.0:4000/chat/completions' \
    --header 'Content-Type: application/json' \
    --data ' {
    "model": "Azure OpenAI GPT-4 East",
    "messages": [
        {
        "role": "user",
        "content": "what llm are you"
        }
    ]
    }'

Ihre Protokolle sollten in DynamoDB verfügbar sein.

Daten, die nach DynamoDB /chat/completions protokolliert werden​

{
  "id": {
    "S": "chatcmpl-8W15J4480a3fAQ1yQaMgtsKJAicen"
  },
  "call_type": {
    "S": "acompletion"
  },
  "endTime": {
    "S": "2023-12-15 17:25:58.424118"
  },
  "messages": {
    "S": "[{'role': 'user', 'content': 'This is a test'}]"
  },
  "metadata": {
    "S": "{}"
  },
  "model": {
    "S": "gpt-3.5-turbo"
  },
  "modelParameters": {
    "S": "{'temperature': 0.7, 'max_tokens': 100, 'user': 'ishaan-2'}"
  },
  "response": {
    "S": "ModelResponse(id='chatcmpl-8W15J4480a3fAQ1yQaMgtsKJAicen', choices=[Choices(finish_reason='stop', index=0, message=Message(content='Great! What can I assist you with?', role='assistant'))], created=1702641357, model='gpt-3.5-turbo-0613', object='chat.completion', system_fingerprint=None, usage=Usage(completion_tokens=9, prompt_tokens=11, total_tokens=20))"
  },
  "startTime": {
    "S": "2023-12-15 17:25:56.047035"
  },
  "usage": {
    "S": "Usage(completion_tokens=9, prompt_tokens=11, total_tokens=20)"
  },
  "user": {
    "S": "ishaan-2"
  }
}

Daten, die nach DynamoDB /embeddings protokolliert werden​

{
  "id": {
    "S": "4dec8d4d-4817-472d-9fc6-c7a6153eb2ca"
  },
  "call_type": {
    "S": "aembedding"
  },
  "endTime": {
    "S": "2023-12-15 17:25:59.890261"
  },
  "messages": {
    "S": "['hi']"
  },
  "metadata": {
    "S": "{}"
  },
  "model": {
    "S": "text-embedding-ada-002"
  },
  "modelParameters": {
    "S": "{'user': 'ishaan-2'}"
  },
  "response": {
    "S": "EmbeddingResponse(model='text-embedding-ada-002-v2', data=[{'embedding': [-0.03503197431564331, -0.020601635798811913, -0.015375726856291294,
  }
}

Sentry​

Wenn API-Aufrufe fehlschlagen (LLM/Datenbank), können Sie diese nach Sentry protokollieren.

Schritt 1 Sentry installieren

pip install --upgrade sentry-sdk

Schritt 2: Speichern Sie Ihren Sentry_DSN und fügen Sie litellm_settings hinzu: failure_callback

export SENTRY_DSN="your-sentry-dsn"
model_list:
 - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
litellm_settings:
  # other settings
  failure_callback: ["sentry"]
general_settings: 
  database_url: "my-bad-url" # set a fake url to trigger a sentry exception

Schritt 3: Den Proxy starten, eine Testanfrage stellen

Proxy starten

litellm --config config.yaml --debug

Testanfrage

litellm --test

Athina​

Athina ermöglicht Ihnen, LLM-Ein-/Ausgaben für Überwachung, Analytik und Beobachtbarkeit zu protokollieren.

Wir verwenden --config, um litellm.success_callback = ["athina"] einzustellen. Dies protokolliert alle erfolgreichen LLM-Aufrufe nach Athina.

Schritt 1 Athina API-Schlüssel festlegen

ATHINA_API_KEY = "your-athina-api-key"

Schritt 2: Erstellen Sie eine config.yaml-Datei und legen Sie litellm_settings fest: success_callback

model_list:
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
litellm_settings:
  success_callback: ["athina"]

Schritt 3: Den Proxy starten, eine Testanfrage stellen

Proxy starten

litellm --config config.yaml --debug

Testanfrage

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": "which llm are you"
        }
    ]
    }'