缓存

缓存LLM响应

note

关于OpenAI/Anthropic提示缓存，请前往这里

LiteLLM支持：

内存缓存
Redis缓存
Qdrant语义缓存
Redis语义缓存
s3存储桶缓存

快速开始 - Redis、s3缓存、语义缓存

redis缓存
Qdrant 语义缓存
s3 缓存
redis 语义缓存

通过在config.yaml中添加cache键可以启用缓存。

步骤1：将`cache`添加到config.yaml

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          # 将缓存响应设置为True，litellm默认使用redis缓存

[可选] 步骤1.5：添加redis命名空间，默认ttl

命名空间

如果你想为你的键创建一些文件夹，你可以设置一个命名空间，像这样：

litellm_settings:
  cache: true 
  cache_params:        # 为redis设置缓存参数
    type: redis
    namespace: "litellm.caching.caching"

并且键将被存储为：

litellm.caching.caching:<hash>

Redis集群

在config.yaml中设置
在.env中设置

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

你可以在你的.env中通过设置REDIS_CLUSTER_NODES来配置redis集群。

示例REDIS_CLUSTER_NODES值

REDIS_CLUSTER_NODES = "[{"host": "127.0.0.1", "port": "7001"}, {"host": "127.0.0.1", "port": "7003"}, {"host": "127.0.0.1", "port": "7004"}, {"host": "127.0.0.1", "port": "7005"}, {"host": "127.0.0.1", "port": "7006"}, {"host": "127.0.0.1", "port": "7007"}]"

note

示例python脚本用于在.env中设置redis集群节点：

# 启动节点列表
startup_nodes = [
    {"host": "127.0.0.1", "port": "7001"},
    {"host": "127.0.0.1", "port": "7003"},
    {"host": "127.0.0.1", "port": "7004"},
    {"host": "127.0.0.1", "port": "7005"},
    {"host": "127.0.0.1", "port": "7006"},
    {"host": "127.0.0.1", "port": "7007"},
]

# 在环境变量中设置启动节点
os.environ["REDIS_CLUSTER_NODES"] = json.dumps(startup_nodes)
print("REDIS_CLUSTER_NODES", os.environ["REDIS_CLUSTER_NODES"])

Redis哨兵

在config.yaml中设置
在.env中设置

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


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

你可以在你的.env中通过设置REDIS_SENTINEL_NODES来配置redis哨兵。

示例REDIS_SENTINEL_NODES值

REDIS_SENTINEL_NODES='[["localhost", 26379]]'
REDIS_SERVICE_NAME = "mymaster"

note

示例python脚本用于在.env中设置redis集群节点：

# 启动节点列表
sentinel_nodes = [["localhost", 26379]]

# 在环境变量中设置启动节点
os.environ["REDIS_SENTINEL_NODES"] = json.dumps(sentinel_nodes)
print("REDIS_SENTINEL_NODES", os.environ["REDIS_SENTINEL_NODES"])

TTL

litellm_settings:
  cache: true 
  cache_params:        # 为redis设置缓存参数
    type: redis
    ttl: 600 # 将在redis中缓存600秒
    # default_in_memory_ttl: Optional[float], 默认是None。时间以秒为单位。
    # default_in_redis_ttl: Optional[float], 默认是None。时间以秒为单位。

SSL

只需在你的.env中设置REDIS_SSL="True"，LiteLLM将自动获取此设置。

REDIS_SSL="True"

为了快速测试，你也可以使用REDIS_URL，例如：

REDIS_URL="rediss://.."

但我们不推荐在生产环境中使用REDIS_URL。我们注意到使用它与redis_host、端口等相比存在性能差异。

步骤2：将Redis凭证添加到.env

设置REDIS_URL或REDIS_HOST在你的操作系统环境中，以启用缓存。

REDIS_URL = ""        # REDIS_URL='redis://username:password@hostname:port/database'
## 或者 ## 
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'

附加参数
你可以通过将变量+值存储在你的操作系统环境中来传递任何额外的redis.Redis参数，像这样：

REDIS_<redis-kwarg-name> = ""

查看如何从环境中读取配置

第三步：使用配置运行代理

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

可以通过在 config.yaml 中添加 cache 键来启用缓存

第一步：在 config.yaml 中添加 `cache`

model_list:
  - model_name: fake-openai-endpoint
    litellm_params:
      model: openai/fake
      api_key: fake-key
      api_base: https://exampleopenaiendpoint-production.up.railway.app/
  - model_name: openai-embedding
    litellm_params:
      model: openai/text-embedding-3-small
      api_key: os.environ/OPENAI_API_KEY

