XADD Builds

https://www.xadd.dev/builds
Admin
A collection of technical guides and tutorials on caching AI SDK tool results, managing chat...
Tokens:14,519
Snippets:136
Trust Score:2.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Express Session with connect-redis Example

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

Demonstrates how to integrate connect-redis with express-session for managing user sessions in an Express application. Sessions are stored in Redis as JSON strings keyed by session ID.

```javascript
import session from 'express-session';
import RedisStore from 'connect-redis';
import { createClient } from 'redis';

// Initialize client. See note below about universal Redis.
let redisClient = createClient({
  url: process.env.REDIS_URL
});
redisClient.on('error', (err) => console.error('Redis Client Error', err));
await redisClient.connect();

// Initialize store. Use `redisClient` for client.
// If you'd want to use a different client, use `new RedisStore({...})` directly.
let sessionStore = new RedisStore({
  // instanceof Redis
  client: redisClient,
  prefix: 'myapp:',
});

// Configure session middleware
let app = express();
app.use(session({
  store: sessionStore,
  secret: 'your secret key',
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: process.env.NODE_ENV === 'production',
    maxAge: 1000 * 60 * 60 * 24 * 7 // 1 week
  }
}));

// Example route
app.get('/', (req, res) => {
  if (req.session.views) {
    req.session.views++;
    res.send(`You have viewed this page ${req.session.views} times`);
  } else {
    req.session.views = 1;
    res.send('Welcome to the club!');
  }
});

// ... other app routes and configurations
```

--------------------------------

### Tiered Rate Limiters with Upstash Redis

Source: https://www.xadd.dev/builds/how-do-i-add-rate-limiting-to-a-nextjs-app-with-upstash-redis-2026

This example sets up multiple `Ratelimit` instances for different user tiers (anon, free, pro), each with its own Redis prefix and limit configuration. It uses an ephemeral cache for performance and `tokenBucket` for the pro tier to allow bursts.

```typescript
// src/lib/tiered.ts
import { Ratelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis";

const redis = Redis.fromEnv();
const cache = new Map<string, number>();

type Tier = "anon" | "free" | "pro";

const limiters: Record<Tier, Ratelimit> = {
  anon: new Ratelimit({
    redis, prefix: "rl:anon",
    limiter: Ratelimit.slidingWindow(20, "1 m"),
    ephemeralCache: cache, analytics: true,
  }),
  free: new Ratelimit({
    redis, prefix: "rl:free",
    limiter: Ratelimit.slidingWindow(100, "1 m"),
    ephemeralCache: cache, analytics: true,
  }),
  pro: new Ratelimit({
    redis, prefix: "rl:pro",
    // 200 tokens/min steady, burst up to 600
    limiter: Ratelimit.tokenBucket(200, "1 m", 600),
    ephemeralCache: cache, analytics: true,
  }),
};

export async function checkQuota(tier: Tier, id: string, weight = 1) {
  return limiters[tier].limit(id, { rate: weight });
}
```

--------------------------------

### Cache Performance Results

Source: https://www.xadd.dev/builds/caching-ai-sdk-v6-tool-results-with-redis

Example output from the benchmarking script, showing a significant reduction in latency for cache hits compared to cache misses. This highlights the performance benefits of using Redis caching.

```text
miss median: 809.6 ms
hit  median:  32.1 ms

```

--------------------------------

### Example Bloom Filter Sizing Calculations

Source: https://www.xadd.dev/builds/how-do-you-use-bloom-filters-with-upstash-redis

Illustrates the calculated bit array size (m) and number of hash functions (k) for a Bloom filter with 100,000 items at different false positive probabilities.

```plaintext
p=0.01    m=958506 bits   k=7   bits/item=9.585
p=0.001   m=1437759 bits  k=10  bits/item=14.378
p=0.0001  m=1917012 bits  k=13  bits/item=19.170
```

--------------------------------

### Configure Multi-Region Rate Limiter with Fixed Window

Source: https://www.xadd.dev/builds/how-do-i-add-rate-limiting-to-a-nextjs-app-with-upstash-redis-2026

