Computer >> Hướng Dẫn Máy Tính >  >> Lập Trình >> Redis

Tăng Hiệu Suất: Cache LLM Theo Yêu Cầu Với LangChain, Redis Và QStash

Trong một số ứng dụng, có thể không khả thi khi truy vấn LLM ngay khi người dùng yêu cầu. Quá trình gửi prompt đến API và chờ phản hồi có thể đặc biệt tốn thời gian. Đối với các tác vụ phức tạp hơn liên quan đến LangChain, như xử lý dữ liệu từ PDF hoặc file audio rồi đưa vào LLM, độ trễ trở thành rào cản lớn hơn cho trải nghiệm người dùng.

Mặc dù streaming là giải pháp phù hợp trong nhiều trường hợp, nhưng có thể tiện lợi hơn để thực hiện mọi thứ tại một thời điểm tùy ý trước khi người dùng thậm chí truy cập ứng dụng. Cách này, người dùng được phục vụ phản hồi từ cache gần như tức thì, không phải chờ LLM sinh ra. Điều này đặc biệt hữu ích cho các ứng dụng dùng cùng đầu vào cho mọi người dùng, như tóm tắt sách hoặc tin tức. Nhưng nếu không có đầu vào từ người dùng, làm sao để LangChain cache phản hồi?

Chúng ta cần một microservice có thể gọi theo yêu cầu, có khả năng gửi prompt đến LangChain và cache phản hồi bằng Upstash Redis. Chúng ta cũng sẽ dùng SDK Rate Limiting của Upstash để đảm bảo không vô tình vượt quá giới hạn rate limit. QStash là cách linh hoạt nhất để gọi microservice—chúng ta có thể thiết lập nó để cache phản hồi bất cứ khi nào muốn, thậm chí truyền cron job nếu ứng dụng yêu cầu. Nó cũng cung cấp dashboard để giám sát việc sử dụng microservice. Nếu endpoint bị quá tải hoặc có sự cố, QStash sẽ retry request HTTP và đảm bảo tin nhắn được gửi đến.

Microservice của chúng ta sẽ được xây dựng bằng Hono.js, framework web nhẹ và nhanh cho edge. Trong demo này, chúng ta sẽ dùng Cloudflare Worker để host microservice. Nhờ Upstash, nó có thể triển khai gần như ở bất đâu, bao gồm các runtime edge/serverless khác.

Bạn có thể tìm toàn bộ mã nguồn demo tại đây.

Yêu Cầu Tiên Quyết

  • Database Upstash Redis
  • Biến môi trường QStash
  • API Key OpenAI

Bắt Đầu

Tạo Dự Án

Khác với nhiều package create-<package> npm khác, create-hono yêu cầu bạn phải ở trong thư mục trống. Trước tiên, tạo thư mục mới trống cho dự án và điều hướng vào:

mkdir langchain-qstash
cd langchain-qstash

Với bản phát hành v1.0.0 gần đây, Bun sẽ được dùng để scaffold dự án. Tuy nhiên, cũng có thể dùng create-hono với npm, pnpm, và yarn. Hãy chắc chắn chọn cloudflare-workers khi được hỏi về template. Bạn có thể thấy bun như một tùy chọn riêng, nhưng đó không phải template dùng trong demo.

bun create hono@latest

Cài Đặt Dependencies

Bây giờ, bạn có thể chạy lệnh sau với package manager tùy chọn để cài đặt các dependencies còn lại:

bun install @upstash/qstash @upstash/ratelimit @upstash/redis langchain openai

Cấu Hình Dự Án

Tính đến thời điểm viết, create-hono bao gồm lockfiles trong .gitignore mặc định. Mặc dù không bắt buộc, bạn có thể cập nhật .gitignore để loại trừ lockfiles như sau:

node_modules
dist
.wrangler
.dev.vars
wrangler.toml

Bây giờ, chúng ta có thể thiết lập biến môi trường từ các yêu cầu tiên quyết. Chúng có thể được thêm vào wrangler.toml, file này đã được loại trừ khỏi source control.

