GPTCache：用于为大语言模型查询创建语义缓存的库

将您的 LLM API 成本降低 10 倍 💰，速度提升 100 倍 ⚡

🎉 GPTCache 已与 🦜️🔗LangChain 完全集成！以下是详细的 使用说明。

🐳 GPTCache 服务器 Docker 镜像 已发布，这意味着 任何编程语言 都可以使用 GPTCache！

📔 本项目正处于快速开发中，因此 API 可能会随时发生变化。有关最新信息，请参阅最新的 文档 和 发布说明。

注意：随着大型模型数量的激增以及其 API 形态的不断演变，我们不再新增对新 API 或模型的支持。我们鼓励使用 GPTCache 中的 get 和 set API，示例代码如下：https://github.com/zilliztech/GPTCache/blob/main/examples/adapter/api.py

快速安装

pip install gptcache

🚀 什么是 GPTCache？

ChatGPT 和各种大型语言模型（LLMs）具有惊人的多功能性，能够支持多种应用的开发。然而，随着您的应用越来越受欢迎并面临更高的流量压力，与 LLM API 调用相关的成本可能会变得非常高昂。此外，LLM 服务在处理大量请求时可能会出现响应缓慢的情况。

为了解决这一挑战，我们开发了 GPTCache，这是一个专门用于构建语义缓存以存储 LLM 响应的项目。

😊 快速入门

注意：

• 您无需进行大量开发即可快速试用 GPTCache 并将其部署到生产环境。但请注意，该仓库目前仍在积极开发中。
• 默认情况下，仅安装有限数量的库来支持基本的缓存功能。当您需要使用其他功能时，相关库将会 自动安装。
• 请确保 Python 版本为 3.8.1 或更高，可通过运行 python --version 进行检查。
• 如果由于 pip 版本过低而导致无法安装某些库，请运行：python -m pip install --upgrade pip。

开发环境安装

# 克隆 GPTCache 仓库
git clone -b dev https://github.com/zilliztech/GPTCache.git
cd GPTCache

# 安装仓库
pip install -r requirements.txt
python setup.py install

示例用法

这些示例将帮助您理解如何使用精确匹配和相似匹配进行缓存。您也可以在 Colab 上运行这些示例。更多示例请参考 训练营。

在运行示例之前，请 确保 已设置 OPENAI_API_KEY 环境变量，方法是执行 echo $OPENAI_API_KEY。如果尚未设置，可以在 Unix/Linux/MacOS 系统上使用 export OPENAI_API_KEY=YOUR_API_KEY，或在 Windows 系统上使用 set OPENAI_API_KEY=YOUR_API_KEY 来设置。

请注意，此方法仅为临时生效，若需永久生效，则需修改环境变量配置文件。例如，在 Mac 上，您可以编辑位于 /etc/profile 的文件。

import os
import time

import openai


def response_text(openai_resp):
    return openai_resp['choices'][0]['message']['content']


question = 'what‘s chatgpt'

# OpenAI API 原始用法
openai.api_key = os.getenv("OPENAI_API_KEY")
start_time = time.time()
response = openai.ChatCompletion.create(
  model='gpt-3.5-turbo',
  messages=[
    {
        'role': 'user',
        'content': question
    }
  ],
)
print(f'Question: {question}')
print("Time consuming: {:.2f}s".format(time.time() - start_time))
print(f'Answer: {response_text(response)}\n')

import time


def response_text(openai_resp):
    return openai_resp['choices'][0]['message']['content']

print("Cache loading.....")

# 使用 GPTCache，您只需要做这些
# -------------------------------------------------
from gptcache import cache
from gptcache.adapter import openai

cache.init()
cache.set_openai_key()

# -------------------------------------------------

question = "什么是GitHub"
for _ in range(2):
    start_time = time.time()
    response = openai.ChatCompletion.create(
      model='gpt-3.5-turbo',
      messages=[
        {
            'role': 'user',
            'content': question
        }
      ],
    )
    print(f'问题: {question}')
    print("耗时: {:.2f}秒".format(time.time() - start_time))
    print(f'答案: {response_text(response)}\n')

import time


def response_text(openai_resp):
    return openai_resp['choices'][0]['message']['content']

