Zum Hauptinhalt springen

Caching

Hinweis

Für OpenAI/Anthropic Prompt Caching, gehen Sie hier

LLM-Antworten cachen. Das Caching-System von LiteLLM speichert und wiederverwendet LLM-Antworten, um Kosten zu sparen und die Latenz zu reduzieren. Wenn Sie dieselbe Anfrage zweimal stellen, wird die gecachte Antwort zurückgegeben, anstatt die LLM-API erneut aufzurufen.

Unterstützte Caches​

  • In-Memory-Cache
  • Festplatten-Cache
  • Redis-Cache
  • Qdrant Semantischer Cache
  • Redis Semantischer Cache
  • S3-Bucket-Cache

Schnellstart​

Caching kann durch Hinzufügen des Schlüssels cache in der config.yaml aktiviert werden.

Schritt 1: cache zur config.yaml hinzufügen​

model_list:
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
  - model_name: text-embedding-ada-002
    litellm_params:
      model: text-embedding-ada-002

litellm_settings:
  set_verbose: True
  cache: True          # set cache responses to True, litellm defaults to using a redis cache

[OPTIONAL]Schritt 1.5: Redis-Namensräume, Standard-TTL hinzufügen​

Namensraum​

Wenn Sie Ordner für Ihre Schlüssel erstellen möchten, können Sie einen Namensraum festlegen, z. B.:

litellm_settings:
  cache: true 
  cache_params:        # set cache params for redis
    type: redis
    namespace: "litellm.caching.caching"

Und Schlüssel werden gespeichert wie:

litellm.caching.caching:<hash>

Redis Cluster​

model_list:
  - model_name: "*"
    litellm_params:
      model: "*"


litellm_settings:
  cache: True
  cache_params:
    type: redis
    redis_startup_nodes: [{"host": "127.0.0.1", "port": "7001"}]

Redis Sentinel​

model_list:
  - model_name: "*"
    litellm_params:
      model: "*"


litellm_settings:
  cache: true
  cache_params:
    type: "redis"
    service_name: "mymaster"
    sentinel_nodes: [["localhost", 26379]]
    sentinel_password: "password" # [OPTIONAL]

TTL​

litellm_settings:
  cache: true 
  cache_params:        # set cache params for redis
    type: redis
    ttl: 600 # will be cached on redis for 600s
    # default_in_memory_ttl: Optional[float], default is None. time in seconds. 
    # default_in_redis_ttl: Optional[float], default is None. time in seconds.

SSL​

Setzen Sie einfach REDIS_SSL="True" in Ihrer .env, und LiteLLM wird dies erkennen.

REDIS_SSL="True"

Für schnelles Testen können Sie auch REDIS_URL verwenden, z. B.:

REDIS_URL="rediss://.."

Wir empfehlen jedoch, REDIS_URL nicht in der Produktion zu verwenden. Wir haben einen Leistungsunterschied zwischen der Verwendung von REDIS_URL und redis_host, port usw. festgestellt.

Schritt 2: Redis-Zugangsdaten zu .env hinzufügen​

Setzen Sie entweder REDIS_URL oder REDIS_HOST in Ihrer OS-Umgebung, um das Caching zu aktivieren.

REDIS_URL = ""        # REDIS_URL='redis://username:password@hostname:port/database'
## OR ## 
REDIS_HOST = ""       # REDIS_HOST='redis-18841.c274.us-east-1-3.ec2.cloud.redislabs.com'
REDIS_PORT = ""       # REDIS_PORT='18841'
REDIS_PASSWORD = ""   # REDIS_PASSWORD='liteLlmIsAmazing'

Zusätzliche kwargs
Sie können beliebige zusätzliche redis.Redis-Argumente übergeben, indem Sie die Variable + den Wert in Ihrer OS-Umgebung speichern, z. B.:

REDIS_<redis-kwarg-name> = ""