litellm_settings:
  set_verbose: True
  cache: True          # 将缓存响应设置为 True，litellm 默认使用 redis 缓存
  cache_params:
    type: qdrant-semantic
    qdrant_semantic_cache_embedding_model: openai-embedding # 该模型应在 model_list 中定义
    qdrant_collection_name: test_collection
    qdrant_quantization_config: binary
    similarity_threshold: 0.8   # 语义缓存的相似度阈值

第二步：将 Qdrant 凭证添加到 .env

QDRANT_API_KEY = "16rJUMBRx*************"
QDRANT_API_BASE = "https://5392d382-45*********.cloud.qdrant.io"

第三步：使用配置运行代理

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

第四步：测试

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

当启用语义缓存时，预期会在响应头中看到 x-litellm-semantic-similarity

第一步：在 config.yaml 中添加 `cache`

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          # 将缓存响应设置为 True
  cache_params:        # 设置 s3 的缓存参数
    type: s3
    s3_bucket_name: cache-bucket-litellm   # AWS S3 的存储桶名称
    s3_region_name: us-west-2              # AWS S3 的区域名称
    s3_aws_access_key_id: os.environ/AWS_ACCESS_KEY_ID  # 使用 os.environ/<变量名> 传递环境变量。这是 AWS S3 的访问密钥 ID
    s3_aws_secret_access_key: os.environ/AWS_SECRET_ACCESS_KEY  # AWS S3 的秘密访问密钥
    s3_endpoint_url: https://s3.amazonaws.com  # [可选] S3 端点 URL，如果你想使用 Backblaze/cloudflare 的 s3 存储桶

第二步：使用配置运行代理

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

可以通过在 config.yaml 中添加 cache 键来启用缓存

第一步：在 config.yaml 中添加 `cache`

model_list:
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: gpt-3.5-turbo
  - model_name: azure-embedding-model
    litellm_params:
      model: azure/azure-embedding-model
      api_base: os.environ/AZURE_API_BASE
      api_key: os.environ/AZURE_API_KEY
      api_version: "2023-07-01-preview"

litellm_settings:
  set_verbose: True
  cache: True          # 将缓存响应设置为 True，litellm 默认使用 redis 缓存
  cache_params:
    type: "redis-semantic"  
    similarity_threshold: 0.8   # 语义缓存的相似度阈值
    redis_semantic_cache_embedding_model: azure-embedding-model # 设置为 model_list 中定义的模型名称

第二步：将 Redis 凭证添加到 .env

在操作系统环境中设置 REDIS_URL 或 REDIS_HOST 以启用缓存。

REDIS_URL = ""        # REDIS_URL='redis://username:password@hostname:port/database'
## 或 ## 
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'

其他关键字参数
你可以通过将变量和值存储在你的操作系统环境中来传递任何额外的 redis.Redis 参数，如下所示：

REDIS_<redis-kwarg-name> = ""

第三步：使用配置运行代理

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

使用缓存 - /chat/completions

/chat/completions
/embeddings

发送两次相同的请求：

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": "写一首关于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": "写一首关于litellm的诗!"}],
     "temperature": 0.7
   }'

发送相同的请求两次：

curl --location 'http://0.0.0.0:4000/embeddings' \
  --header 'Content-Type: application/json' \
  --data ' {
  "model": "text-embedding-ada-002",
  "input": ["write a litellm poem"]
  }'

curl --location 'http://0.0.0.0:4000/embeddings' \
  --header 'Content-Type: application/json' \
  --data ' {
  "model": "text-embedding-ada-002",
  "input": ["write a litellm poem"]
  }'

为代理设置缓存，但在实际的LLM API调用中不启用缓存

如果您只想启用速率限制、在多个实例之间进行负载均衡等功能，请使用此选项。

设置 supported_call_types: [] 以禁用在实际API调用中的缓存。

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

调试缓存 - `/cache/ping`

LiteLLM Proxy 暴露了一个 /cache/ping 端点来测试缓存是否按预期工作

使用方法

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

预期响应 - 当缓存健康时

{
    "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"
    }
}

高级设置

控制缓存启用的调用类型 - (`/chat/completion`, `/embeddings`, 等)

默认情况下，所有调用类型的缓存都启用。您可以通过在 cache_params 中设置 supported_call_types 来控制哪些调用类型的缓存启用。

缓存将仅对 supported_call_types 中指定的调用类型启用

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

在 config.yaml 中设置缓存参数

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          # 将缓存响应设置为 True，litellm 默认使用 redis 缓存
  cache_params:         # cache_params 是可选的
    type: "redis"  # 要初始化的缓存类型。可以是 "local" 或 "redis"。默认为 "local"。
    host: "localhost"  # Redis 缓存的主机地址。如果类型是 "redis"，则必需。
    port: 6379  # Redis 缓存的端口号。如果类型是 "redis"，则必需。
    password: "your_password"  # Redis 缓存的密码。如果类型是 "redis"，则必需。
    
    # 可选配置
    supported_call_types: ["acompletion", "atext_completion", "aembedding", "atranscription"]
                      # /chat/completions, /completions, /embeddings, /audio/transcriptions