from gptcache import cache
from gptcache.adapter import openai
from gptcache.embedding import Onnx
from gptcache.manager import CacheBase、VectorBase、get_data_manager
from gptcache.similarity_evaluation.distance import SearchDistanceEvaluation

print("缓存加载中.....")

onnx = Onnx()
data_manager = get_data_manager(CacheBase("sqlite")、VectorBase("faiss"、dimension=onnx.dimension))
cache.init(
    embedding_func=onnx.to_embeddings,
    data_manager=data_manager,
    similarity_evaluation=SearchDistanceEvaluation(),
    )
cache.set_openai_key()

questions = [
    "什么是GitHub",
    "你能解释一下GitHub是什么吗",
    "你能多告诉我一些关于GitHub的信息吗",
    "GitHub的用途是什么"
]

for question in questions:
    start_time = time.time()
    response = openai.ChatCompletion.create(
        model='gpt-3.5-turbo',
        messages=[
            {
                'role': 'user',
                'content': question
            }
        ],
    )
    print(f'问题: {question}')
    print("耗时: {:.2f}秒".format(time.time() - start_time))
    print(f'答案: {response_text(response)}\n')

import time

from gptcache import cache、Config
from gptcache.manager import manager_factory
from gptcache.embedding import Onnx
from gptcache.processor.post import temperature_softmax
from gptcache.similarity_evaluation.distance import SearchDistanceEvaluation
from gptcache.adapter import openai

cache.set_openai_key()

onnx = Onnx()
data_manager = manager_factory("sqlite,faiss"、vector_params={"dimension": onnx.dimension})

cache.init(
    embedding_func=onnx.to_embeddings,
    data_manager=data_manager,
    similarity_evaluation=SearchDistanceEvaluation(),
    post_process_messages_func=temperature_softmax
    )
# cache.config = Config(similarity_threshold=0.2)

question = "什么是GitHub"

for _ in range(3):
    start = time.time()
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        temperature = 1.0,  # 在这里更改temperature
        messages=[{
            "role": "user",
            "content": question
        }],
    )
    print("用时:", round(time.time() - start, 3))
    print("答案:", response["choices"][0]["message"]["内容"])

要完全使用GPTCache，只需以下几行代码，无需修改任何现有代码。

from gptcache import cache
from gptcache.adapter import openai

cache.init()
cache.set_openai_key()

更多文档：

• 使用指南，如何更好地使用GPTCache
• 功能介绍，缓存目前支持的所有功能
• 示例，学习更好的自定义缓存
• 分布式缓存与水平扩展

🎓 培训营

• GPTCache与LangChain
  • 问答生成
  • 问题回答
  • SQL链
  • BabyAGI用户指南
• GPTCache与Llama_index
  • 网页问答
• GPTCache与OpenAI
  • 聊天完成
  • 语言翻译
  • SQL翻译
  • 推文分类器
  • 多模态：图像生成
  • 多模态：语音转文字
• GPTCache与Replicate
  • 视觉问答
• GPTCache与Temperature参数
  • OpenAI聊天
  • OpenAI图像创作

😎 这能帮上什么忙？

GPTCache 提供以下主要优势：

• 降低成本：大多数大模型服务会根据请求数量和令牌计数来收取费用。GPTCache 通过缓存查询结果，有效减少发送到大模型服务的请求数量和令牌用量，从而显著降低使用成本。这样一来，您在使用该服务时将获得更具性价比的体验。
• 提升性能：大模型采用生成式 AI 算法实时生成响应，这一过程有时可能较为耗时。然而，当相似的查询已被缓存时，响应时间会大幅缩短，因为可以直接从缓存中获取结果，无需再与大模型服务交互。在大多数情况下，相比标准的大模型服务，GPTCache 还能提供更高的查询吞吐量。
• 灵活的开发与测试环境：作为开发大模型应用的工程师，您知道通常需要连接到大模型 API，并且在将应用部署到生产环境之前，进行全面测试至关重要。GPTCache 提供一个与大模型 API 兼容的接口，支持存储由大模型生成的数据以及模拟数据。这一特性使您能够轻松地开发和测试应用，而无需实际连接到大模型服务。
• 增强可扩展性和可用性：大模型服务经常实施速率限制，即 API 对用户或客户端在特定时间内访问服务器次数的约束。一旦达到速率限制，后续请求将被阻止，直到一定时间过去才会恢复，这可能导致服务中断。借助 GPTCache，您可以轻松扩展以应对不断增加的查询量，确保随着用户规模的增长，应用始终保持稳定的性能。

