Tutorial GPTCache: aumentando a eficiência em aplicações com LLM

GPTCache é um framework open source para aplicações com modelos de linguagem de grande porte (LLM), como o ChatGPT. Ele armazena respostas de LLM já geradas para consultas semelhantes. Em vez de depender do LLM a cada vez, a aplicação verifica o cache em busca de uma resposta relevante para economizar seu tempo.

Este guia explica como o GPTCache funciona e como você pode usá-lo com eficiência nos seus projetos.

O que é o GPTCache?

GPTCache é um sistema de cache criado para melhorar o desempenho e a eficiência de modelos de linguagem de grande porte (LLMs) como o GPT-3. Ele ajuda LLMs a armazenar consultas e respostas já geradas para economizar tempo e processamento.

Quando surge uma consulta semelhante, o LLM pode recuperar a resposta em cache em vez de gerar uma nova do zero.

Diferente de outras ferramentas, o GPTCache trabalha com cache semântico. Caches semânticos preservam a intenção de uma consulta/solicitação. Assim, quando consultas armazenadas são recuperadas, o resultado reduz a carga do servidor e melhora as taxas de acerto do cache.

Vantagens de usar o GPTCache

A ideia central do GPTCache é armazenar e reutilizar os cálculos intermediários gerados durante o processo de inferência de um LLM. Isso traz vários benefícios:

Economia em chamadas de API de LLM

A maioria dos LLMs cobra por solicitação com base no número de tokens processados. É aí que o GPTCache ajuda: ele reduz o número de chamadas à API do LLM ao servir respostas já geradas para consultas semelhantes. Como resultado, você diminui custos com chamadas desnecessárias.

Tempo de resposta e eficiência melhores

Buscar uma resposta no cache é muito mais rápido do que gerá-la do zero consultando o LLM. Isso acelera a execução e melhora o tempo de resposta. Respostas mais eficientes aliviam a carga do próprio LLM e liberam recursos para outras tarefas.

Experiência do usuário aprimorada com desempenho mais rápido

Imagine que você está pesquisando perguntas para seu conteúdo. Cada pergunta leva uma eternidade para a IA responder. Por quê? Porque muitos serviços de LLM impõem limites de requisições em períodos definidos. Ao exceder esses limites, novas solicitações ficam bloqueadas até a redefinição, causando interrupções.

O ChatGPT pode atingir o limite de geração de respostas

Para evitar esses problemas, o GPTCache guarda respostas anteriores para perguntas semelhantes. Quando você pede algo, ele rapidamente consulta a memória e entrega a informação em instantes. Assim, você recebe a resposta muito mais rápido que o normal.

Em resumo, ao aproveitar respostas em cache, o GPTCache torna aplicações baseadas em LLM mais responsivas e eficientes — como você espera de qualquer ferramenta moderna.

Configurando o GPTCache

Veja como instalar o GPTCache diretamente:

Instalação e configuração

Instale o pacote GPTCache com este comando.

! pip install -q gptcacheTecnologia

Depois, importe o GPTCache para sua aplicação.

from gptcache import GPTCache
cache = GPTCache()  
# mantenha o modo padrão 
Tecnologia

Pronto, é só isso!

Integração com LLMs

Você pode integrar o GPTCache aos LLMs por meio do LLM Adapter. Por enquanto, ele é compatível com apenas dois adapters de modelos de linguagem:

• OpenAI
• Langchain

Veja como integrar com ambos:

GPTCache com a API do ChatGPT (OpenAI)

Para integrar o GPTCache com a OpenAI, inicialize o cache e importe openai de gptcache.adapter.

from gptcache import cache
from gptcache.adapter import openai

cache.init()
cache.set_openai_key()
Tecnologia

Antes de executar o exemplo, defina a variável de ambiente OPENAI_API_KEY executando echo $OPENAI_API_KEY.