按请求启用/禁用缓存

代理支持4种缓存控制：

ttl: 可选(int) - 将响应缓存用户定义的时间量（以秒为单位）。
s-maxage: 可选(int) 仅接受在用户定义范围内的缓存响应（以秒为单位）。
no-cache: 可选(bool) 不会返回缓存响应，而是调用实际端点。
no-store: 可选(bool) 不会缓存响应。

如果您需要更多功能，请告诉我们

关闭缓存

设置 no-cache=True，这将不会返回缓存响应

OpenAI Python SDK
curl

import os
from openai import OpenAI

client = OpenAI(
    # 这是默认值，可以省略
    api_key=os.environ.get("OPENAI_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 在 extra_body 中接受额外参数
        cache: {
          "no-cache": True # 不会返回缓存响应
      }
    }
)

curl http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-1234" \
  -d '{
    "model": "gpt-3.5-turbo",
    "cache": {"no-cache": True},
    "messages": [
      {"role": "user", "content": "说这是一个测试"}
    ]
  }'

开启缓存

默认情况下，缓存始终处于开启状态

OpenAI Python SDK
curl

import os
from openai import OpenAI

client = OpenAI(
    # 这是默认设置，可以省略
    api_key=os.environ.get("OPENAI_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"
)

curl http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-1234" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [
      {"role": "user", "content": "Say this is a test"}
    ]
  }'

设置 ttl

设置 ttl=600，这将缓存响应 10 分钟（600 秒）

OpenAI Python SDK
curl

import os
from openai import OpenAI

client = OpenAI(
    # 这是默认设置，可以省略
    api_key=os.environ.get("OPENAI_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 在 extra_body 中接受额外参数
        cache: {
          "ttl": 600 # 缓存响应 10 分钟 
      }
    }
)

curl http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-1234" \
  -d '{
    "model": "gpt-3.5-turbo",
    "cache": {"ttl": 600},
    "messages": [
      {"role": "user", "content": "Say this is a test"}
    ]
  }'

设置 s-maxage

设置 s-maxage，这将仅获取过去 10 分钟内缓存的响应

OpenAI Python SDK
curl

import os
from openai import OpenAI

client = OpenAI(
    # 这是默认设置，可以省略
    api_key=os.environ.get("OPENAI_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 在 extra_body 中接受额外参数
        cache: {
          "s-maxage": 600 # 仅获取过去 10 分钟内缓存的响应 
      }
    }
)

curl http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-1234" \
  -d '{
    "model": "gpt-3.5-turbo",
    "cache": {"s-maxage": 600},
    "messages": [
      {"role": "user", "content": "Say this is a test"}
    ]
  }'

按密钥开启/关闭缓存

在创建密钥时添加缓存参数完整列表

curl -X POST 'http://0.0.0.0:4000/key/generate' \
-H 'Authorization: Bearer sk-1234' \
-H 'Content-Type: application/json' \
-D '{
    "user_id": "222",
    "metadata": {
        "cache": {
            "no-cache": true
        }
    }
}'

测试一下！

curl -X POST 'http://localhost:4000/chat/completions' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer <YOUR_NEW_KEY>' \
-D '{"model": "gpt-3.5-turbo", "messages": [{"role": "user", "content": "bom dia"}]}'

删除缓存密钥 - `/cache/delete`

要删除缓存密钥，请向 /cache/delete 发送请求，并附上要删除的 keys

示例

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

# {"status":"success"}

查看响应中的缓存密钥

您可以在响应头中查看缓存密钥，缓存命中时，缓存密钥会作为 x-litellm-cache-key 响应头发送

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

来自 litellm 代理的响应

date: 周四, 2024年4月4日 17:37:21 GMT
content-type: 应用程序/json
x-litellm-cache-key: 586bf3f3c1bf5aecb55bd9996494d3bbc69eb58397163add6d49537762a7548d

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

设置缓存默认关闭 - 仅限选择加入

为缓存设置 mode: default_off

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:
  set_verbose: True
  cache: True
  cache_params:
    mode: default_off # 👈 关键更改：缓存默认关闭

在缓存默认关闭时选择加入缓存

OpenAI Python SDK
curl

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 接受 extra_body 中的额外参数
        "cache": {"use-cache": True}
    }
)

curl http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-1234" \
  -d '{
    "model": "gpt-3.5-turbo",
    "cache": {"use-cache": True}
    "messages": [
      {"role": "user", "content": "Say this is a test"}
    ]
  }'

开启 `batch_redis_requests`

它的作用是什么？ 当发出请求时：

检查内存中是否存在以 litellm:<hashed_api_key>:<call_type>: 开头的键，如果不存在 - 获取该键的最后 100 个缓存请求并存储它
新请求以这个 litellm:.. 作为命名空间存储