Sehen Sie, wie es aus der Umgebung gelesen wird.

Schritt 3: Proxy mit Konfiguration ausführen​

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

Verwendung​

Grundlegend​

Senden Sie dieselbe Anfrage zweimal

curl http://0.0.0.0:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
     "model": "gpt-3.5-turbo",
     "messages": [{"role": "user", "content": "write a poem about litellm!"}],
     "temperature": 0.7
   }'

curl http://0.0.0.0:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
     "model": "gpt-3.5-turbo",
     "messages": [{"role": "user", "content": "write a poem about litellm!"}],
     "temperature": 0.7
   }'

Dynamische Cache-Steuerungen​

ParameterTypBeschreibung
ttlOptional (int)Speichert die Antwort für die vom Benutzer definierte Zeit (in Sekunden).
s-maxageOptional (int)Akzeptiert nur gecachte Antworten, die innerhalb des vom Benutzer definierten Bereichs liegen (in Sekunden).
no-cacheOptional (bool)Speichert die Antwort nicht im Cache.
no-storeOptional (bool)Speichert die Antwort nicht.
namespaceOptional (str)Speichert die Antwort unter einem vom Benutzer definierten Namensraum.

Jeder Cache-Parameter kann pro Anfrage gesteuert werden. Hier sind Beispiele für jeden Parameter:

ttl​

Legt fest, wie lange (in Sekunden) eine Antwort gecached werden soll.

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="http://0.0.0.0:4000"
)

chat_completion = client.chat.completions.create(
    messages=[{"role": "user", "content": "Hello"}],
    model="gpt-3.5-turbo",
    extra_body={
        "cache": {
            "ttl": 300  # Cache response for 5 minutes
        }
    }
)

s-maxage​

Akzeptiert nur gecachte Antworten, die innerhalb des angegebenen Alters (in Sekunden) liegen.

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="http://0.0.0.0:4000"
)

chat_completion = client.chat.completions.create(
    messages=[{"role": "user", "content": "Hello"}],
    model="gpt-3.5-turbo",
    extra_body={
        "cache": {
            "s-maxage": 600  # Only use cache if less than 10 minutes old
        }
    }
)

no-cache​

Erzwingt eine frische Antwort und umgeht den Cache.

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="http://0.0.0.0:4000"
)

chat_completion = client.chat.completions.create(
    messages=[{"role": "user", "content": "Hello"}],
    model="gpt-3.5-turbo",
    extra_body={
        "cache": {
            "no-cache": True  # Skip cache check, get fresh response
        }
    }
)

no-store​

Speichert die Antwort nicht im Cache.

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="http://0.0.0.0:4000"
)

chat_completion = client.chat.completions.create(
    messages=[{"role": "user", "content": "Hello"}],
    model="gpt-3.5-turbo",
    extra_body={
        "cache": {
            "no-store": True  # Don't cache this response
        }
    }
)

namespace​

Speichert die Antwort unter einem bestimmten Cache-Namensraum.

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="http://0.0.0.0:4000"
)

chat_completion = client.chat.completions.create(
    messages=[{"role": "user", "content": "Hello"}],
    model="gpt-3.5-turbo",
    extra_body={
        "cache": {
            "namespace": "my-custom-namespace"  # Store in custom namespace
        }
    }
)

Cache für Proxy festlegen, aber nicht für den tatsächlichen LLM-API-Aufruf​

Verwenden Sie dies, wenn Sie nur Funktionen wie Ratenbegrenzung und Lastverteilung über mehrere Instanzen hinweg aktivieren möchten.

Setzen Sie supported_call_types: [], um das Caching beim tatsächlichen API-Aufruf zu deaktivieren.

litellm_settings:
  cache: True
  cache_params:
    type: redis
    supported_call_types: []

Caching debuggen - /cache/ping​

LiteLLM Proxy stellt einen Endpunkt /cache/ping bereit, um zu testen, ob der Cache wie erwartet funktioniert.