[vars]
QSTASH_CURRENT_SIGNING_KEY="sig_********"
QSTASH_NEXT_SIGNING_KEY="sig_********"
UPSTASH_REDIS_REST_URL="https://********.upstash.io"
UPSTASH_REDIS_REST_TOKEN="********"
OPENAI_API_KEY="sk-********"

Cuối cùng, sửa src/index.ts để thêm typing cho biến môi trường từ trước:

type Bindings = {
  QSTASH_CURRENT_SIGNING_KEY: string;
  QSTASH_NEXT_SIGNING_KEY: string;
  UPSTASH_REDIS_REST_URL: string;
  UPSTASH_REDIS_REST_TOKEN: string;
  OPENAI_API_KEY: string;
};
const app = new Hono<{ Bindings: Bindings }>();

Lợi ích của việc có hai signing key đến từ việc bạn có thể xoay chúng một lần mà không cần cập nhật biến môi trường, vì QStash sẽ tự động thử dùng next signing key nếu current key thất bại.

Phát Triển

Ở giai đoạn này, wrangler nên có thể đọc biến môi trường và triển khai dự án. Để làm vậy, chạy lệnh sau với package manager tùy chọn:

bun run dev

wrangler sẽ khởi động server Hono.js và cung cấp URL local trên cổng 8787 để test dự án. Nếu bạn muốn bắt đầu edge preview session thay vì test local, sửa script dev trong package.json như sau:

"dev": "wrangler dev src/index.ts --remote",

Để xem cấu hình và log của Cloudflare Worker, bạn phải triển khai worker trước:

bun run deploy

Điều này sẽ hướng dẫn bạn qua các bước đăng nhập Cloudflare, tự động triển khai dự án lần đầu sau khi xác thực.

Tạo Middleware

Với mục đích debug, việc log các request nhận được từ QStash sẽ hữu ích. Chúng sẽ hiển thị trong dashboard Cloudflare Worker dưới tab "Logs" khi bạn nhấn Begin log stream. Hono.js cung cấp middleware logger có thể thêm vào router:

import { Hono } from "hono";
import { logger } from "hono/logger";
// snip
const app = new Hono<{ Bindings: Bindings }>();
app.use("*", logger());
// snip

Tăng Hiệu Suất: Cache LLM Theo Yêu Cầu Với LangChain, Redis Và QStash

Kết Nối QStash Với Cloudflare Workers

Trước khi phát triển API endpoint bằng Hono.js, chúng ta cần cách chặn tin nhắn từ QStash và loại bỏ request nếu chữ ký không hợp lệ. May mắn thay, Hono.js cung cấp cách triển khai custom middleware, luôn chạy trước handlers. Nó đủ mạnh để tổ chức middleware vào các file riêng biệt theo ý muốn.

Trong middleware, chúng ta có thể dùng receiver của QStash. Hãy tạo file mới src/middleware/verify.ts, và export function có type MiddlewareHandler:

import { Receiver } from "@upstash/qstash";
import { type MiddlewareHandler } from "hono";
declare global {
  interface Response {
    locals: {
      query: string;
    };
  }
}
export const verify: MiddlewareHandler = async (ctx, next) => {
  const receiver = new Receiver({
    currentSigningKey: ctx.env.QSTASH_CURRENT_SIGNING_KEY,
    nextSigningKey: ctx.env.QSTASH_NEXT_SIGNING_KEY,
  });
};

Hono.js truyền object ctx (context) cho mỗi middleware và handler. Đây không trực tiếp giống ExecutionContext của Cloudflare Workers—nhưng nó chứa cùng thông tin. Object ctx của Hono gần như tương đương với request object, environment, và execution context truyền cho handler fetch mặc định của Cloudflare Workers, tất cả gộp vào một object.

Chúng ta cũng sửa interface Response toàn cục để bao gồm locals tùy chỉnh. Khác với Express, Hono không tạo object res.locals mặc định. Chúng ta sẽ dùng nó để truyền query đến handler sau. Tiếp theo, truy cập biến môi trường đã typed từ trước để xây dựng receiver.

Bây giờ chúng ta có thể dùng receiver để verify chữ ký của request:

// snip
const body = await ctx.req.text();
ctx.res.locals = { query: JSON.parse(body).query };
const isValid = await receiver
  .verify({
    signature: ctx.req.headers.get("Upstash-Signature")!,
    body,
  })
  .catch((err) => {
    console.error(err);
    return false;
  });
if (!isValid) {
  return new Response("Invalid signature", { status: 401 });
}
await next();

Đầu tiên, lấy request object từ context. Hono.js thuận tiện chỉ dùng Web Standard APIs như fetch, URL, Request, và Response. Mặc dù demo dùng trên Cloudflare Workers, điều này cho phép chạy trên vô số môi trường khác, bao gồm edge/serverless.

Từ request object, đọc body dưới dạng text cũng như header Upstash-Signature, chứa custom JWT. Chúng ta dùng receiver để verify chữ ký trong JWT bằng cách truyền signature và body của request. Trong handler .catch, log lỗi và trả về false để chỉ ra chữ ký không hợp lệ.

Vì chúng ta consume body của request, chúng ta sẽ không truy cập được nó trong handler thực tế sau. Điều này vì body là ReadableStream chỉ có thể consume một lần. Thay vào đó, để truyền query đến handler, thêm nó vào object locals trên response. Cuối cùng, nếu chữ ký không hợp lệ, trả về response 401 Unauthorized. Ngược lại, gọi next() để tiếp tục middleware hoặc handler tiếp theo.

Thêm Rate Limiting

Vì chúng ta sẽ kết nối endpoint này với API key OpenAI cá nhân, quan trọng là đảm bảo không vô tình vượt quá rate limit. May mắn thay, Upstash cung cấp SDK Rate Limiting để dễ dàng thêm rate limiting vào endpoint. Nếu số request vượt ngưỡng cho trước, trả về response 429 Too Many Requests.

Hãy tạo middleware mới trong src/middleware/ratelimit.ts:

import { Ratelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis/cloudflare";
import { type MiddlewareHandler } from "hono";
export const ratelimit: MiddlewareHandler = async (ctx, next) => {
  const redis = new Redis({
    url: ctx.env.UPSTASH_REDIS_REST_URL,
    token: ctx.env.UPSTASH_REDIS_REST_TOKEN,
  });
  const ratelimit = new Ratelimit({
    redis,
    limiter: Ratelimit.slidingWindow(10, "10 s"),
    analytics: true,
  });
  await next();
};

Ở đây, kết nối database Upstash Redis với SDK Rate Limiting. Chúng ta phải tạo instance Redis thủ công dùng biến môi trường từ ctx.env, vì Redis.fromEnv() không đọc được tự động khi dùng Cloudflare Workers. Khi analytics là true, SDK sẽ tự động gọi Redis để giữ cache các cuộc gọi cho mỗi identifier. Nó dùng @upstash/ratelimit làm prefix mặc định.

SDK cũng hỗ trợ dùng ephemeral cache với Map thay vì Redis, tiết kiệm thời gian và tài nguyên dưới tải cực đại:

const cache = new Map(); // bên ngoài middleware handler
// snip
const ratelimit = new Ratelimit({
  ephemeralCache: cache,
  // snip
});

Chúng ta cũng cung cấp limiter cho SDK. Đây là function cho SDK biết cách rate limit request. Chúng ta dùng limiter slidingWindow, cấu hình cho phép tối đa 10 request mỗi 10 giây.

SDK cũng cho phép cung cấp identifier cho mỗi request, tự động theo dõi số request trong khoảng thời gian. Trong ứng dụng thực tế, có thể dùng IP người dùng làm identifier, nhưng cho demo này, dùng string constant để limit tất cả request với một ratelimit:

// snip
const identifier = "openai";
const { success } = await ratelimit.limit(identifier);
if (!success) {
  return new Response("Too many requests", { status: 429 });
}
await next();
// snip

Nếu request bị rate limit, trả về 429 Too Many Requests. Ngược lại, gọi next() để tiếp tục. Trong trường hợp kết nối nhiều Redis database với SDK, nó sẽ phải đồng bộ hóa giữa chúng. Điều này dẫn đến dangling promises trên Vercel Edge và Cloudflare Workers, xử lý như sau:

const { pending, success } = await ratelimit.limit(identifier);
ctx.event.waitUntil(pending);

Cách làm này có thể khác tùy thư viện. Vì Hono dùng Web Standard APIs, dùng method event.waitUntil để chờ promise resolve. Tuy nhiên, demo này chỉ dùng một Redis database, nên không lo về dangling promises.

Nhận Tin Nhắn Từ QStash

Khi gửi HTTP request đến QStash, destination sẽ là URL endpoint Cloudflare Workers. Chúng ta dùng Hono.js tạo handler cho endpoint này. Thêm handler mới trong src/index.ts, bật middleware từ trước:

// snip
import { ratelimit } from "./middleware/ratelimit";
import { verify } from "./middleware/verify";
// snip
app.post("/api/announce", ratelimit, verify, async (ctx) => {});

Trong handler này, dùng LangChain sinh phản hồi cho prompt cho trước, dùng Upstash Redis cache kết quả:

// snip
import { Redis } from "@upstash/redis/cloudflare";
import { UpstashRedisCache } from "langchain/cache/upstash_redis";
import { OpenAI } from "langchain/llms/openai";
// snip
app.post("/api/announce", ratelimit, verify, async (ctx) => {
  const redis = new Redis({
    url: ctx.env.UPSTASH_REDIS_REST_URL,
    token: ctx.env.UPSTASH_REDIS_REST_TOKEN,
  });
  const cache = new UpstashRedisCache({ client: redis });
  const model = new OpenAI({
    cache,
    openAIApiKey: ctx.env.OPENAI_API_KEY,
  });
  const query = ctx.res.locals.query;
  const result = await model
    .call(query)
    .then((result) => {
      console.log(result);
      return result;
    })
    .catch((err) => console.error(err));
  return new Response(result ?? "", { status: 200 });
});
// snip

Ở đây, import các class cần thiết thiết lập caching cho LangChain. Xây dựng chain dùng model OpenAI và cache Upstash Redis, truyền instance Upstash Redis cho cache. Lại phải truyền OpenAI API Key thủ công cho model vì không đọc được tự động trên Cloudflare Workers.

Sau đó, truy cập query đã lưu trong res.locals, dùng nó gọi model và log kết quả. Cuối cùng, trả về kết quả làm response, hoặc string rỗng nếu có lỗi. Ở giai đoạn này, test endpoint bằng cách gửi POST request và kiểm tra response. Chạy lại script deploy trong package.json:

bun run deploy

Sau khi lấy URL endpoint Cloudflare Workers, gửi POST request bằng curl:

curl -XPOST \
"https://qstash.upstash.io/v2/publish/https://<YOUR_API_URL>.workers.dev/api/announce" \
-H "Authorization: Bearer <YOUR_QSTASH_TOKEN>" \
-H "Content-Type: application/json" \
-d "{ \"query\": \"What's the derivative of e^x?\" }"

Upstash cung cấp QStash console để gửi request dễ dàng hơn. Cũng đơn giản để cho QStash cron job chạy request lặp lại. QStash truyền body request nguyên vẹn đến endpoint. Chúng ta gửi JSON payload sau, nơi query là prompt cho model:

{ "query": "What's the derivative of e^x?" }

Tăng Hiệu Suất: Cache LLM Theo Yêu Cầu Với LangChain, Redis Và QStash

Kết Luận

SDK Rate Limiting cache thành công số lượng gọi cho mỗi identifier:

Tăng Hiệu Suất: Cache LLM Theo Yêu Cầu Với LangChain, Redis Và QStash

Tương tự, nội dung sinh ra từ LangChain cache thành công trong database Upstash Redis:

Tăng Hiệu Suất: Cache LLM Theo Yêu Cầu Với LangChain, Redis Và QStash

Và cuối cùng, response được log trong log Cloudflare Worker:

Tăng Hiệu Suất: Cache LLM Theo Yêu Cầu Với LangChain, Redis Và QStash