Zum Hauptinhalt springen

Übersicht

Legen Sie Model-Liste, api_base, api_key, temperature & Proxy-Server-Einstellungen (master-key) in der config.yaml fest.

ParameternameBeschreibung
model_listListe der unterstützten Modelle auf dem Server mit modellspezifischen Konfigurationen
router_settingslitellm Router-Einstellungen, z.B. routing_strategy="least-busy" Alle anzeigen
litellm_settingslitellm Modul-Einstellungen, z.B. litellm.drop_params=True, litellm.set_verbose=True, litellm.api_base, litellm.cache Alle anzeigen
general_settingsServer-Einstellungen, z.B. master_key: sk-my_special_key
environment_variablesUmgebungsvariablen Beispiel, REDIS_HOST, REDIS_PORT

Vollständige Liste: Überprüfen Sie die Swagger UI-Dokumentation unter <your-proxy-url>/#/config.yaml (z.B. http://0.0.0.0:4000/#/config.yaml) für alles, was Sie in der config.yaml übergeben können.

Schnellstart​

Legen Sie einen Modellalias für Ihre Deployments fest.

In der config.yaml ist der Parameter model_name der benutzerseitige Name, der für Ihr Deployment verwendet werden soll.

In der folgenden Konfiguration

  • model_name: der Name, der von externen Clients an litellm übergeben wird
  • litellm_params.model: die Modellzeichenkette, die an die Funktion litellm.completion() übergeben wird

Z.B.

  • model=vllm-models wird zu openai/facebook/opt-125m weitergeleitet.
  • model=gpt-3.5-turbo wird zwischen azure/gpt-turbo-small-eu und azure/gpt-turbo-small-ca im Load Balancing verteilt.
model_list:
  - model_name: gpt-3.5-turbo ### RECEIVED MODEL NAME ###
    litellm_params: # all params accepted by litellm.completion() - https://docs.litellm.de/docs/completion/input
      model: azure/gpt-turbo-small-eu ### MODEL NAME sent to `litellm.completion()` ###
      api_base: https://my-endpoint-europe-berri-992.openai.azure.com/
      api_key: "os.environ/AZURE_API_KEY_EU" # does os.getenv("AZURE_API_KEY_EU")
      rpm: 6      # [OPTIONAL] Rate limit for this deployment: in requests per minute (rpm)
  - model_name: bedrock-claude-v1 
    litellm_params:
      model: bedrock/anthropic.claude-instant-v1
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: azure/gpt-turbo-small-ca
      api_base: https://my-endpoint-canada-berri992.openai.azure.com/
      api_key: "os.environ/AZURE_API_KEY_CA"
      rpm: 6
  - model_name: anthropic-claude
    litellm_params: 
      model: bedrock/anthropic.claude-instant-v1
      ### [OPTIONAL] SET AWS REGION ###
      aws_region_name: us-east-1
  - model_name: vllm-models
    litellm_params:
      model: openai/facebook/opt-125m # the `openai/` prefix tells litellm it's openai compatible
      api_base: http://0.0.0.0:4000/v1
      api_key: none
      rpm: 1440
    model_info: 
      version: 2
  
  # Use this if you want to make requests to `claude-3-haiku-20240307`,`claude-3-opus-20240229`,`claude-2.1` without defining them on the config.yaml
  # Default models
  # Works for ALL Providers and needs the default provider credentials in .env
  - model_name: "*" 
    litellm_params:
      model: "*"

litellm_settings: # module level litellm settings - https://github.com/BerriAI/litellm/blob/main/litellm/__init__.py
  drop_params: True
  success_callback: ["langfuse"] # OPTIONAL - if you want to start sending LLM Logs to Langfuse. Make sure to set `LANGFUSE_PUBLIC_KEY` and `LANGFUSE_SECRET_KEY` in your env

general_settings: 
  master_key: sk-1234 # [OPTIONAL] Only use this if you to require all calls to contain this key (Authorization: Bearer sk-1234)
  alerting: ["slack"] # [OPTIONAL] If you want Slack Alerts for Hanging LLM requests, Slow llm responses, Budget Alerts. Make sure to set `SLACK_WEBHOOK_URL` in your env
