docs: add per-IP rate limiting to the Ask AI route

In-memory fixed-window limit (20 req/min/IP) caps single-source volume on the
hot path, returning 429 with Retry-After. Best-effort on serverless; a shared
store + edge WAF remain the durable controls, but this closes the no-volume-cap
gap flagged in review.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ouiliame

apps/docs/app/api/chat/route.ts

@@ -35,8 +35,9 @@ function matchesLocale(sourceDocument: string, locale: string): boolean {
 /**
  * Abuse guards. This endpoint proxies a paid LLM, so an unauthenticated public
  * route is a target for scripted "free inference". These bounds cap the cost of
- * any single request; durable per-IP rate limiting, a provider spend cap, and
- * edge bot protection are provisioned separately (see the PR checklist).
+ * any single request; an in-memory per-IP rate limit (below) caps volume on the
+ * hot path. A shared-store rate limit, a provider spend cap, and edge bot
+ * protection remain the durable controls (see the PR checklist).
  *
  * The size cap counts only user-authored text — NOT the conversation history,
  * assistant turns, or retrieved doc chunks we add via the searchDocs tool, which
@@ -49,6 +50,46 @@ const MAX_STEPS = 6
 /** Backstop on the whole serialized payload — blocks stuffing assistant/tool parts past the user-text cap. */
 const MAX_TOTAL_CHARS = 1_000_000
 
+/**
+ * Per-IP rate limit. Fixed window, in-memory: this bounds volume from a single
+ * source on a warm instance without external infra. It is best-effort on
+ * serverless (state is per-instance, not shared across regions/cold starts);
+ * a shared store (e.g. Vercel KV) and an edge WAF remain the durable controls,
+ * but this closes the "no volume limit at all" gap on the hot path.
+ */
+const RATE_LIMIT_MAX = 20
+const RATE_LIMIT_WINDOW_MS = 60_000
+const rateLimitHits = new Map<string, { count: number; resetAt: number }>()
+
+/** Resolve the client IP from forwarding headers, falling back to a shared bucket. */
+function getClientIp(req: Request): string {
+  const forwarded = req.headers.get('x-forwarded-for')
+  if (forwarded) return forwarded.split(',')[0].trim()
+  return req.headers.get('x-real-ip') ?? 'unknown'
+}
+
+/** Fixed-window check. Returns retry-after seconds when the caller is over the limit, else null. */
+function rateLimit(ip: string, now: number): number | null {
+  const entry = rateLimitHits.get(ip)
+  if (!entry || now >= entry.resetAt) {
+    rateLimitHits.set(ip, { count: 1, resetAt: now + RATE_LIMIT_WINDOW_MS })
+    return null
+  }
+  if (entry.count >= RATE_LIMIT_MAX) {
+    return Math.ceil((entry.resetAt - now) / 1000)
+  }
+  entry.count += 1
+  return null
+}
+
+/** Drop expired buckets so the Map doesn't grow unbounded on a long-lived instance. */
+function sweepRateLimit(now: number): void {
+  if (rateLimitHits.size < 10_000) return
+  for (const [ip, entry] of rateLimitHits) {
+    if (now >= entry.resetAt) rateLimitHits.delete(ip)
+  }
+}
+
 /** A structurally valid UI message: has a role and a parts array. */
 function isValidMessage(message: unknown): message is UIMessage {
   return (
@@ -144,6 +185,16 @@ export async function POST(req: Request) {
     return new Response('Forbidden', { status: 403 })
   }
 
+  const now = Date.now()
+  sweepRateLimit(now)
+  const retryAfter = rateLimit(getClientIp(req), now)
+  if (retryAfter !== null) {
+    return new Response('Too many requests', {
+      status: 429,
+      headers: { 'Retry-After': String(retryAfter) },
+    })
+  }
+
   let body: { messages: UIMessage[]; locale?: string }
   try {
     body = await req.json()