🤔 它是如何工作的？

在线服务通常具有数据局部性特征，用户往往会频繁访问热门或流行的内容。缓存系统正是利用这一特性，将常用数据存储起来，从而缩短数据检索时间、加快响应速度，并减轻后端服务器的压力。传统的缓存系统通常采用精确匹配的方式，即通过比对新查询与缓存中的查询是否完全一致，来判断所需内容是否已在缓存中，然后再进行数据获取。

然而，对于大模型的缓存来说，采用精确匹配的方法效果并不理想，因为大模型的查询往往复杂多样，导致缓存命中率较低。为解决这一问题，GPTCache 采用了语义缓存等替代策略。语义缓存能够识别并存储相似或相关的查询，从而提高缓存命中概率，提升整体缓存效率。

GPTCache 使用嵌入算法将查询转换为嵌入向量，并借助向量存储对这些嵌入向量进行相似度搜索。这一过程使 GPTCache 能够从缓存存储中识别并检索出相似或相关的查询，如模块部分所示。

GPTCache 采用模块化设计，方便用户自定义自己的语义缓存。系统为每个模块提供了多种实现方式，用户甚至可以根据自身需求开发专属的实现方案。

在语义缓存中，可能会出现缓存命中时的误报以及缓存未命中时的漏报。为了帮助开发者优化缓存系统，GPTCache 提供了三项性能指标：

• 命中率：该指标用于衡量缓存成功满足内容请求的能力，相对于其收到的总请求数而言。命中率越高，说明缓存越有效。
• 延迟：该指标用于测量查询被处理并从缓存中检索到相应数据所需的时间。延迟越低，表明缓存系统越高效、响应越迅速。
• 召回率：该指标表示由缓存提供的查询数量占本应由缓存提供的总查询数量的比例。召回率越高，说明缓存能够有效地提供合适的内容。

此外，还提供了一个示例基准测试，供用户开始评估其语义缓存的性能。

🤗 模块

• LLM 适配器： LLM 适配器旨在通过统一不同 LLM 模型的 API 和请求协议来实现集成。GPTCache 为此提供了标准化接口，目前支持 ChatGPT 集成。

  • 支持 OpenAI ChatGPT API。
  • 支持 langchain。
  • 支持 minigpt4。
  • 支持 Llamacpp。
  • 支持 dolly。
  • 支持其他 LLM，例如 Hugging Face Hub、Bard、Anthropic。

• 多模态适配器（实验性）： 多模态适配器旨在通过统一不同大型多模态模型的 API 和请求协议来实现集成。GPTCache 为此提供了标准化接口，目前支持图像生成、音频转录等功能的集成。

  • 支持 OpenAI Image Create API。
  • 支持 OpenAI Audio Transcribe API。
  • 支持 Replicate BLIP API。
  • 支持 Stability Inference API。
  • 支持 Hugging Face Stable Diffusion Pipeline（本地推理）。
  • 支持其他多模态服务或自托管的大型多模态模型。

• 嵌入生成器： 该模块用于从请求中提取嵌入向量，以进行相似度搜索。GPTCache 提供了一个通用接口，支持多种嵌入 API，并提供多种解决方案供选择。

  • 禁用嵌入功能。这会将 GPTCache 变为基于关键词匹配的缓存。
  • 支持 OpenAI 嵌入 API。
  • 支持 ONNX，使用 GPTCache/paraphrase-albert-onnx 模型。
  • 支持 Hugging Face 嵌入，包括 transformers、ViTModel、Data2VecAudio。
  • 支持 Cohere 嵌入 API。
  • 支持 fastText 嵌入。
  • 支持 SentenceTransformers 嵌入。
  • 支持 Timm 模型用于图像嵌入。
  • 支持其他嵌入 API。