Use MultiRegionRatelimit for global applications with users across multiple continents where single-region latency is a concern. This example configures a fixed window limiter across multiple Redis instances. Note that CRDT replication in multi-region can lead to exceeding the configured limit by a small margin during sync.

```tsx
import { MultiRegionRatelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis";

export const ratelimit = new MultiRegionRatelimit({
  redis: [
    new Redis({ url: process.env.US_URL!, token: process.env.US_TOKEN! }),
    new Redis({ url: process.env.EU_URL!, token: process.env.EU_TOKEN! }),
  ],
  limiter: MultiRegionRatelimit.fixedWindow(100, "10 s"),
  prefix: "rl:multi",
  analytics: true,
});
```

--------------------------------

### Full Session Store Implementation with Upstash Redis

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

This snippet provides a complete `SessionStore` class using Upstash Redis. It includes methods for creating, reading, and destroying sessions, with automatic JSON serialization/deserialization. It highlights atomic `SET ... EX` and pipelined `GET` + `EXPIRE` for efficiency.

```typescript
import { Redis } from "@upstash/redis";
import { randomBytes, createHash } from "node:crypto";

export type SessionData = {
  userId: string;
  email: string;
  csrfToken: string;
  createdAt: number;
};

const TTL_SECONDS = 60 * 60 * 24 * 14; // 14 days absolute
const SLIDING_SECONDS = 60 * 30;       // 30 min idle window

const sidToKey = (sid: string) =>
  `sess:${createHash("sha256").update(sid).digest("hex")}`;

export class SessionStore {
  constructor(private redis: Redis) {}

  newSid(): string {
    // 32 bytes = 256 bits of entropy. base64url is cookie-safe.
    return randomBytes(32).toString("base64url");
  }

  async create(sid: string, data: SessionData) {
    await this.redis.set(sidToKey(sid), data, { ex: TTL_SECONDS });
  }

  async read(sid: string): Promise<SessionData | null> {
    const key = sidToKey(sid);
    // GET + bump the TTL in one pipelined round trip.
    const p = this.redis.pipeline();
    p.get<SessionData>(key);
    p.expire(key, SLIDING_SECONDS);
    const [data] = await p.exec<[SessionData | null, number]>();
    return data ?? null;
  }

  async destroy(sid: string) {
    await this.redis.del(sidToKey(sid));
  }
}
```

--------------------------------

### Next.js App Router Session Cookie Setup

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

Illustrates setting and reading a session ID cookie in Next.js App Router using the built-in cookies API. This approach is suitable for stateless encrypted cookies or when integrating with a server-side session store.

```typescript
import { cookies } from 'next/headers';

// In a Route Handler or Server Action to set the cookie:
const sid = generateSessionId(); // Your session ID generation logic
cookies().set('sid', sid, {
  httpOnly: true,
  secure: true,
  sameSite: 'lax',
  maxAge: 60 * 60 * 24 * 14 // 14 days
});

// In a middleware or protected route to read the cookie:
const sessionId = cookies().get('sid')?.value;
if (sessionId) {
  // Look up session in Redis using sessionId
}
```

--------------------------------

### Configure Rate Limiter with Timeout and Ephemeral Cache

Source: https://www.xadd.dev/builds/how-do-i-add-rate-limiting-to-a-nextjs-app-with-upstash-redis-2026

Set a short network timeout and use an in-memory cache to maintain availability when Redis is slow or unresponsive. The timeout defaults to 5 seconds, which is too long; this example reduces it to 1000ms. The ephemeral cache stores blocked identifiers locally to avoid Redis calls for repeat requests.

```tsx
const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(10, "10 s"),
  timeout: 1000,        // fail open after 1s
  ephemeralCache: new Map(),
  analytics: true,
});
```

--------------------------------

### Redis HTTP Client Instantiation for Serverless

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

Shows the recommended way to instantiate the Upstash Redis HTTP client for use in serverless environments like Vercel. Instantiating at module scope avoids the overhead of creating a new client for each request.