Info

Weitere Anbieter-spezifische Informationen finden Sie hier

Schritt 2: Proxy mit Konfiguration starten​

$ litellm --config /path/to/config.yaml
Tipp

Führen Sie mit --detailed_debug aus, wenn Sie detaillierte Debug-Logs benötigen

$ litellm --config /path/to/config.yaml --detailed_debug

Schritt 3: Testen​

Sendet eine Anfrage an das Modell, bei dem model_name=gpt-3.5-turbo in der config.yaml gesetzt ist.

Wenn mehrere mit model_name=gpt-3.5-turbo vorhanden sind, wird Load Balancing durchgeführt.

Langchain, OpenAI SDK Anwendungsbeispiele

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"
        }
      ],
    }
'

LLM-Konfigurationen model_list​

Modellspezifische Parameter (API-Basis, Schlüssel, Temperatur, Max. Tokens, Organisation, Header usw.)​

Sie können die Konfiguration verwenden, um modellspezifische Informationen wie api_base, api_key, temperature, max_tokens usw. zu speichern.

Alle Eingabeparameter

Schritt 1: Erstellen Sie eine Datei config.yaml

model_list:
  - model_name: gpt-4-team1
    litellm_params: # params for litellm.completion() - https://docs.litellm.de/docs/completion/input#input---request-body
      model: azure/chatgpt-v-2
      api_base: https://openai-gpt-4-test-v-1.openai.azure.com/
      api_version: "2023-05-15"
      azure_ad_token: eyJ0eXAiOiJ
      seed: 12
      max_tokens: 20
  - model_name: gpt-4-team2
    litellm_params:
      model: azure/gpt-4
      api_key: sk-123
      api_base: https://openai-gpt-4-test-v-2.openai.azure.com/
      temperature: 0.2
  - model_name: openai-gpt-3.5
    litellm_params:
      model: openai/gpt-3.5-turbo
      extra_headers: {"AI-Resource Group": "ishaan-resource"}
      api_key: sk-123
      organization: org-ikDc4ex8NB
      temperature: 0.2
  - model_name: mistral-7b
    litellm_params:
      model: ollama/mistral
      api_base: your_ollama_api_base

Schritt 2: Starten Sie den Server mit der Konfiguration

$ litellm --config /path/to/config.yaml

Erwartete Protokolle

Suchen Sie nach dieser Zeile in Ihren Konsolenprotokollen, um zu bestätigen, dass die config.yaml korrekt geladen wurde.

LiteLLM: Proxy initialized with Config, Set models:

Einbettungsmodelle - Verwenden Sie Sagemaker, Bedrock, Azure, OpenAI, XInference​

Unterstützte Einbettungsanbieter & Modelle finden Sie hier

model_list:
  - model_name: bedrock-cohere
    litellm_params:
      model: "bedrock/cohere.command-text-v14"
      aws_region_name: "us-west-2"
  - model_name: bedrock-cohere
    litellm_params:
      model: "bedrock/cohere.command-text-v14"
      aws_region_name: "us-east-2"
  - model_name: bedrock-cohere
    litellm_params:
      model: "bedrock/cohere.command-text-v14"
      aws_region_name: "us-east-1"

Proxy starten​

litellm --config config.yaml

Anfrage senden​

Sendet Anfrage an bedrock-cohere

curl --location 'http://0.0.0.0:4000/chat/completions' \
  --header 'Content-Type: application/json' \
  --data ' {
  "model": "bedrock-cohere",
  "messages": [
      {
      "role": "user",
      "content": "gm"
      }
  ]
}'

Mehrere OpenAI-Organisationen​

