O cache de prompts é uma maneira de armazenar e, em seguida, reutilizar as respostas geradas a partir de prompts executados ao trabalhar com modelos de linguagem como os modelos IBM® Granite. Se a mesma entrada (prompt) for encontrada novamente, em vez de fazer uma nova chamada de API, a aplicação recuperará a resposta armazenada anteriormente no cache de prompts.
Pense no cache de prompts como uma espécie de "memória" para sua aplicação. O sistema mantém os resultados de consultas anteriores para economizar tempo de computação por não ter que fazer solicitações repetidas para a mesma entrada.
O cache de prompts é significativo porque evita chamadas repetidas da interface de programação de aplicativos (API) por reutilizar respostas existentes para prompts idênticos repetidos. Essa capacidade resulta em tempo de resposta mais rápido, saída consistente e menor uso da API, o que é útil para permanecer dentro dos limites de taxa. Também ajuda a escalar o fluxo e criar resiliência durante interrupções. O cache de prompts é uma funcionalidade crítica que agrega valor a qualquer aplicação de IA econômica, eficiente e fácil de usar.
Você precisa de uma conta do IBM® Cloud para criar um projeto do watsonx.ai .
Você também precisa do Python versão 3.12.7
Etapa 1. Configure seu ambiente
Embora você possa escolher entre várias ferramentas, este tutorial explica como configurar uma conta da IBM para usar um Jupyter Notebook.
Faça login no watsonx.ai usando sua conta do IBM Cloud.
Crie um projeto do watsonx.ai. Você pode obter a ID do projeto a partir de seu projeto. Clique na guia Gerenciar . Em seguida, copie a ID do projeto da seção Detalhes da página Geral . Você precisa dessa ID para este tutorial.
Crie um Jupyter Notebook. Esta etapa abre um ambiente do Jupyter Notebook onde você pode copiar o código deste tutorial. Ou você pode fazer download desse notebook em seu sistema local e carregá-lo como um ativo em seu projeto do watsonx.ai. Para ver mais tutoriais do IBM Granite, confira a Comunidade IBM Granite.
Etapa 2. Configure uma instância do watsonx.ai Runtime e uma chave de API
Crie uma instância do serviço watsonx.ai Runtime (escolha o plano Lite, que é uma instância gratuita).
Gere uma chave de API.
Associe o serviço watsonx.ai Runtime ao projeto que você criou no watsonx.ai.
Etapa 3: Instalação dos pacotes
Precisamos de bibliotecas para trabalhar com o framework do langchain e o WatsonxLLM. Vamos primeiro instalar os pacotes necessários. Este tutorial foi criado usando o Python 3.12.7
Observação: se você estiver usando uma versão mais antiga do pip, poderá usar o comando pip install --upgrade pip para instalar facilmente os pacotes mais recentes que podem não ser compatíveis com versões mais antigas. Mas se você já está usando a versão mais recente ou atualizou seus pacotes recentemente, pode ignorar este comando.
Etapa 4: Importe as bibliotecas necessárias
O módulo os é usado para acessar variáveis de ambiente, como credenciais de projeto ou chaves de API.
O WatsonxLLM é um módulo do langchain_ibm que integra o IBM Watson LLM para gerar saídas a partir de modelos de IA generativa.
O ChatWatsonx permite interações baseadas em chat usando o IBM watsonx por meio do LangChain.
O SimpleDirectoryReader é para carregar e ler documentos de um diretório para indexação com o LlamaIndex.
O GenParams contém chaves de metadados para configurar os parâmetros de geração de texto do watsonx.
O SQLiteCache permite configurar um banco de dados SQLite local.cache.db para evitar chamadas de API redundantes e acelerar o desenvolvimento e os testes.
Precisamos de algumas bibliotecas e módulos para este tutorial. Certifique-se de importar as seguintes e, se não estiverem instaladas, uma instalação rápida de pip resolve o problema.
import getpass
import requests
import random
import json
from typing import Dict, List
from langchain_ibm import WatsonxLLM
from ibm_watsonx_ai.metanames import GenTextParamsMetaNames as GenParams
from langchain_ibm import WatsonxLLM
from langchain_ibm import ChatWatsonx
from llama_index.core import SimpleDirectoryReader
Etapa 5: Leia os dados do texto
documents = SimpleDirectoryReader(
input_files=["~/Artificial Intelligence/Generative_AI/files/FIle2.txt"],
).load_data()
document_text = documents[0].text
print(document_text[:200] + "...")
Etapa 6: Configure as credenciais
Esse código configura credenciais para acessar a API do IBM Watson Machine Learning (WML) e ajuda a garantir que a ID do projeto esteja configurada corretamente.
- As credenciais de um dicionário são criadas com o URL do serviço WML e a chave de API. A chave de API é coletada de forma segura usando getpass.getpass para evitar a exposição de informações confidenciais.
- o código tenta buscar o PROJECT_ID das variáveis de ambiente usando o os.environ. Se o PROJECT_ID não for encontrado, será solicitado que o usuário o insira manualmente por meio de uma entrada.
"url": "https://us-south.ml.cloud.ibm.com", # Replace with the correct region if needed
"apikey": getpass.getpass("Please enter your WML API key (hit enter): ")
}
# Set up project_id
try:
project_id = os.environ["PROJECT_ID"]
except KeyError:
project_id = input("Please enter your project_id (hit enter): ")
Etapa 7. Inicialize o grande modelo de linguagem
Este código inicializa o IBM Watson LLM para uso na aplicação:
- Este código cria uma instância do WatsonxLLM utilizando o modelo ibm/granite-3-8b-instruct (Granite-3.1-8B-Instruct) projetado para tarefas de IA generativa baseadas em instruções.
- Os valores de url, apikey e project_id das credenciais configuradas anteriormente são passados para autenticação e conexão com o serviço IBM Watson LLM.
- Configura o parâmetro max_new_tokens para limitar o número de tokens gerados pelo modelo em cada resposta (2.000 tokens, neste caso).
Para saber mais sobre os parâmetros do modelo, como os limites mínimo e máximo de tokens, consulte a documentação.
model_id= "ibm/granite-3-8b-instruct",
url=URL,
apikey=WATSONX_APIKEY,
project_id=WATSONX_PROJECT_ID,
params={
GenParams.DECODING_METHOD: "greedy",
GenParams.TEMPERATURE: 0,
GenParams.MIN_NEW_TOKENS: 5,
GenParams.MAX_NEW_TOKENS: 2000,
GenParams.REPETITION_PENALTY:1.2,
GenParams.STOP_SEQUENCES: ["\n\n"]
}
)
Etapa 8: Configure o cache do SQLite para respostas de LLMs mais rápidas
O SQLiteCache é uma ferramenta de cache persistente oferecida pelo LangChain que armazena respostas de chamadas de LLMs em um arquivo de banco de dados SQLite. O SQLiteCache reduz de forma inteligente o tempo da CPU ao armazenar cálculos dispendiosos, o que significa que ele se concentra em recuperar dados em vez de recalculá-los. Em vez de passar por todo o processo novamente, ele simplesmente extrai os resultados do disco, tornando-o eficiente, confiável e reutilizável.
A figura ilustra com o cache de prompt, como os resultados são carregados instantaneamente do disco; sem ele, toda consulta é uma perda de tempo em cálculos redundantes.
from langchain.globals import set_llm_cache
set_llm_cache(SQLiteCache(database_path=".langchain.db"))
prompt = "System: You are a helpful assistant.\nUser: Why did Paul Graham start YC?\nAssistant:"
resp = llm.invoke(prompt)
print(resp)
Nesse caso, a CPU funcionou por apenas 22 ms, mas o tempo decorrido real foi de 1,43 segundo.
Esse exemplo sugere que a maior parte do tempo era gasta esperando, provavelmente por operações de E/S (por exemplo, leitura e gravação de disco, acesso à rede ou chamada de API)
Agora, vamos executar o modelo uma segunda vez com o prompt e ver o tempo de resposta.
llm.predict(resp)
Claramente, usando o SQLiteCache, a CPU é usada por apenas 7,26 ms, mas o tempo de espera foi de 6,15 segundos.
Isso aponta claramente para o bloqueio de dependências externas (como esperar por uma resposta de um servidor).
O cache de prompts acelera e reduz o custo das solicitações de APIs para grandes modelos de linguagem, como o GPT-4o. Os prompts armazenam em cache o conteúdo, como tokens de entrada, tokens de saída, embeddings e mensagens do usuário, um prompt do sistema ou a saída de uma função, que agora usa um conteúdo em cache em vez de solicitações de rede para uma nova revisão. Esse método oferece preços mais baixos, melhor latência de resposta e principais indicadores de desempenho (KPIs) melhorados.
O cache de prompts pode ser benéfico para chatbots, sistemas de RAG, ajuste fino e assistentes de código. Uma estratégia de cache robusta que inclui funções como leitura em cache, gravação em cache, mensagem do sistema, controle de cache e tempo de vida adequado (TTL) melhorará as taxas de acertos de cache e reduzirá as taxas de perda de cache.
O uso consistente dos mesmos tokens de prompts, prefixo de prompts e instruções do sistema ajuda no desempenho consistente dos prompts em conversas multivoltas e solicitações subsequentes. Independentemente de usar Python, um SDK ou trabalhar com a OpenAI ou outro provedor, entender como o cache de prompts funciona permitirá que você implemente melhor o cache de prompts para uso em muitos casos de uso.