```typescript
import { Redis } from '@upstash/redis';

// Instantiate the Redis client once at module scope
const redisClient = Redis.fromEnv();

// Use redisClient in your Route Handlers, Server Actions, etc.
export async function POST(request: Request) {
  const data = await request.json();
  await redisClient.set('user:' + data.id, JSON.stringify(data));
  return new Response(JSON.stringify({ success: true }));
}
```

--------------------------------

### Define an AI SDK v6 Web Search Tool

Source: https://www.xadd.dev/builds/caching-ai-sdk-v6-tool-results-with-redis

This snippet defines a basic web search tool using the AI SDK v6. It includes a description and an input schema for the search query. The `execute` function is a placeholder for the actual web search implementation.

```tsx
import { tool } from "ai";
import { z } from "zod";

const web_search = tool({
  description: "Search the web for up-to-date information.",
  inputSchema: z.object({
    query: z.string(),
  }),
  execute: async ({ query }) => {
    return await searchTheWeb(query);
  },
});
```

--------------------------------

### Redis TCP Client Instantiation for Long-Running Servers

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

Demonstrates instantiating the ioredis client, suitable for long-running server environments. This client uses a persistent TCP connection, which is more efficient than repeated HTTP requests for such applications.

```typescript
import Redis from 'ioredis';

// Instantiate the ioredis client once at module scope
const redisClient = new Redis({
  url: process.env.REDIS_URL // e.g., 'redis://:password@host:port'
});

// Use redisClient for your Redis operations
redisClient.on('connect', () => {
  console.log('Connected to Redis');
});

redisClient.on('error', (err) => {
  console.error('Redis Error:', err);
});

// Example usage:
async function getUser(id: string) {
  const userData = await redisClient.get(`user:${id}`);
  return userData ? JSON.parse(userData) : null;
}
```

--------------------------------

### Benchmark Cache Performance

Source: https://www.xadd.dev/builds/caching-ai-sdk-v6-tool-results-with-redis

This script measures the performance difference between a cold cache call (miss) and a warm cache call (hit) for the web search tool. It executes 10 unique queries and calculates the median time for each.

```typescript
// bench.ts
import { web_search } from "./tools/web-search";

const ctx = { toolCallId: "bench", messages: [] } as never;
const misses: number[] = [];
const hits: number[] = [];

for (let i = 0; i < 10; i++) {
  const input = { query: `bench query ${Date.now()}-${i}` };

  const t1 = performance.now();
  await web_search.execute!(input, ctx);
  misses.push(performance.now() - t1);

  const t2 = performance.now();
  await web_search.execute!(input, ctx);
  hits.push(performance.now() - t2);
}

const median = (xs: number[]) =>
  [...xs].sort((a, b) => a - b)[Math.floor(xs.length / 2)];

console.log(`miss median: ${median(misses).toFixed(1)} ms`);
console.log(`hit  median: ${median(hits).toFixed(1)} ms`);

```

--------------------------------

### Apply Cache Wrapper to Web Search Tool

Source: https://www.xadd.dev/builds/caching-ai-sdk-v6-tool-results-with-redis

This snippet shows how to wrap an existing tool definition with the `cached` function. The agent code consuming the tool remains unchanged. Ensure your Redis connection and API keys are configured.

```typescript
// tools/web-search.ts
import { tool } from "ai";
import { z } from "zod";
import { cached } from "@/lib/cache";

async function searchTheWeb(query: string) {
  // any search provider works — firecrawl, tavily, exa, etc.
  const res = await fetch("https://api.firecrawl.dev/v2/search", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.FIRECRAWL_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ query, limit: 5 }),
  });
  if (!res.ok) throw new Error(`web search failed: ${res.status}`);
  return (await res.json()) as {
    success: boolean;
    data: { web: { url: string; title: string; description: string }[] };
  };
}

export const web_search = cached(
  "web_search",
  tool({
    description: "Search the web for up-to-date information.",
    inputSchema: z.object({
      query: z.string().describe("The search query."),
    }),
    execute: async ({ query }) => searchTheWeb(query),
  }),
  { ttlSeconds: 60 * 60 },
);

```