Verwendung

curl --location 'http://0.0.0.0:4000/cache/ping'  -H "Authorization: Bearer sk-1234"

Erwartete Antwort - wenn Cache fehlerfrei ist

{
    "status": "healthy",
    "cache_type": "redis",
    "ping_response": true,
    "set_cache_response": "success",
    "litellm_cache_params": {
        "supported_call_types": "['completion', 'acompletion', 'embedding', 'aembedding', 'atranscription', 'transcription']",
        "type": "redis",
        "namespace": "None"
    },
    "redis_cache_params": {
        "redis_client": "Redis<ConnectionPool<Connection<host=redis-16337.c322.us-east-1-2.ec2.cloud.redislabs.com,port=16337,db=0>>>",
        "redis_kwargs": "{'url': 'redis://:******@redis-16337.c322.us-east-1-2.ec2.cloud.redislabs.com:16337'}",
        "async_redis_conn_pool": "BlockingConnectionPool<Connection<host=redis-16337.c322.us-east-1-2.ec2.cloud.redislabs.com,port=16337,db=0>>",
        "redis_version": "7.2.0"
    }
}

Erweitert​

Steuern Sie, für welche Aufruftypen das Caching aktiviert ist - (/chat/completion, /embeddings, usw.)​

Standardmäßig ist das Caching für alle Aufruftypen aktiviert. Sie können steuern, für welche Aufruftypen das Caching aktiviert ist, indem Sie supported_call_types in cache_params festlegen.

Der Cache ist nur für die in supported_call_types angegebenen Aufruftypen aktiviert.

litellm_settings:
  cache: True
  cache_params:
    type: redis
    supported_call_types: ["acompletion", "atext_completion", "aembedding", "atranscription"]
                          # /chat/completions, /completions, /embeddings, /audio/transcriptions

Cache-Parameter in config.yaml festlegen​

model_list:
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
  - model_name: text-embedding-ada-002
    litellm_params:
      model: text-embedding-ada-002

litellm_settings:
  set_verbose: True
  cache: True          # set cache responses to True, litellm defaults to using a redis cache
  cache_params:         # cache_params are optional
    type: "redis"  # The type of cache to initialize. Can be "local" or "redis". Defaults to "local".
    host: "localhost"  # The host address for the Redis cache. Required if type is "redis".
    port: 6379  # The port number for the Redis cache. Required if type is "redis".
    password: "your_password"  # The password for the Redis cache. Required if type is "redis".
    
    # Optional configurations
    supported_call_types: ["acompletion", "atext_completion", "aembedding", "atranscription"]
                      # /chat/completions, /completions, /embeddings, /audio/transcriptions

Cache-Schlüssel löschen - /cache/delete​

Um einen Cache-Schlüssel zu löschen, senden Sie eine Anfrage an /cache/delete mit den keys, die Sie löschen möchten.

Beispiel

curl -X POST "http://0.0.0.0:4000/cache/delete" \
  -H "Authorization: Bearer sk-1234" \
  -d '{"keys": ["586bf3f3c1bf5aecb55bd9996494d3bbc69eb58397163add6d49537762a7548d", "key2"]}'
# {"status":"success"}

Cache-Schlüssel aus Antworten anzeigen​

Sie können den cache_key in den Antwortheadern sehen. Bei Cache-Treffern wird der cache key als x-litellm-cache-key Antwortheader gesendet.

curl -i --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",
    "user": "ishan",
    "messages": [
        {
        "role": "user",
        "content": "what is litellm"
        }
    ],
}'

Antwort vom LiteLLM-Proxy

date: Thu, 04 Apr 2024 17:37:21 GMT
content-type: application/json
x-litellm-cache-key: 586bf3f3c1bf5aecb55bd9996494d3bbc69eb58397163add6d49537762a7548d