为什么？ 减少 redis GET 请求的数量。这在生产负载测试中将延迟降低了 46%。

用法

litellm_settings:
  cache: true
  cache_params:
    type: redis
    ... # 剩余的 redis 参数（主机、端口等）
  callbacks: ["batch_redis_requests"] # 👈 关键更改！

查看代码

代理配置文件中支持的 `cache_params`

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

  # 缓存类型（选项："local", "redis", "s3"）
  type: s3

  # 要缓存的 litellm 调用类型列表
  # 选项："completion", "acompletion", "embedding", "aembedding"
  supported_call_types: ["acompletion", "atext_completion", "aembedding", "atranscription"]
                      # /chat/completions, /completions, /embeddings, /audio/transcriptions

  # Redis 缓存参数
  host: localhost  # Redis 服务器主机名或 IP 地址
  port: "6379"  # Redis 服务器端口（作为字符串）
  password: secret_password  # Redis 服务器密码
  namespace: Optional[str] = None,
  

  # S3 缓存参数
  s3_bucket_name: your_s3_bucket_name  # S3 存储桶名称
  s3_region_name: us-west-2  # S3 存储桶的 AWS 区域
  s3_api_version: 2006-03-01  # AWS S3 API 版本
  s3_use_ssl: true  # 使用 SSL 进行 S3 连接（选项：true, false）
  s3_verify: true  # S3 连接的 SSL 证书验证（选项：true, false）
  s3_endpoint_url: https://s3.amazonaws.com  # S3 端点 URL
  s3_aws_access_key_id: your_access_key  # S3 的 AWS 访问密钥 ID
  s3_aws_secret_access_key: your_secret_key  # S3 的 AWS 秘密访问密钥
  s3_aws_session_token: your_session_token  # 用于临时凭证的 AWS 会话令牌

高级设置 - 用户 API 密钥缓存 TTL

配置内存缓存存储密钥对象的时间长度（防止数据库请求）

general_settings:
  user_api_key_cache_ttl: <your-number> # 时间（秒）

默认情况下，此值设置为 60 秒。

缓存

快速开始 - Redis、s3缓存、语义缓存​

步骤1：将cache添加到config.yaml​

[可选] 步骤1.5：添加redis命名空间，默认ttl​

命名空间​

Redis集群​

Redis哨兵​

TTL​

SSL​

步骤2：将Redis凭证添加到.env​

第三步：使用配置运行代理​

第一步：在 config.yaml 中添加 cache​

第二步：将 Qdrant 凭证添加到 .env​

第三步：使用配置运行代理​

第四步：测试​

第一步：在 config.yaml 中添加 cache​

第二步：使用配置运行代理​

第一步：在 config.yaml 中添加 cache​

第二步：将 Redis 凭证添加到 .env​

第三步：使用配置运行代理​

使用缓存 - /chat/completions​

为代理设置缓存，但在实际的LLM API调用中不启用缓存​

调试缓存 - /cache/ping​

高级设置​

控制缓存启用的调用类型 - (/chat/completion, /embeddings, 等)​

在 config.yaml 中设置缓存参数​

按请求启用/禁用缓存​

按密钥开启/关闭缓存​

删除缓存密钥 - /cache/delete​

查看响应中的缓存密钥​

设置缓存默认关闭 - 仅限选择加入​

开启 batch_redis_requests​

代理配置文件中支持的 cache_params​

高级设置 - 用户 API 密钥缓存 TTL​

快速开始 - Redis、s3缓存、语义缓存

步骤1：将`cache`添加到config.yaml

[可选] 步骤1.5：添加redis命名空间，默认ttl

命名空间

Redis集群

Redis哨兵

TTL

SSL

步骤2：将Redis凭证添加到.env

第三步：使用配置运行代理

第一步：在 config.yaml 中添加 `cache`

第二步：将 Qdrant 凭证添加到 .env

第三步：使用配置运行代理

第四步：测试

第一步：在 config.yaml 中添加 `cache`

第二步：使用配置运行代理

第一步：在 config.yaml 中添加 `cache`

第二步：将 Redis 凭证添加到 .env

第三步：使用配置运行代理

使用缓存 - /chat/completions

为代理设置缓存，但在实际的LLM API调用中不启用缓存

调试缓存 - `/cache/ping`

高级设置

控制缓存启用的调用类型 - (`/chat/completion`, `/embeddings`, 等)

在 config.yaml 中设置缓存参数

按请求启用/禁用缓存

按密钥开启/关闭缓存

删除缓存密钥 - `/cache/delete`

查看响应中的缓存密钥

设置缓存默认关闭 - 仅限选择加入

开启 `batch_redis_requests`

代理配置文件中支持的 `cache_params`

高级设置 - 用户 API 密钥缓存 TTL