Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Vercel Eve पर आधारित एजेंट को प्रोडक्शन में अपलोड करते ही सर्वरलेस की अंतर्निहित स्टेटलेसनेस (Statelessness) का सामना करना पड़ता है। जैसे ही अनुरोध समाप्त होता है, इंस्टेंस बंद हो जाता है और निष्पादन स्थिति गायब हो जाती है। इसके बावजूद यदि सेशन को पुनर्स्थापित करने के लिए हर बार PostgreSQL जैसे DB को हिट किया जाता है, तो 100ms से अधिक की देरी के साथ-साथ DB की लागत तेजी से बढ़ जाती है।
सर्वरलेस की सीमाओं को पार करने के लिए वास्तविक प्रोडक्शन में उपयोग की जाने वाली तीन संरचनाओं को यहाँ संक्षेप में प्रस्तुत किया गया है।
सर्वरलेस वातावरण में हर बार नया DB कनेक्शन स्थापित करना इंफ्रास्ट्रक्चर लागत और प्रतिक्रिया गति दोनों को बर्बाद करने का एक आसान तरीका है। HTTP REST API के माध्यम से संचार करने वाले Upstash Redis को सेशन कैश लेयर के रूप में रखकर इस समस्या को हल किया जा सकता है।
`
[User Request]
│
▼
┌──────────────┐ < 50ms (HTTP REST) ┌────────────────────────┐
│ Vercel Eve │ ────────────────────────> │ Upstash Redis │
│ Agent │ <──────────────────────── │ (Session State Storage)│
└──────────────┘ Session Context Restored└────────────────────────┘
│
│ Compress History (Sliding Window + Summary)
▼
┌──────────────┐
│ LLM Provider │
└──────────────┘
`
सेशन डेटा REST API के माध्यम से 50ms के भीतर प्राप्त कर लिया जाता है। डायरेक्ट RDB लुकअप को कैश से बदलकर Read Capacity खपत को काफी कम किया जा सकता है।
| मूल्यांकन आइटम | पारंपरिक RDB (PostgreSQL) | DynamoDB (On-Demand) | Upstash Redis (HTTP REST) |
|---|---|---|---|
| कनेक्शन विधि | TCP Socket | AWS SDK | HTTP/REST API |
| औसत रीड लेटेंसी | 50ms - 200ms | 10ms - 20ms | 1ms - 5ms (Edge < 50ms) |
| सर्वरलेस उपयुक्तता | कम (Connection Exhaustion) | मध्यम (कनेक्शन देरी मौजूद) | बहुत उच्च (Scale-to-Zero सपोर्ट) |
| लागत संरचना | प्रोविजनिंग इंस्टेंस प्रति घंटा बिलिंग | RCU/WCU अनुरोध इकाई बिलिंग | Command अनुरोध इकाई ($0.20/100k) |
| मुख्य उपयोग उद्देश्य | ACID ट्रांजेक्शन, मूल संग्रहण | स्थायी डेटा संग्रहण और खोज | सेशन कैशिंग, Rate Limit, एजेंट मेमोरी |
सेशन स्टोरेज और रीस्टोर कोड को सरल रखा गया है।
`typescript
import { Redis } from "@upstash/redis";
const redis = Redis.fromEnv();
interface AgentSessionContext {
userId: string;
currentStep: string;
intermediateThoughts: Record<string, unknown>[];
lastActiveTimestamp: number;
}
export async function restoreSessionContext(sessionId: string): Promise<AgentSessionContext | null> {
const cacheKey = session:context:${sessionId};
const cachedContext = await redis.get(cacheKey);
return cachedContext ?? null;
}
export async function saveSessionContext(
sessionId: string,
context: AgentSessionContext,
ttlSeconds: number = 3600
): Promise {
const cacheKey = session:context:${sessionId};
await redis.set(cacheKey, JSON.stringify(context), { ex: ttlSeconds });
}
`
जैसे-जैसे बातचीत लंबी होती जाती है, टोकन की लागत बढ़ती जाती है। केवल हाल के 6 टर्न को मूल रूप में रखा जाता है, और पिछली बातचीत को एक हल्के मॉडल के साथ सारांशित करके प्रॉम्प्ट के शीर्ष पर रखा जाता है।
`typescript
import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";
interface Message {
role: "user" | "assistant" | "system";
content: string;
}
export async function compressConversationHistory(
messages: Message[],
recentWindowSize: number = 6
): Promise<Message[]> {
if (messages.length <= recentWindowSize) return messages;
const systemMessage = messages.find((m) => m.role === "system");
const nonSystemMessages = messages.filter((m) => m.role !== "system");
const olderMessages = nonSystemMessages.slice(0, nonSystemMessages.length - recentWindowSize);
const recentMessages = nonSystemMessages.slice(nonSystemMessages.length - recentWindowSize);
const summaryResponse = await generateText({
model: openai("gpt-4o-mini"),
prompt: 다음 대화의 핵심 사실과 결정 사항만 200자 이내로 요약하세요:\n\n${JSON.stringify(olderMessages)},
});
const compressedHistory: Message[] = [];
if (systemMessage) compressedHistory.push(systemMessage);
compressedHistory.push({
role: "system",
content: [이전 대화 요약]: ${summaryResponse.text},
});
compressedHistory.push(...recentMessages);
return compressedHistory;
}
`
बाहरी टूल्स को कॉल करते समय 429 (Rate Limit) या 5xx एरर आने पर संपूर्ण एजेंट इंफरेंस टूट जाता है। Full Jitter के साथ एक्सपोनेंशियल बैकऑफ और सर्किट ब्रेकर स्थापित किया जाना चाहिए।
एक्सपोनेंशियल बैकऑफ फॉर्मूला प्रतीक्षा समय को सीधे अनुपात में बढ़ाने के बजाय रैंडम नंबर मिलाकर अड़चनों से बचाता है।
`typescript
export interface RetryConfig {
maxRetries: number;
baseDelayMs: number;
maxDelayMs: number;
}
export async function executeWithExponentialBackoff(
fn: () => Promise,
config: RetryConfig = { maxRetries: 3, baseDelayMs: 200, maxDelayMs: 8000 }
): Promise {
let attempt = 0;
while (true) {
try {
return await fn();
} catch (error: any) {
attempt++;
const statusCode = error?.status || error?.response?.status;
const isUnretryable = statusCode && statusCode >= 400 && statusCode < 500 && statusCode !== 429;
if (attempt > config.maxRetries || isUnretryable) throw error;
const calculatedDelay = Math.min(
config.maxDelayMs,
config.baseDelayMs * Math.pow(2, attempt)
);
const jitteredDelay = calculatedDelay * (0.5 + Math.random());
await new Promise((resolve) => setTimeout(resolve, jitteredDelay));
}
}
}
`
यदि विफलता लंबी होती है, तो सर्किट ब्रेकर तुरंत अनुरोधों को ब्लॉक (Fail-Fast) कर देता है और Fallback लॉजिक लागू करता है।
| बाहरी API प्रतिक्रिया स्थिति | सर्किट ब्रेकर स्थिति | कार्य तंत्र | एजेंट प्रोसेसिंग परिणाम |
|---|---|---|---|
| HTTP 200 OK | Closed | सामान्य पास और सफलता काउंटर वृद्धि | एजेंट को बाहरी डेटा सफलतापूर्वक आपूर्ति |
| HTTP 429 / 503 | Closed $ | ||
| ightarrow$ Open | एक्सपोनेंशियल बैकऑफ निष्पादन के बाद विफलता दर थ्रेशोल्ड प्राप्त होने पर Open | पुनः प्रयास के बाद सर्किट खोलना | |
| Circuit OPEN स्थिति | Open | बाहरी API नेटवर्क अनुरोध अवरुद्ध (Fail-Fast) | वैकल्पिक Tool का उपयोग या Fallback संदेश आउटपुट |
| Cooldown समाप्ति के बाद | Half-Open | सिंगल Probing अनुरोध द्वारा बाहरी सेवा रिकवरी की पुष्टि | सफलता पर सर्किट सामान्यीकरण, विफलता पर सर्किट पुनः अवरुद्ध |
`typescript
export class CircuitBreaker {
private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
private failureCount = 0;
private lastStateChange = Date.now();
constructor(
private failureThreshold: number = 5,
private cooldownPeriodMs: number = 30000
) {}
async execute(requestFn: () => Promise, fallbackFn: () => Promise): Promise {
const now = Date.now();
if (this.state === 'OPEN') {
if (now - this.lastStateChange > this.cooldownPeriodMs) {
this.state = 'HALF_OPEN';
this.lastStateChange = now;
} else {
return await fallbackFn();
}
}
try {
const result = await requestFn();
if (this.state === 'HALF_OPEN') {
this.state = 'CLOSED';
this.failureCount = 0;
this.lastStateChange = now;
}
return result;
} catch (error) {
this.failureCount++;
if (this.failureCount >= this.failureThreshold || this.state === 'HALF_OPEN') {
this.state = 'OPEN';
this.lastStateChange = now;
}
return await fallbackFn();
}
}
}
`
सर्वरलेस फ़ंक्शन निष्पादन समय सीमाओं के साथ आते हैं। भुगतान या DB विलोपन स्वीकृति की प्रतीक्षा में अनुरोध को खुला रखने से टाइमआउट त्रुटियाँ होंगी।
`
[Agent Action] ──> Eve Tool (needsApproval: true)
│
▼
[Checkpoint Saved & Instance Terminated]
│
├─> Slack Notification (Interactive Card)
│
[Human Approve] ───────>│ (Webhook POST Callback)
│
▼
[Resume Agent & Proceed Transaction]
`
Eve टूल्स को needsApproval: true दें, निष्पादन रोकें और केवल चेकपॉइंट छोड़ें।
`typescript
import { defineTool } from "@vercel/eve";
import { z } from "zod";
export const deleteDatabaseTool = defineTool({
name: "delete_database", description: "특정 테넌트의 영구 데이터베이스 레코드를 삭제합니다.",
needsApproval: true,
input: z.object({
tenantId: z.string(),
reason: z.string(),
}),
execute: async ({ tenantId }) => {
return await db.tenant.delete({ where: { id: tenantId } });
},
});
`
मानवीय स्वीकृति एक वेबहुक कॉलबैक के माध्यम से प्राप्त की जाती है ताकि प्रक्रिया फिर से शुरू हो सके।
`typescript
import { createWebhook } from "@vercel/workflows";
export async function handleApprovalWorkflow(event: { approvalId: string; payload: any }) {
const webhook = createWebhook();
await sendSlackApprovalCard({
approvalId: event.approvalId,
callbackUrl: webhook.url,
payload: event.payload,
});
try {
const { approved, userReason } = await webhook.timeout("12h");
if (!approved) {
await rollbackPreviousSteps(event.payload);
return { status: "REJECTED", reason: userReason };
}
return await proceedAction(event.payload);
} catch (error) {
await rollbackPreviousSteps(event.payload);
return { status: "TIMEOUT_CANCELLED" };
}
}
`
प्रॉम्प्ट संशोधन के बाद होने वाले मतिभ्रम (Hallucination) को मैनुअल परीक्षण द्वारा पकड़ना कठिन है। पाइपलाइन को इस तरह से डिज़ाइन किया गया है कि केवल DeepEval मेट्रिक्स को पास करने पर ही PR को मर्ज किया जा सके।
| मूल्यांकन मेट्रिक | स्वीकार्य थ्रेशोल्ड | मूल्यांकन मानदंड |
|---|---|---|
| Faithfulness | प्रदान किए गए Context के मुकाबले तथ्य विकृति की उपस्थिति/अनुपस्थिति | |
| Answer Relevancy | उपयोगकर्ता प्रश्न उद्देश्य के साथ संगति | |
| Hallucination Rate | टेस्ट सेट में मतिभ्रम घटना अनुपात | |
| Tool Calling Accuracy | सही OpenAPI स्पेक टूल चयन और प्रकार अनुपालन दर |
GitHub Actions में Pytest चलाएं और थ्रेशोल्ड से कम होने पर बिल्ड को ब्लॉक करें।
`yaml
name: Eve Agent Prompt Evaluation Pipeline
on:
pull_request:
branches: [ main ]
jobs:
evaluate-agent:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.11'
- name: Install Evaluation Dependencies
run: |
pip install deepeval pytest
- name: Run DeepEval Regression Suite
env:
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
run: |
pytest test_agent_evals.py --deepeval-metric-threshold=0.85
`
डेप्लॉयमेंट के समय, Edge Config और मिडिलवेयर को लिंक करके नए प्रॉम्प्ट को पहले केवल 10% ट्रैफिक पर लागू किया जाता है।
`typescript
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { get } from '@vercel/edge-config';
export async function middleware(req: NextRequest) {
const res = NextResponse.next();
let variant = req.cookies.get('agent_canary_variant')?.value;
if (!variant) {
const canaryRate = (await get('canary_traffic_rate')) || 0.10;
variant = Math.random() < canaryRate ? 'canary' : 'control';
res.cookies.set('agent_canary_variant', variant, { path: '/', httpOnly: true });
}
res.headers.set('x-agent-prompt-version', variant === 'canary' ? 'v2-canary' : 'v1-stable');
return res;
}
export const config = {
matcher: '/api/agent/:path*',
};
`