• 缓存存储： 缓存存储是存放来自 LLM（如 ChatGPT）响应的地方。缓存的响应会被检索出来，用于评估相似性，并在语义匹配良好时返回给请求者。目前，GPTCache 支持 SQLite，并提供一个通用接口以便扩展此模块。

  • 支持 SQLite。
  • 支持 DuckDB。
  • 支持 PostgreSQL。
  • 支持 MySQL。
  • 支持 MariaDB。
  • 支持 SQL Server。
  • 支持 Oracle。
  • 支持 DynamoDB。
  • 支持 MongoDB。
  • 支持 Redis。
  • 支持 Minio。
  • 支持 HBase。
  • 支持 ElasticSearch。
  • 支持其他存储系统。

• 向量存储： 向量存储模块根据输入请求提取的嵌入向量，帮助找到与之最相似的 K 个请求。其结果可用于评估相似性。GPTCache 提供了一个用户友好的接口，支持多种向量存储，包括 Milvus、Zilliz Cloud 和 FAISS。未来还将提供更多选项。

  • 支持 Milvus——一款面向生产级 AI/LLM 应用的开源向量数据库。
  • 支持 Zilliz Cloud——基于 Milvus 的全托管云向量数据库。
  • 支持 Milvus Lite——一款可嵌入 Python 应用的轻量级 Milvus 版本。
  • 支持 FAISS——一个用于高效相似度搜索和稠密向量聚类的库。
  • 支持 Hnswlib——一个仅包含头文件的 C++/Python 库，用于快速近似最近邻搜索。
  • 支持 PGVector——一个面向 Postgres 的开源向量相似度搜索工具。
  • 支持 Chroma——一款原生支持 AI 的开源嵌入式数据库。
  • 支持 DocArray——一个用于表示、传输和存储多模态数据的库，非常适合机器学习应用。
  • 支持 qdrant
  • 支持 weaviate
  • 支持其他向量数据库。

• 缓存管理器： 缓存管理器负责控制 缓存存储 和 向量存储 的运行。

  • 逐出策略： 缓存逐出可以在内存中使用 Python 的 cachetools 进行管理，也可以通过 Redis 作为键值存储实现分布式管理。
  • 内存缓存

  目前，GPTCache 的逐出决策仅基于条目数量。这种方法可能导致资源评估不准确，并引发内存不足（OOM）错误。我们正在积极研究并开发更复杂的策略。

  • 支持 LRU 逐出策略。
  • 支持 FIFO 逐出策略。
  • 支持 LFU 逐出策略。
  • 支持 RR 逐出策略。
  • 支持更复杂的逐出策略。
  • 分布式缓存

  如果您尝试使用内存缓存对 GPTCache 部署进行水平扩展，则无法实现。因为缓存信息将仅限于单个 Pod。

  通过分布式缓存，可以在所有副本之间保持缓存信息的一致性，从而可以使用 Redis 等分布式缓存存储。

  • 支持 Redis 分布式缓存。
  • 支持 memcached 分布式缓存。

• 相似度评估器： 该模块从 缓存存储 和 向量存储 中收集数据，并使用多种策略来确定输入请求与 向量存储 中请求之间的相似度。基于此相似度，它决定请求是否与缓存匹配。GPTCache 提供了标准化接口，用于集成各种策略，并附带一系列实现方案可供使用。目前支持或未来将支持的相似度定义如下：

  • 由 向量存储 得到的距离。
  • 基于模型的相似度，使用来自 ONNX 的 GPTCache/albert-duplicate-onnx 模型计算。
  • 输入请求与 向量存储 中获取的请求之间的完全匹配。
  • 通过将 numpy 的 linalg.norm 应用于嵌入向量所表示的距离。
  • BM25 和其他相似度测量方法。
  • 支持 PyTorch 等其他模型推理框架。

  注意：并非所有模块组合都能相互兼容。例如，如果禁用 嵌入提取器，向量存储 可能无法正常工作。我们目前正在为 GPTCache 实现组合合理性检查。

😇 路线图

即将推出！敬请关注！

😍 参与贡献

我们非常欢迎各种形式的贡献，无论是新增功能、优化基础设施，还是改进文档。

有关如何参与贡献的详细说明，请参阅我们的贡献指南。

GPTCache 快速上手指南