Fügen Sie alle OpenAI-Modelle aus allen OpenAI-Organisationen mit nur einer Modelldefinition hinzu

  - model_name: *
    litellm_params:
      model: openai/*
      api_key: os.environ/OPENAI_API_KEY
      organization:
       - org-1 
       - org-2 
       - org-3

LiteLLM erstellt automatisch separate Deployments für jede Organisation.

Bestätigen Sie dies über

curl --location 'http://0.0.0.0:4000/v1/model/info' \
--header 'Authorization: Bearer ${LITELLM_KEY}' \
--data ''

Load Balancing​

Info

Mehr dazu finden Sie auf dieser Seite.

Verwenden Sie dies, um mehrere Instanzen desselben Modells aufzurufen und Dinge wie die Routing-Strategie zu konfigurieren.

Für optimale Leistung

  • Legen Sie tpm/rpm pro Modell-Deployment fest. Die gewichteten Auswahlen basieren dann auf den festgelegten tpm/rpm.
  • Wählen Sie Ihre optimale Routing-Strategie in router_settings:routing_strategy.

LiteLLM unterstützt

["simple-shuffle", "least-busy", "usage-based-routing","latency-based-routing"], default="simple-shuffle"`

Wenn tpm/rpm gesetzt ist + routing_strategy==simple-shuffle, verwendet litellm eine gewichtete Auswahl basierend auf dem festgelegten tpm/rpm. In unseren Lasttests maximierte das Setzen von tpm/rpm für alle Deployments + routing_strategy==simple-shuffle den Durchsatz.

  • Wenn Sie mehrere LiteLLM-Server / Kubernetes verwenden, legen Sie die Redis-Einstellungen fest: router_settings:redis_host usw.
model_list:
  - model_name: zephyr-beta
    litellm_params:
        model: huggingface/HuggingFaceH4/zephyr-7b-beta
        api_base: http://0.0.0.0:8001
        rpm: 60      # Optional[int]: When rpm/tpm set - litellm uses weighted pick for load balancing. rpm = Rate limit for this deployment: in requests per minute (rpm).
        tpm: 1000   # Optional[int]: tpm = Tokens Per Minute 
  - model_name: zephyr-beta
    litellm_params:
        model: huggingface/HuggingFaceH4/zephyr-7b-beta
        api_base: http://0.0.0.0:8002
        rpm: 600      
  - model_name: zephyr-beta
    litellm_params:
        model: huggingface/HuggingFaceH4/zephyr-7b-beta
        api_base: http://0.0.0.0:8003
        rpm: 60000      
  - model_name: gpt-3.5-turbo
    litellm_params:
        model: gpt-3.5-turbo
        api_key: <my-openai-key>
        rpm: 200      
  - model_name: gpt-3.5-turbo-16k
    litellm_params:
        model: gpt-3.5-turbo-16k
        api_key: <my-openai-key>
        rpm: 100      

litellm_settings:
  num_retries: 3 # retry call 3 times on each model_name (e.g. zephyr-beta)
  request_timeout: 10 # raise Timeout error if call takes longer than 10s. Sets litellm.request_timeout 
  fallbacks: [{"zephyr-beta": ["gpt-3.5-turbo"]}] # fallback to gpt-3.5-turbo if call fails num_retries 
  context_window_fallbacks: [{"zephyr-beta": ["gpt-3.5-turbo-16k"]}, {"gpt-3.5-turbo": ["gpt-3.5-turbo-16k"]}] # fallback to gpt-3.5-turbo-16k if context window error
  allowed_fails: 3 # cooldown model if it fails > 1 call in a minute. 

router_settings: # router_settings are optional
  routing_strategy: simple-shuffle # Literal["simple-shuffle", "least-busy", "usage-based-routing","latency-based-routing"], default="simple-shuffle"
  model_group_alias: {"gpt-4": "gpt-3.5-turbo"} # all requests with `gpt-4` will be routed to models with `gpt-3.5-turbo`
  num_retries: 2
  timeout: 30                                  # 30 seconds
  redis_host: <your redis host>                # set this when using multiple litellm proxy deployments, load balancing state stored in redis
  redis_password: <your redis password>
  redis_port: 1992

Sie können Ihre Kosten einsehen, sobald Sie virtuelle Schlüssel oder custom_callbacks eingerichtet haben.

Laden von API-Schlüsseln / Konfigurationswerten aus Umgebungsvariablen​

Wenn Sie Geheimnisse in Ihrer Umgebung gespeichert haben und diese nicht in der config.yaml preisgeben möchten, können Sie modellspezifische Schlüssel aus der Umgebung laden. Dies funktioniert für JEDEN Wert in der config.yaml.

os.environ/<YOUR-ENV-VAR> # runs os.getenv("YOUR-ENV-VAR")
model_list:
  - model_name: gpt-4-team1
    litellm_params: # params for litellm.completion() - https://docs.litellm.de/docs/completion/input#input---request-body
      model: azure/chatgpt-v-2
      api_base: https://openai-gpt-4-test-v-1.openai.azure.com/
      api_version: "2023-05-15"
      api_key: os.environ/AZURE_NORTH_AMERICA_API_KEY # 👈 KEY CHANGE

Code anzeigen

Danke an @David Manouchehri für die Hilfe dabei.

Zentralisierte Credential-Verwaltung​

Definieren Sie Anmeldedaten einmal und verwenden Sie sie für mehrere Modelle. Dies hilft bei

  • Geheimnisrotation
  • Reduzierung von Konfigurationsduplikaten
model_list:
  - model_name: gpt-4o
    litellm_params:
      model: azure/gpt-4o
      litellm_credential_name: default_azure_credential  # Reference credential below

credential_list:
  - credential_name: default_azure_credential
    credential_values:
      api_key: os.environ/AZURE_API_KEY  # Load from environment
      api_base: os.environ/AZURE_API_BASE
      api_version: "2023-05-15"
    credential_info:
      description: "Production credentials for EU region"

Schlüsselparameter​

  • credential_name: Eindeutiger Identifikator für den Anmeldedatensatz
  • credential_values: Schlüssel-Wert-Paare von Anmeldedaten/Geheimnissen (unterstützt os.environ/ Syntax)
  • credential_info: Schlüssel-Wert-Paare von benutzergestellten Anmeldeinformationen. Keine Schlüssel-Wert-Paare erforderlich, aber das Wörterbuch muss vorhanden sein.

Laden von API-Schlüsseln aus Geheimnismanagern (Azure Vault usw.)​

Verwendung von Geheimnismanagern mit LiteLLM Proxy

Unterstützte Umgebungen für ein Modell festlegen - production, staging, development​

Verwenden Sie dies, wenn Sie steuern möchten, welches Modell in einer bestimmten litellm-Umgebung verfügbar gemacht wird

Unterstützte Umgebungen

  • production
  • staging
  • development
  1. Setzen Sie LITELLM_ENVIRONMENT="<environment>" in Ihrer Umgebung. Kann production, staging oder development sein.
  1. Legen Sie für jedes Modell die Liste der unterstützten Umgebungen in model_info.supported_environments fest.
model_list:
 - model_name: gpt-3.5-turbo
   litellm_params:
     model: openai/gpt-3.5-turbo
     api_key: os.environ/OPENAI_API_KEY
   model_info:
     supported_environments: ["development", "production", "staging"]
 - model_name: gpt-4
   litellm_params:
     model: openai/gpt-4
     api_key: os.environ/OPENAI_API_KEY
   model_info:
     supported_environments: ["production", "staging"]
 - model_name: gpt-4o
   litellm_params:
     model: openai/gpt-4o
     api_key: os.environ/OPENAI_API_KEY
   model_info:
     supported_environments: ["production"]

Benutzerdefinierte Prompt-Vorlagen festlegen​

LiteLLM prüft standardmäßig, ob ein Modell über eine Prompt-Vorlage verfügt und wendet diese an (z.B. wenn ein Huggingface-Modell eine gespeicherte Chat-Vorlage in seiner tokenizer_config.json hat). Sie können jedoch auch eine benutzerdefinierte Prompt-Vorlage in Ihrer Proxy-Konfiguration in der config.yaml festlegen.

Schritt 1: Speichern Sie Ihre Prompt-Vorlage in einer config.yaml

# Model-specific parameters
model_list:
  - model_name: mistral-7b # model alias
    litellm_params: # actual params for litellm.completion()
      model: "huggingface/mistralai/Mistral-7B-Instruct-v0.1" 
      api_base: "<your-api-base>"
      api_key: "<your-api-key>" # [OPTIONAL] for hf inference endpoints
      initial_prompt_value: "\n"
      roles: {"system":{"pre_message":"<|im_start|>system\n", "post_message":"<|im_end|>"}, "assistant":{"pre_message":"<|im_start|>assistant\n","post_message":"<|im_end|>"}, "user":{"pre_message":"<|im_start|>user\n","post_message":"<|im_end|>"}}
      final_prompt_value: "\n"
      bos_token: " "
      eos_token: " "
      max_tokens: 4096

Schritt 2: Starten Sie den Server mit der Konfiguration

$ litellm --config /path/to/config.yaml

Benutzerdefinierten Tokenizer festlegen​

Wenn Sie den /utils/token_counter Endpunkt verwenden und einen benutzerdefinierten Huggingface-Tokenizer für ein Modell festlegen möchten, können Sie dies in der config.yaml tun.

model_list:
  - model_name: openai-deepseek
    litellm_params:
      model: deepseek/deepseek-chat
      api_key: os.environ/OPENAI_API_KEY
    model_info:
      access_groups: ["restricted-models"]
      custom_tokenizer: 
        identifier: deepseek-ai/DeepSeek-V3-Base
        revision: main
        auth_token: os.environ/HUGGINGFACE_API_KEY

Spezifikation

custom_tokenizer: 
  identifier: str # huggingface model identifier
  revision: str # huggingface model revision (usually 'main')
  auth_token: Optional[str] # huggingface auth token

Allgemeine Einstellungen general_settings (DB-Verbindung usw.)​

Datenbank-Pool-Limits + Verbindungs-Timeouts konfigurieren​

general_settings: 
  database_connection_pool_limit: 100 # sets connection pool for prisma client to postgres db at 100
  database_connection_timeout: 60 # sets a 60s timeout for any connection call to the db

Extras​

Swagger UI deaktivieren​

Um die Swagger-Dokumentation von der Basis-URL zu deaktivieren, setzen Sie

NO_DOCS="True"

in Ihrer Umgebung und starten Sie den Proxy neu.

CONFIG_FILE_PATH für Proxy verwenden (einfachere Azure-Container-Bereitstellung)​

  1. Konfigurieren Sie config.yaml
model_list:
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
      api_key: os.environ/OPENAI_API_KEY
  1. Dateipfad als Umgebungsvariable speichern
CONFIG_FILE_PATH="/path/to/config.yaml"
  1. Proxy starten
$ litellm 

# RUNNING on http://0.0.0.0:4000

LiteLLM config.yaml-Datei als S3-, GCS-Bucket-Objekt/URL bereitstellen​

Verwenden Sie dies, wenn Sie eine Konfigurationsdatei nicht auf Ihrem Bereitstellungsdienst montieren können (Beispiel: AWS Fargate, Railway usw.)

LiteLLM Proxy liest Ihre config.yaml aus einem S3-Bucket oder GCS-Bucket.

Legen Sie die folgenden .env-Variablen fest

LITELLM_CONFIG_BUCKET_TYPE = "gcs"                              # set this to "gcs"         
LITELLM_CONFIG_BUCKET_NAME = "litellm-proxy"                    # your bucket name on GCS
LITELLM_CONFIG_BUCKET_OBJECT_KEY = "proxy_config.yaml"         # object key on GCS

Starten Sie den litellm-Proxy mit diesen Umgebungsvariablen – litellm liest Ihre Konfiguration aus GCS.

docker run --name litellm-proxy \
   -e DATABASE_URL=<database_url> \
   -e LITELLM_CONFIG_BUCKET_NAME=<bucket_name> \
   -e LITELLM_CONFIG_BUCKET_OBJECT_KEY="<object_key>> \
   -e LITELLM_CONFIG_BUCKET_TYPE="gcs" \
   -p 4000:4000 \
   ghcr.io/berriai/litellm-database:main-latest --detailed_debug