--------------------------------

### Integrate Cached Tool into Agent

Source: https://www.xadd.dev/builds/caching-ai-sdk-v6-tool-results-with-redis

Demonstrates how to use the cached web search tool within an AI agent's configuration. The tool is passed as part of the `tools` object, and the agent code does not need modification.

```typescript
import { streamText } from "ai";
import { anthropic } from "@ai-sdk/anthropic";
import { web_search } from "@/tools/web-search";

const result = streamText({
  model: anthropic("claude-sonnet-4-6"),
  messages,
  tools: { web_search },
});

```

--------------------------------

### Enable Protection and Limit Requests with IP, User Agent, and Country

Source: https://www.xadd.dev/builds/how-do-i-add-rate-limiting-to-a-nextjs-app-with-upstash-redis-2026

Activate built-in protection features to automatically block abusive IPs. Pass request details like IP address, user agent, and country to the limit function. This enables both a manual deny list managed via the Upstash dashboard and an automatic IP deny list synced from external aggregators.

```tsx
const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(10, "10 s"),
  enableProtection: true,
  analytics: true,
});

const { success, reason, deniedValue, pending } = await ratelimit.limit(userId, {
  ip: clientIp,
  userAgent: req.headers.get("user-agent") ?? undefined,
  country: req.headers.get("x-vercel-ip-country") ?? undefined,
});
after(pending);

if (!success && reason === "denyList") {
  console.warn("denied by deny list:", deniedValue);
}
```

--------------------------------

### Calculate Optimal Bloom Filter Parameters

Source: https://www.xadd.dev/builds/how-do-you-use-bloom-filters-with-upstash-redis

These helper functions calculate the optimal number of bits (m) and hash functions (k) for a Bloom filter given the expected number of items (n) and the desired false positive probability (p).

```typescript
export function optimalBits(n: number, p: number): number {
  return Math.ceil((-n * Math.log(p)) / Math.LN2 ** 2);
}

export function optimalHashes(m: number, n: number): number {
  return Math.max(1, Math.round((m / n) * Math.LN2));
}
```

--------------------------------

### Implement Language Model Caching with Redis

Source: https://www.xadd.dev/builds/caching-ai-sdk-v6-tool-results-with-redis

This code demonstrates a language model middleware for caching responses using Redis. It wraps the `doGenerate` function, caching the result based on the entire `params` object. The cache is set with an expiration time of one hour.

```tsx
import { Redis } from "@upstash/redis";
import type { LanguageModelMiddleware } from "ai";

const redis = Redis.fromEnv();

const cache: LanguageModelMiddleware = {
  specificationVersion: "v3",
  wrapGenerate: async ({ doGenerate, params }) => {
    const key = JSON.stringify(params); // 👈 whole prompt, settings, history
    const cached = await redis.get(key);
    if (cached) return cached as Awaited<ReturnType<typeof doGenerate>>;

    const result = await doGenerate();
    await redis.set(key, result, { ex: 60 * 60 });
    return result;
  },
};
```

--------------------------------

### Implement Redis Cache Wrapper Function

Source: https://www.xadd.dev/builds/caching-ai-sdk-v6-tool-results-with-redis

This function caches tool execution results in Redis. It hashes inputs to create cache keys and sets a Time-To-Live (TTL) for cache entries. Use this to avoid redundant computations and external API calls.