GPTCache 是一个专为大语言模型（LLM）查询设计的语义缓存库。它能将 LLM API 成本降低 10 倍，响应速度提升 100 倍，通过缓存相似问题的回答来避免重复调用昂贵的 LLM 服务。

环境准备

在开始之前，请确保满足以下系统要求：

• Python 版本：3.8.1 或更高。
  • 检查命令：python --version
• pip 版本：建议升级到最新版本以避免安装错误。
  • 升级命令：python -m pip install --upgrade pip
• API Key：如果使用 OpenAI 等模型，需提前设置好环境变量 OPENAI_API_KEY。
  • Linux/Mac: export OPENAI_API_KEY=YOUR_API_KEY
  • Windows: set OPENAI_API_KEY=YOUR_API_KEY

提示：国内开发者若遇到网络安装问题，可使用清华源或阿里源加速安装（例如：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple gptcache）。

安装步骤

方式一：通过 PyPI 安装（推荐）

这是最快速的安装方式，仅安装核心功能。当需要使用特定功能（如向量数据库、嵌入模型）时，相关依赖库会自动按需安装。

pip install gptcache

方式二：开发版安装

如果你需要体验最新功能或贡献代码，可以从 GitHub 克隆源码安装：

# 克隆仓库
git clone -b dev https://github.com/zilliztech/GPTCache.git
cd GPTCache

# 安装依赖并构建
pip install -r requirements.txt
python setup.py install

基本使用

GPTCache 的设计目标是零代码侵入。你只需添加几行初始化代码，即可让现有的 OpenAI 调用自动具备缓存能力。

1. 精确匹配缓存（Exact Match）

适用于完全相同的问题直接返回缓存结果，无需再次请求 LLM。

import time
from gptcache import cache
from gptcache.adapter import openai

# 初始化缓存并设置 Key
cache.init()
cache.set_openai_key()

def response_text(openai_resp):
    return openai_resp['choices'][0]['message']['content']

question = "what's github"

# 第一次请求：调用 LLM 并缓存结果
# 第二次请求：直接从缓存获取，速度极快且无 API 费用
for _ in range(2):
    start_time = time.time()
    response = openai.ChatCompletion.create(
      model='gpt-3.5-turbo',
      messages=[{'role': 'user', 'content': question}],
    )
    print(f'Question: {question}')
    print("Time consuming: {:.2f}s".format(time.time() - start_time))
    print(f'Answer: {response_text(response)}\n')

2. 语义相似匹配缓存（Similarity Search）

适用于问题表述不同但意图相似的场景（例如："GitHub 是什么" 和 "介绍一下 GitHub"）。这需要配置嵌入模型（Embedding）和向量存储。

import time
from gptcache import cache
from gptcache.adapter import openai
from gptcache.embedding import Onnx
from gptcache.manager import CacheBase, VectorBase, get_data_manager
from gptcache.similarity_evaluation.distance import SearchDistanceEvaluation

# 配置嵌入模型和向量数据库
onnx = Onnx()
data_manager = get_data_manager(CacheBase("sqlite"), VectorBase("faiss", dimension=onnx.dimension))

# 初始化缓存
cache.init(
    embedding_func=onnx.to_embeddings,
    data_manager=data_manager,
    similarity_evaluation=SearchDistanceEvaluation(),
)
cache.set_openai_key()

questions = [
    "what's github",
    "can you explain what GitHub is",  # 语义相似，将命中缓存
    "can you tell me more about GitHub", # 语义相似，将命中缓存
]

for question in questions:
    start_time = time.time()
    response = openai.ChatCompletion.create(
        model='gpt-3.5-turbo',
        messages=[{'role': 'user', 'content': question}],
    )
    print(f'Question: {question}')
    print("Time consuming: {:.2f}s".format(time.time() - start_time))
    print(f'Answer: {response_text(response)}\n')

进阶提示：温度参数（Temperature）

你可以通过传递 temperature 参数来控制缓存行为：

• temperature = 0：优先搜索缓存，未命中才请求模型。
• temperature = 2：跳过缓存，直接请求模型。
• 中间值：按概率决定是否跳过缓存搜索。

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    temperature=1.0,  # 调整此参数控制缓存命中率
    messages=[{"role": "user", "content": "what's github"}],
)