Cloudflare Agents: סוכני AI עם מצב קבוע על האדג' בלי כאבי ראש של מסדי נתונים

נקודה מרכזית

הריפו Cloudflare Agents הוא SDK בסרברלס שנותן לסוכני ה-AI שלנו זיכרון קבוע ומצב על האדג' באמצעות טכנולוגיית Durable Objects של Cloudflare. פותח על ידי Cloudflare, הוא מבטל את בעיית ה'שכחה' שפוקדת סוכני AI מסורתיים בסרברלס על ידי התייחסות לכל סוכן כשחקן ייחודי עם האחסון שלו, מה שמאפשר למיליוני סוכנים לשמור על מצב עצמאי, להירדם כדי לחסוך בעלויות, ולהתעורר מיד לפי דרישה.

מה זה Cloudflare Agents?

הריפו Cloudflare Agents הוא SDK חזק לבניית סוכני AI עם מצב קבוע על רשת האדג' של Cloudflare. הפרויקט cloudflare/agents פותר את הבעיה של ניהול מצב בסביבות serverless שכולנו מתמודדים איתה כשאנחנו בונים סוכני AI שצריכים לזכור הקשר על פני אינטראקציות מרובות.

פונקציות serverless מסורתיות הן חסרות מצב על ידי תכנון - הן מריצות, מחזירות תוצאה, ושוכחות הכל. זה עובד מצוין ל-APIs פשוטים אבל הופך לסיוט כשאנחנו בונים סוכני AI שצריכים לשמור היסטוריית שיחות, העדפות משתמשים, או התקדמות במשימות רב-שלביות. הסוכנים שלנו בעצם מקבלים אמנזיה אחרי כל בקשה.

הבעיה שכולנו מכירים

כולנו נתקלנו בקיר הזה: הסוכנים שלנו עושים סקייל מעולה על פלטפורמות serverless, אבל הם לא יכולים לזכור שום דבר בין בקשות. כל פעם שמשתמש שולח הודעה, הסוכן מתחיל מאפס, מה שמכריח אותנו להעביר היסטוריות שיחה שלמות בכל בקשה או להקים חנויות מצב חיצוניות מסובכות.

מסתבר שהפתרונות הטיפוסיים שאנחנו פונים אליהם - Redis, DynamoDB, או מסדי נתונים חיצוניים אחרים - עובדים, אבל הם מוסיפים עיכוב, מציגים אתגרי סינכרון, ויוצרים עוד שירות שאנחנו צריכים לנהל, לעקוב אחריו ולשלם עבורו. אנחנו בסופו של דבר עם פונקציית serverless שלא באמת serverless יותר כי היא תלויה במסד נתונים עם מצב שרץ איפשהו אחר.

גרוע מכך, הסקייל הופך למסובך. האם אנחנו מחלקים מצב לפי משתמש? לפי סשן? איך אנחנו מטפלים בבקשות מקבילות לאותו סוכן? איך אנחנו נמנעים מעונשים של cold start תוך שמירה על עלויות סבירות?

איך Cloudflare Agents עובד

הריפו Cloudflare Agents לוקח גישה שונה בתכלית על ידי העברת ניהול המצב לאדג' באמצעות Durable Objects. תחשבו על זה כמו לתת לכל סוכן AI שרת ייעודי זעיר משלו שרץ רק כשצריך וזוכר הכל בין בקשות.

הנה הקסם הטכני: Durable Objects הם פרימיטיב של Cloudflare שמבטיח שקיים מופע יחיד של אובייקט JavaScript בצורה גלובלית. כשאנחנו יוצרים סוכן, הוא מקבל Durable Object משלו עם אחסון קבוע. האובייקט הזה יכול להירדם - מה שנקרא hibernation - כלומר הוא לא צורך משאבי חישוב בכלל - אבל שומר על המצב שלו. כשבקשה מגיעה דרך WebSocket או RPC - מה שנקרא Remote Procedure Call, כלומר הפרונט-אנד שלנו יכול לקרוא למתודות בצד השרת כאילו הן פונקציות מקומיות - האובייקט מתעורר מיד עם כל ההקשר.

ה-SDK מתייחס לסוכנים כקלאסים. אנחנו מרחיבים את הקלאס הבסיסי Agent, מסמנים מתודות עם @callable() כדי לחשוף אותן דרך RPC, וניגשים ל-this.state למידע קבוע ששורד על פני הרצות. בפרונט-אנד, הוק ריאקט כמו useAgent() מתחבר למופע סוכן ספציפי, ושינויי מצב מסתנכרנים אוטומטית בזמן אמת.

התחלה מהירה

ככה אנחנו מתחילים עם Cloudflare Agents:

# התקנת ה-SDK
npm install @cloudflare/agents