```typescript
// lib/cache.ts
import { Redis } from "@upstash/redis";
import type { Tool } from "ai";

const redis = Redis.fromEnv();

// we sort object keys so {a:1,b:2} and {b:2,a:1} hash the same.
function stableStringify(value: unknown): string {
  if (value === null || typeof value !== "object") return JSON.stringify(value);
  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
  const entries = Object.entries(value as Record<string, unknown>).sort(
    ([a], [b]) => a.localeCompare(b),
  );
  return `{${entries
    .map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`)
    .join(",")}}
`;
}

export function cached<T extends Tool>(
  name: string,
  toolDef: T,
  options: { ttlSeconds?: number } = {},
): T {
  const original = toolDef.execute;
  if (!original) return toolDef;

  const ttl = options.ttlSeconds ?? 60 * 60; // 1 hour default

  return {
    ...toolDef,
    execute: async (input: unknown, ctx: Parameters<typeof original>[1]) => {
      const key = `tool:${name}:${stableStringify(input)}`;

      const hit = await redis.get(key);
      if (hit !== null) return hit;

      const result = await original(
        input as Parameters<typeof original>[0],
        ctx,
      );
      await redis.set(key, result, { ex: ttl });
      return result;
    },
  } as T;
}

```

--------------------------------

### Load Initial Chat History in Next.js App Router

Source: https://www.xadd.dev/builds/how-do-you-store-vercel-ai-sdk-chat-history-in-redis

Load chat history from Redis in a server component and pass it as `initialMessages` to the `Chat` component. This ensures the chat renders with history already present, avoiding client-side loading states.

```tsx
import { loadChat } from "@/util/chat-store";
import { Chat } from "@/ui/chat";

export default async function Page(props: {
  params: Promise<{ id: string }>;
}) {
  const { id } = await props.params;
  const initialMessages = await loadChat(id);
  return <Chat id={id} initialMessages={initialMessages} />;
}

```

--------------------------------

### Bloom Filter Sizing Math

Source: https://www.xadd.dev/builds/how-do-you-use-bloom-filters-with-upstash-redis

This table outlines the relationship between accuracy target, bits per item, and the number of hash functions required for a Bloom filter.

```markdown
| Accuracy target | Bits per item | Number of hash functions |
| --- | --- | --- |
| 1 in 10 wrong | 4.8 | 3 |
| 1 in 100 wrong | 9.6 | 7 |
| 1 in 1,000 wrong | 14.4 | 10 |
| 1 in 10,000 wrong | 19.2 | 13 |
```

--------------------------------

### Tracking and Revoking User Sessions

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

This snippet shows how to implement a 'log me out everywhere' feature. It uses a Redis set to track all session IDs for a given user and provides methods to add sessions to the tracking set and revoke all sessions for a user by deleting their associated keys.

```typescript
async track(userId: string, sid: string) {
  await this.redis.sadd(`user:${userId}:sids`, sid);
}

async revokeAll(userId: string): Promise<number> {
  const sids = await this.redis.smembers(`user:${userId}:sids`);
  if (sids.length === 0) return 0;
  const keys = sids.map(sidToKey);
  const [deleted] = await Promise.all([
    this.redis.del(...keys),
    this.redis.del(`user:${userId}:sids`),
  ]);
  return deleted;
}
```

--------------------------------

### Set Session with JSON Payload and TTL

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

Use this command to store a session payload as a JSON string with an expiration time. This is the default approach for small payloads (under 1 KB) where the entire session is read at once.

```redis
SET sess:<sid> <json> EX 1800
```

--------------------------------

### AI SDK 6 onFinish Callback Structure

Source: https://www.xadd.dev/builds/how-do-you-store-vercel-ai-sdk-chat-history-in-redis

The `onFinish` callback receives the complete message history, including the latest assistant reply, in a format compatible with `useChat` on the client.

```typescript
onFinish: ({ messages }: { messages: UIMessage[] }) => {
  // messages = previous history + new user message + assistant reply
  // same shape useChat uses on the client, ready to JSON.stringify
}
```

--------------------------------

### Route Handler for Streaming Chat with Redis Persistence

Source: https://www.xadd.dev/builds/how-do-you-store-vercel-ai-sdk-chat-history-in-redis

This route handler processes incoming chat messages, streams responses using `streamText`, and persists the conversation delta to Redis using the `onFinish` callback. It requires `convertToModelMessages` to be awaited.

```typescript
// app/api/chat/route.ts
import {
  convertToModelMessages,
  createIdGenerator,
  streamText,
  type UIMessage,
} from "ai";
import { openai } from "@ai-sdk/openai";
import { appendMessages, loadChat } from "@/util/chat-store";

export async function POST(req: Request) {
  const { message, id } = (await req.json()) as { message: UIMessage; id: string };

  const previous = await loadChat(id);
  const messages = [...previous, message];

  const result = streamText({
    model: openai("gpt-4o"),
    messages: await convertToModelMessages(messages),
  });

  // drain the stream even if the client disconnects 👇
  result.consumeStream();

  return result.toUIMessageStreamResponse({
    originalMessages: messages,
    generateMessageId: createIdGenerator({ prefix: "msg", size: 16 }),
    onFinish: async ({ messages: finalMessages }) => {
      const delta = finalMessages.slice(previous.length);
      await appendMessages(id, delta);
    },
  });
}
```

--------------------------------

### Redis Chat Store Utility Functions

Source: https://www.xadd.dev/builds/how-do-you-store-vercel-ai-sdk-chat-history-in-redis

Utility functions for managing chat history in Redis. `createChat` generates a new chat ID, `loadChat` retrieves all messages for a given chat ID, and `appendMessages` adds new messages to the end of the Redis list.

```typescript
// util/chat-store.ts
import { Redis } from "@upstash/redis";
import { generateId, type UIMessage } from "ai";

const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL!,
  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
});