Se ela ainda não estiver definida, você pode configurá-la com export OPENAI_API_KEY=YOUR_API_KEY em sistemas Unix/Linux/MacOS ou set OPENAI_API_KEY=YOUR_API_KEY no Windows.

Depois, se você fizer duas perguntas idênticas ao ChatGPT, a resposta da segunda será recuperada do cache em vez de consultar o ChatGPT novamente.

Aqui vai um exemplo de código para cache por similaridade:

import time


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

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

# To use GPTCache, that's all you need
# -------------------------------------------------
from gptcache import cache
from gptcache.adapter import openai

cache.init()
cache.set_openai_key()
# -------------------------------------------------

question = "what's 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: {question}')
    print("Time consuming: {:.2f}s".format(time.time() - start_time))
    print(f'Answer: {response_text(response)}\n')Tecnologia

Veja o que você verá na saída:

Na segunda vez, o GPT levou praticamente 0 segundo para responder a mesma pergunta

GPTCache com LangChain

Se quiser utilizar um LLM diferente, experimente o adapter do LangChain. Veja como integrar o GPTCache ao LangChain:

from langchain.globals import set_llm_cache
from langchain_openai import OpenAI

# To make the caching really obvious, lets use a slower model.
llm = OpenAI(model_name="gpt-3.5-turbo-instruct", n=2, best_of=2)Tecnologia

Aprenda a construir aplicações com LLM usando LangChain.

Usando o GPTCache nos seus projetos

Vamos ver como o GPTCache pode apoiar seus projetos.

Operações básicas

LLMs podem se tornar ineficientes por conta da complexidade e variabilidade inerentes às consultas, o que resulta em uma baixa taxa de acertos no cache.

Para contornar essa limitação, o GPTCache adota estratégias de cache semântico. O cache semântico armazena consultas semelhantes ou relacionadas — aumentando a probabilidade de acertos e elevando a eficiência geral do cache.

O GPTCache usa algoritmos de embedding para converter consultas em representações numéricas chamadas embeddings. Esses embeddings são armazenados em um repositório vetorial, permitindo buscas por similaridade eficientes. Esse processo possibilita identificar e recuperar consultas semelhantes ou relacionadas do armazenamento em cache.

Com um design modular, você pode personalizar a implementação de cache semântico conforme suas necessidades.

No entanto — às vezes ocorrem falsos acertos e perdas (misses) no cache semântico. Para monitorar o desempenho, o GPTCache oferece três métricas:

• Taxa de acerto (hit ratio) mede o sucesso do cache em atender requisições. Quanto maior, melhor.
• Latência indica o tempo para recuperar dados do cache — quanto menor, melhor.
• Revocação (recall) mostra a proporção de consultas corretamente atendidas pelo cache. Percentuais maiores indicam melhor precisão.

Recursos avançados

Todos os dados básicos, como consultas iniciais, prompts, respostas e carimbos de data/hora de acesso, são armazenados em um "gerenciador de dados". O GPTCache atualmente oferece suporte às seguintes opções de armazenamento de cache:

• SQLite
• MySQL
• Bancos PostgreSQL.

Ainda não há suporte a bancos ‘NoSQL’, mas ele está nos planos para ser incorporado em breve.

Usando políticas de remoção (eviction)

O GPTCache pode remover dados do armazenamento de cache com base em um limite ou contagem definidos. Para gerenciar o tamanho do cache, você pode aplicar a política LRU (Least Recently Used) ou FIFO (First In, First Out).

• LRU remove os itens acessados há mais tempo.
• Já a política FIFO descarta os itens em cache que estão lá há mais tempo.

Avaliando o desempenho das respostas

O GPTCache usa uma função de ‘avaliação’ para verificar se uma resposta em cache atende à consulta do usuário. Para isso, ela considera três entradas:

• a solicitação do usuário
• os dados em cache que estão sendo avaliados
• parâmetros definidos pelo usuário (se houver)

Você também pode usar duas outras funções:

• log_time_func permite registrar e informar a duração de tarefas intensivas, como gerar embeddings ou executar buscas no cache. Isso ajuda a monitorar características de desempenho.
• Com similarity_threshold, você define o limite a partir do qual dois vetores de embedding (representações textuais de alta dimensão) são considerados suficientemente semelhantes para corresponder.

Boas práticas e solução de problemas no GPTCache

Agora que você já sabe como o GPTCache funciona, veja algumas boas práticas e dicas para aproveitar ao máximo.

Otimizando o desempenho do GPTCache

Há várias ações que você pode adotar para otimizar o desempenho do GPTCache, como as listadas abaixo.

1. Deixe seus prompts claros

A forma como você escreve seus prompts impacta diretamente o desempenho do GPTCache. Mantenha a redação consistente para aumentar as chances de acerto no cache.

Por exemplo, use sempre formulações consistentes como "Não consigo fazer login na minha conta". Assim, o GPTCache reconhece com mais facilidade problemas semelhantes, como "Esqueci minha senha" ou "Problemas para acessar a conta".

2. Use as métricas nativas de acompanhamento

Monitore métricas como taxa de acerto, recall e latência para analisar o desempenho do cache. Uma taxa de acerto mais alta indica que o cache está servindo melhor o conteúdo solicitado a partir dos dados armazenados — ajudando você a entender sua efetividade.

3. Escalando o GPTCache para aplicações de LLM com grande base de usuários

Para escalar o GPTCache em aplicações maiores, implemente um cache compartilhado que utilize o mesmo cache para grupos de usuários com perfis semelhantes. Crie perfis de usuário e classifique-os para identificar grupos similares.

Aproveitar um cache compartilhado para usuários do mesmo grupo de perfil traz ótimos resultados em eficiência e escalabilidade.

Isso porque usuários de um mesmo grupo tendem a ter consultas relacionadas que se beneficiam de respostas em cache. Porém, é essencial aplicar técnicas adequadas de criação de perfis e classificação para agrupar usuários corretamente e extrair o máximo do cache compartilhado.

Solucionando problemas comuns no GPTCache

Se você estiver enfrentando dificuldades com o GPTCache, há algumas ações que podem ajudar a diagnosticar e resolver os problemas.

1. Invalidação do cache

O GPTCache depende de respostas atualizadas. Se as respostas do LLM ou a intenção do usuário mudarem com o tempo, as respostas em cache podem ficar imprecisas ou irrelevantes.

Para evitar isso, defina tempos de expiração para as entradas em cache com base na frequência esperada de atualização do LLM e faça a atualização periódica do cache.

2. Dependência excessiva do cache

Embora o GPTCache aumente a eficiência, depender demais do cache pode levar a informações desatualizadas se a invalidação não for feita corretamente.

Por isso, garanta que sua aplicação ocasionalmente busque respostas novas do LLM, mesmo para consultas semelhantes. Isso mantém a precisão e a qualidade das respostas em cenários críticos ou sensíveis ao tempo.

3. Ignorar a qualidade do cache

A qualidade e a relevância das respostas em cache impactam a experiência do usuário. Use métricas de avaliação para verificar a qualidade das respostas antes de entregá-las aos usuários.

Ao entender esses possíveis problemas e suas soluções, você garante que o GPTCache aumente o desempenho e a relação custo-benefício das suas aplicações com LLM — sem comprometer a precisão ou a experiência do usuário.

Fechamento

O GPTCache é uma ferramenta poderosa para otimizar o desempenho e reduzir custos em aplicações com LLM. Configuração adequada, monitoramento e estratégias de avaliação do cache são essenciais para garantir respostas precisas e relevantes.

Se você está começando com LLMs, estes recursos podem ajudar:

• Developing large language models
• Building LLM applications with LangChain and GPT
• Training an LLM with PyTorch
• Using LLM with cohere API
• Developing LLM applications with LangChain