# הגדרת קלאס סוכן
import { Agent, callable } from '@cloudflare/agents';

export class CounterAgent extends Agent {
  @callable()
  async increment() {
    this.state.count = (this.state.count || 0) + 1;
    return this.state.count;
  }
  
  @callable()
  async getCount() {
    return this.state.count || 0;
  }
}

דוגמה אמיתית

נגיד שאנחנו רוצים לבנות סוכן AI שיחתי שזוכר היסטוריית צ'אט בלי להעביר אותה בכל בקשה:

import { Agent, callable } from '@cloudflare/agents';

export class ChatAgent extends Agent {
  // אתחול עם היסטוריית שיחה ריקה
  async init() {
    if (!this.state.messages) {
      this.state.messages = [];
    }
  }
  
  @callable()
  async sendMessage(userMessage: string) {
    // הוספת הודעת משתמש להיסטוריה הקבועה
    this.state.messages.push({
      role: 'user',
      content: userMessage,
      timestamp: Date.now()
    });
    
    // קריאה ל-LLM עם כל הקשר השיחה
    const response = await this.callLLM(this.state.messages);
    
    // שמירת תגובת הסוכן
    this.state.messages.push({
      role: 'assistant',
      content: response,
      timestamp: Date.now()
    });
    
    return response;
  }
  
  @callable()
  async getHistory() {
    return this.state.messages;
  }
  
  @callable()
  async clearHistory() {
    this.state.messages = [];
  }
}

בפרונט-אנד ריאקט, אנחנו מתחברים לסוכן הזה:

import { useAgent } from '@cloudflare/agents-react';

function ChatInterface({ userId }) {
  // התחברות למופע ChatAgent הספציפי של המשתמש
  const agent = useAgent(ChatAgent, userId);
  const [input, setInput] = useState('');
  
  const handleSend = async () => {
    // זה קורא למתודה בצד השרת ישירות
    const response = await agent.sendMessage(input);
    setInput('');
    // עדכוני מצב מסתנכרנים אוטומטית ל-UI
  };
  
  return (
    
      {agent.state.messages?.map((msg, i) => (
        {msg.role}: {msg.content}
      ))}
       setInput(e.target.value)} />
      Send
    
  );
}

פיצ'רים מרכזיים

• Hibernation אוטומטית - הסוכנים שלנו נרדמים כשהם לא עושים כלום, ולא צורכים משאבי חישוב. תחשבו על זה כמו להעביר את הלפטופ שלכם למצב שינה - התעוררות מיידית, בלי זמן אתחול, אבל אין ניקוז סוללה בזמן השינה. זה אומר שאנחנו יכולים להחזיק מיליוני מופעי סוכנים בלי שהעלויות יתפוצצו.
• תמיכה ב-WebSocket - תקשורת דו-כיווניית בזמן אמת בין הקליינט לסוכן. בניגוד לדפוסי request-response מסורתיים, סוכנים יכולים לדחוף עדכונים לקליינטים מיד, מושלם לסטרימינג של תגובות AI או עריכה שיתופית.
• RPC עם @callable() - אנחנו מסמנים מתודות בצד השרת וקוראים להן מהפרונט-אנד כאילו הן מקומיות. בלי הגדרת endpoints ידנית, בלי כאבי ראש של סריאליזציה. זה כמו שיש לנו את הבאק-אנד בקוד הפרונט-אנד שלנו.
• Model Context Protocol (MCP) - דרך סטנדרטית לחבר סוכנים לכלים ומקורות נתונים. MCP - מה שנקרא פרוטוקול שמגדיר איך מודלי AI ניגשים להקשר חיצוני כמו מסדי נתונים, APIs, או מערכות קבצים. זה מאפשר לסוכנים שלנו לעבוד עם כל כלי תואם MCP בלי קוד אינטגרציה מותאם אישית.
• Workflows עמידים - משימות רב-שלביות ששורדות כשלים והפעלות מחדש. הקטע המדליק הוא שאנחנו יכולים ליישם דפוסים של 'human-in-the-loop' שבהם סוכן עוצר ביצוע, מחכה לאישור או קלט מהמשתמש, ואז ממשיך בדיוק מאיפה שעצר ימים אחר כך.
• Edge SQL - הרצת שאילתות SQLite ישירות בתוך ה-Durable Object לפעולות מורכבות של נתונים. זה פסיכי - אנחנו מקבלים מסד נתונים רלציוני מלא לכל מופע סוכן, בלי הגדרת מסד נתונים חיצוני.

מתי להשתמש ב-Cloudflare Agents לעומת אלטרנטיבות