const key = (chatId: string) => `chat:${chatId}:messages`;

export async function createChat(): Promise<string> {
  // no write needed yet; an empty list means "no messages"
  return generateId();
}

export async function loadChat(chatId: string): Promise<UIMessage[]> {
  return redis.lrange<UIMessage>(key(chatId), 0, -1);
}

export async function appendMessages(
  chatId: string,
  messages: UIMessage[],
): Promise<void> {
  if (messages.length === 0) return;
  await redis.rpush(key(chatId), ...messages);
}
```

--------------------------------

### Session Read with Combined Absolute and Sliding TTLs

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

This snippet demonstrates how to combine absolute and sliding TTLs for sessions. It checks if the session's absolute lifetime has passed before renewing the sliding TTL, preventing indefinite session validity and annoying mid-task logouts.

```typescript
async read(sid: string): Promise<SessionData | null> {
  const key = sidToKey(sid);
  const data = await this.redis.get<SessionData>(key);
  if (!data) return null;
  const MAX_LIFETIME_MS = 14 * 24 * 60 * 60 * 1000;
  if (Date.now() - data.createdAt > MAX_LIFETIME_MS) {
    await this.redis.del(key);
    return null;
  }
  await this.redis.expire(key, 60 * 30); // sliding idle window
  return data;
}
```

--------------------------------

### Rate Limiter in proxy.ts for API Routes

Source: https://www.xadd.dev/builds/how-do-i-add-rate-limiting-to-a-nextjs-app-with-upstash-redis-2026

This snippet sets up a rate limiter in `proxy.ts` to protect all API routes. It uses the IP address as the identifier and applies a sliding window limit. The `after()` call is used for Next.js 15.1+ to run analytics writes after the response is sent.

```typescript
// src/proxy.ts
import { NextRequest, NextResponse, after } from "next/server";
import { Ratelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis";

const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(20, "10 s"),
  prefix: "rl:proxy",
  analytics: true,
});

export const config = {
  matcher: ["/api/:path*"],
};

export default async function proxy(req: NextRequest) {
  const ip =
    req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ??
    req.headers.get("x-real-ip") ??
    "127.0.0.1";

  const { success, limit, remaining, reset, pending } = await ratelimit.limit(ip);
  after(pending);

  const res = success
    ? NextResponse.next()
    : NextResponse.json({ error: "Too many requests" }, { status: 429 });
  res.headers.set("X-RateLimit-Limit", limit.toString());
  res.headers.set("X-RateLimit-Remaining", remaining.toString());
  res.headers.set("X-RateLimit-Reset", reset.toString());
  return res;
}
```

--------------------------------

### Identify Caller IP Address

Source: https://www.xadd.dev/builds/how-do-i-add-rate-limiting-to-a-nextjs-app-with-upstash-redis-2026

This code snippet demonstrates how to extract the client's IP address from request headers, prioritizing `x-forwarded-for`, then `x-real-ip`, and falling back to `127.0.0.1` for local testing. This is crucial for accurate rate limiting.

```typescript
const ip =
  req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ??
  req.headers.get("x-real-ip") ??
  "127.0.0.1";