{
    "id": "chatcmpl-9ALJTzsBlXR9zTxPvzfFFtFbFtG6T",
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "message": {
                "content": "I'm sorr.."
                "role": "assistant"
            }
        }
    ],
    "created": 1712252235,
}

Caching standardmäßig deaktivieren - Nur Opt-in​

  1. Setzen Sie mode: default_off für Caching.
model_list:
  - model_name: fake-openai-endpoint
    litellm_params:
      model: openai/fake
      api_key: fake-key
      api_base: https://exampleopenaiendpoint-production.up.railway.app/

# default off mode
litellm_settings:
  set_verbose: True
  cache: True
  cache_params:
    mode: default_off # 👈 Key change cache is default_off
  1. Opt-in zum Caching, wenn der Cache standardmäßig deaktiviert ist
import os
from openai import OpenAI

client = OpenAI(api_key=<litellm-api-key>, base_url="http://0.0.0.0:4000")

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "Say this is a test",
        }
    ],
    model="gpt-3.5-turbo",
    extra_body = {        # OpenAI python accepts extra args in extra_body
        "cache": {"use-cache": True}
    }
)

batch_redis_requests aktivieren​

Was es tut? Wenn eine Anfrage gestellt wird:

  • Prüfen Sie, ob ein Schlüssel, der mit litellm:<hashed_api_key>:<call_type>: beginnt, im Speicher vorhanden ist. Wenn nicht, rufen Sie die letzten 100 gecachten Anfragen für diesen Schlüssel ab und speichern Sie sie.

  • Neue Anfragen werden mit diesem litellm:.. als Namensraum gespeichert.

Warum? Reduziert die Anzahl der Redis GET-Anfragen. Dies verbesserte die Latenz in Produktions-Load-Tests um 46 %.

Verwendung

litellm_settings:
  cache: true
  cache_params:
    type: redis
    ... # remaining redis args (host, port, etc.)
  callbacks: ["batch_redis_requests"] # 👈 KEY CHANGE!

CODE ANZEIGEN

Unterstützte cache_params in der Proxy-Konfiguration config.yaml​

cache_params:
  # ttl 
  ttl: Optional[float]
  default_in_memory_ttl: Optional[float]
  default_in_redis_ttl: Optional[float]

  # Type of cache (options: "local", "redis", "s3")
  type: s3

  # List of litellm call types to cache for
  # Options: "completion", "acompletion", "embedding", "aembedding"
  supported_call_types: ["acompletion", "atext_completion", "aembedding", "atranscription"]
                      # /chat/completions, /completions, /embeddings, /audio/transcriptions

  # Redis cache parameters
  host: localhost  # Redis server hostname or IP address
  port: "6379"  # Redis server port (as a string)
  password: secret_password  # Redis server password
  namespace: Optional[str] = None,
  

  # S3 cache parameters
  s3_bucket_name: your_s3_bucket_name  # Name of the S3 bucket
  s3_region_name: us-west-2  # AWS region of the S3 bucket
  s3_api_version: 2006-03-01  # AWS S3 API version
  s3_use_ssl: true  # Use SSL for S3 connections (options: true, false)
  s3_verify: true  # SSL certificate verification for S3 connections (options: true, false)
  s3_endpoint_url: https://s3.amazonaws.com  # S3 endpoint URL
  s3_aws_access_key_id: your_access_key  # AWS Access Key ID for S3
  s3_aws_secret_access_key: your_secret_key  # AWS Secret Access Key for S3
  s3_aws_session_token: your_session_token  # AWS Session Token for temporary credentials

Erweitert - Cache-TTL für Benutzer-API-Schlüssel​

Konfigurieren Sie, wie lange der In-Memory-Cache das Schlüsselobjekt speichert (verhindert Datenbankanfragen).

general_settings:
  user_api_key_cache_ttl: <your-number> #time in seconds

Standardmäßig ist dieser Wert auf 60 Sekunden eingestellt.