אם אנחנו כבר על Cloudflare Workers וצריכים סוכנים עם מצב, זה ברור. האינטגרציה חלקה, ואנחנו נמנעים מהמורכבות של חנויות מצב חיצוניות. זה חזק במיוחד ליוזקייסים כמו בוטים של תמיכת לקוחות (זוכרים שיחה על פני ימים), כלים שיתופיים (מספר משתמשים מתקשרים עם אותו סוכן), או workflows ארוכים (סוכן מתאם משימות רב-יומיות).

לצוותים על AWS Lambda או Google Cloud Functions, אלטרנטיבות כמו LangGraph עם Supabase או Temporal.io workflows מספקות ניהול מצב דומה אבל דורשות יותר הקמת תשתית. LangGraph נותן לנו תזמור סוכנים מבוסס גרף עם checkpointing ל-Postgres או Redis. Temporal מצטיין ב-workflows עמידים עם ערבויות חזקות אבל מוסיף מורכבות תפעולית.

אם אנחנו בונים על ענני אחרים, Modal או Fly.io עם SQLite מציעים פרימיטיבים של חישוב עם מצב דומים ל-Durable Objects. Modal נותן לנו volumes קבועים לכל מופע פונקציה. Fly.io מאפשר לנו להריץ תהליכים ארוכי-חיים עם אחסון קבוע מחובר.

הטרייד-אוף הוא vendor lock-in. הקוד של Cloudflare Agents לא יעבור בקלות לפלטפורמות אחרות. אבל אם אנחנו מחויבים לרשת האדג' של Cloudflare, הטרייד-אוף הזה אולי שווה את זה בשביל הפשטות וחיסכון העלויות.

בעיניי - האם אשתמש בזה?

לעניות דעתי, זה הפתרון הכי נקי למצב serverless עבור סוכני AI שראיתי. מודל ה-hibernation הוא מבריק - אנחנו מקבלים את היתרונות של סקייל ועלות של serverless עם מצביות של שרתים מסורתיים. אין יותר תשלום על חיבורי Redis סרק או ניהול connection pools של מסד נתונים.

לכל פרויקט סוכנים מבוסס Cloudflare, הייתי פונה לזה מיד. חוויית המפתח פנטסטית - דפוס ה-RPC מרגיש כמו קסם, וסינכרון מצב אוטומטי מסיר קטגוריות שלמות של באגים. יוזקייסים שבהם זה מבריק: אפליקציות צ'אט רב-סשן, עוזרי AI שלומדים העדפות משתמש לאורך זמן, או סוכנים שיתופיים שבהם מספר משתמשים מתקשרים עם אותו ישות בעלת מצב.

המגבלות הן אמיתיות בכל זאת. אנחנו נעולים לאקוסיסטם של Cloudflare. אם אנחנו צריכים לעבור ל-AWS או Azure מאוחר יותר, אנחנו משכתבים. למודל Durable Objects יש גם מוזרויות - יש עקומת למידה סביב איך לחשוב על שחקנים של מופע יחיד לעומת שירותים מאוזני-עומס מסורתיים.

שורה תחתונה: לפרויקטים חדשים על Cloudflare, זה מסיר שכבה שלמה של מורכבות. לפרויקטים קיימים, תעריכו אם מאמץ המיגרציה מצדיק את הפישוט התפעולי. בדקו את הריפו: cloudflare/agents

שאלות נפוצות

מה זה Cloudflare Agents?

הריפו Cloudflare Agents הוא SDK בסרברלס שמאפשר סוכני AI קבועים ועם מצב על רשת האדג' של Cloudflare באמצעות טכנולוגיית Durable Objects.

מי יצר את Cloudflare Agents?

הריפו Cloudflare Agents נוצר על ידי Cloudflare כחלק מהפלטפורמת מפתחים שלהם לבניית אפליקציות AI על האדג'.

מתי כדאי להשתמש ב-Cloudflare Agents?

כדאי להשתמש ב-Cloudflare Agents כשבונים אפליקציות AI שצריכות מצב קבוע על פני בקשות בלי מסדי נתונים חיצוניים, במיוחד לצ'אט בזמן אמת, כלים שיתופיים, או workflows ארוכים.

מה האלטרנטיבות ל-Cloudflare Agents?

אלטרנטיבות כוללות LangGraph עם Supabase לתזמור סוכנים מבוסס גרף, Temporal.io ל-workflows עמידים, Modal ל-serverless עם מצב על ענני אחרים, או גישות מסורתיות עם Redis/DynamoDB לניהול מצב.

מה המגבלות של Cloudflare Agents?

המגבלה העיקרית היא vendor lock-in לפלטפורמה של Cloudflare - הקוד לא יעבור בקלות ל-AWS, Azure, או Google Cloud. יש גם עקומת למידה סביב המודל של שחקן-מופע-יחיד של Durable Objects.