```

--------------------------------

### Set Session with Hash Fields and Separate Expiration

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

Use HSET to store individual session fields and EXPIRE to set the TTL for the entire session key. This pattern is suitable when you frequently update a single field without rewriting the entire session payload.

```redis
HSET sess:<sid> field val
EXPIRE sess:<sid> 1800
```

--------------------------------

### Consume Stream to Prevent Data Loss on Client Disconnect

Source: https://www.xadd.dev/builds/how-do-you-store-vercel-ai-sdk-chat-history-in-redis

Call `consumeStream` on the result without awaiting it to ensure the model runs to completion and the full assistant reply is saved to Redis, even if the client disconnects. This prevents `onFinish` from being missed and ensures data persistence.

```typescript
import { streamText, toUIMessageStreamResponse } from "ai";
import { Redis } from "@upstash/redis";

const redis = new Redis({
  url: "https://...upstash.io",
  token: "...",
});

export const POST = async (req: Request) => {
  const { messages } = await req.json();

  const result = await streamText({
    model: "claude-3-opus-20240229",
    messages,
    async onFinish({
      content,
      // other params
    }) {
      // save to redis
      await redis.call(
        "RPUSH",
        "chat_history",
        JSON.stringify({ role: "assistant", content })
      );
    },
  });

  // Consume the stream without awaiting it to prevent backpressure
  // from causing onFinish to be skipped if the client disconnects.
  // This ensures the model runs to completion and the message is saved.
  void consumeStream(result.toReadableStream());

  return toUIMessageStreamResponse(result);
};

```

--------------------------------

### Add Item to Bloom Filter using BITFIELD

Source: https://www.xadd.dev/builds/how-do-you-use-bloom-filters-with-upstash-redis

Adds an item to a Bloom filter in Redis by calculating bit positions using double hashing and setting the corresponding bits with a single BITFIELD command. It returns true if any bit was flipped from 0 to 1, indicating the item was likely new.

```typescript
import { Redis } from "@upstash/redis";

function fnv1a64(bytes: Uint8Array, offset: bigint): bigint {
  const PRIME = 1099511628211n;
  const MASK = 0xffffffffffffffffn;
  let h = offset;
  for (let i = 0; i < bytes.length; i++) {
    h ^= BigInt(bytes[i]);
    h = (h * PRIME) & MASK;
  }
  return h;
}

const enc = new TextEncoder();
const A = 0xcbf29ce484222325n;
const B = 0x84222325cbf29ce4n;

function bitPositions(item: string, m: number, k: number): number[] {
  const bytes = enc.encode(item);
  const h1 = fnv1a64(bytes, A);
  const h2 = fnv1a64(bytes, B);
  const mBig = BigInt(m);
  const out: number[] = [];
  for (let i = 0; i < k; i++) {
    out.push(Number((h1 + BigInt(i) * h2) % mBig));
  }
  return out;
}

export async function bloomAdd(
  redis: Redis,
  key: string,
  bits: number,
  hashes: number,
  item: string,
): Promise<boolean> {
  const positions = bitPositions(item, bits, hashes);
  let cmd = redis.bitfield(key);
  for (const pos of positions) cmd = cmd.set("u1", pos, 1);
  const old = await cmd.exec(); // returns the old value of each bit
  return old.some((b) => b === 0); // true if any bit flipped
}
```

--------------------------------

### Estimate Cardinality of Bloom Filter

Source: https://www.xadd.dev/builds/how-do-you-use-bloom-filters-with-upstash-redis

Estimates the number of items in the filter by counting set bits and applying the Swamidass-Baldi estimator. Handles cases where no bits are set or all bits are set.

```typescript
export async function bloomCardinality(
  redis: Redis,
  key: string,
  bits: number,
  hashes: number,
): Promise<number> {
  const setBits = await redis.bitcount(key, 0, -1);
  if (setBits === 0) return 0;
  if (setBits >= bits) return Infinity;
  return Math.round(-(bits / hashes) * Math.log(1 - setBits / bits));
}
```

--------------------------------

### Validate UI Messages Against Schema Drift

Source: https://www.xadd.dev/builds/how-do-you-store-vercel-ai-sdk-chat-history-in-redis

Use the `validateUIMessages` helper to re-check stored messages against current tool and metadata schemas. This prevents errors if schemas have changed since the messages were saved. If validation fails, you can choose to drop or migrate offending messages.

```tsx
import { validateUIMessages, TypeValidationError } from "ai";

const previous = await loadChat(id);

let validated;
try {
  validated = await validateUIMessages({
    messages: [...previous, message],
    tools,
    metadataSchema,
  });
} catch (err) {
  if (err instanceof TypeValidationError) {
    // drop or migrate the offending messages, then retry
    validated = [message];
  } else {
    throw err;
  }
}

```

--------------------------------

### Check if Item Exists in Bloom Filter

Source: https://www.xadd.dev/builds/how-do-you-use-bloom-filters-with-upstash-redis

Computes bit positions for an item and uses BITFIELD to read them. Returns true if all bits are set, indicating probable existence.

```typescript
export async function bloomExists(
  redis: Redis,
  key: string,
  bits: number,
  hashes: number,
  item: string,
): Promise<boolean> {
  const positions = bitPositions(item, bits, hashes);
  let cmd = redis.bitfield(key);
  for (const pos of positions) cmd = cmd.get("u1", pos);
  const result = await cmd.exec();
  return result.every((b) => b === 1);
}
```

--------------------------------

### Disable Auto-Pipelining for Upstash Redis Client

Source: https://www.xadd.dev/builds/how-do-you-use-bloom-filters-with-upstash-redis

Configures the Upstash Redis client to disable automatic command batching, which is necessary for the correct functioning of chained commands like `bitfield()`.

```typescript
const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL!,
  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
  enableAutoPipelining: false,
});
```

--------------------------------

### Send Only Last Message in Chat Request

Source: https://www.xadd.dev/builds/how-do-you-store-vercel-ai-sdk-chat-history-in-redis

Configure the `useChat` hook to send only the latest message in the request body by customizing the `prepareSendMessagesRequest` hook within `DefaultChatTransport`. This optimizes payload size by avoiding redundant history transmission.

```tsx
"use client";

import { useChat } from "@ai-sdk/react";
import { DefaultChatTransport, type UIMessage } from "ai";
import { useState } from "react";

interface ChatProps {
  id: string;
  initialMessages: UIMessage[];
}

export function Chat({ id, initialMessages }: ChatProps) {
  const [input, setInput] = useState("");

  const { sendMessage, messages } = useChat({
    id,
    messages: initialMessages,
    transport: new DefaultChatTransport({
      api: "/api/chat",
      prepareSendMessagesRequest({ messages, id }) {
        return { body: { message: messages[messages.length - 1], id } };
      },
    }),
  });

  return (
    <div>
      {messages.map((m) => (
        <div key={m.id}>
          <strong>{m.role}:</strong>{" "}
          {m.parts.map((p, i) =>
            p.type === "text" ? <span key={i}>{p.text}</span> : null,
          )}
        </div>
      ))}

      <form
        onSubmit={(e) => {
          e.preventDefault();
          if (!input.trim()) return;
          sendMessage({ text: input });
          setInput("");
        }}
      >
        <input value={input} onChange={(e) => setInput(e.target.value)} />
        <button type="submit">Send</button>
      </form>
    </div>
  );
}

```

--------------------------------

### Redis 7.4 HEXPIRE for Individual Field TTL

Source: https://www.xadd.dev/builds/how-do-you-use-redis-as-a-session-store-2026-guide

Introduced in Redis 7.4, HEXPIRE allows setting a TTL for individual fields within a hash. This enables expiring specific session attributes without affecting the entire session record. Note that this feature might not be available on all managed Redis providers.

```redis
HEXPIRE sess:<sid> field <seconds>
```
Tokens:
Raw