Workers AI ו-RAG — inference ב-Edge, ו-chatbot חינמי על המסמכים שלך

ניצור תיקייה חדשה, נאתחל אותה כפרויקט Node.js ונתקין את Hono ואת כלי הפיתוח הנדרשים ל-Cloudflare Workers:

mkdir my-edge-rag && cd my-edge-rag
npm init -y
npm install hono
npm install --save-dev typescript @cloudflare/workers-types wrangler

הפלט הצפוי: הורדה והתקנה של החבילות בתיקיית node_modules ויצירת קובץ package.json תקין.

ניצור בסיס נתונים D1 עבור המטא-דאטה והטקסטים המקוריים, ולאחר מכן ניצור אינדקס וקטורי ב-Vectorize עם 384 ממדים (התואם למודל Embeddings החינמי של Cloudflare):

npx wrangler d1 create rag_db

הפלט יציג את ה-ID הייחודי של מסד הנתונים שנוצר. כעת ניצור את האינדקס הווקטורי:

npx wrangler vectorize create rag_index --dimensions=384 --metric=cosine

הפלט הצפוי: הודעת אישור על יצירת האינדקס rag_index בהצלחה בטכנולוגיית Cosine Similarity.

צרו קובץ בשם tsconfig.json בתיקיית השורש והעתיקו אליו את ההגדרות הבאות:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "lib": ["ES2022"],
    "strict": true,
    "skipLibCheck": true,
    "types": ["@cloudflare/workers-types"]
  }
}

כעת צרו קובץ בשם wrangler.toml בשורש הפרויקט והחליפו את ה-database_id בערך שקיבלתם בשלב 2:

name = "my-edge-rag"
main = "src/index.ts


מתחיל5 דקותחינםsetup
הגישה המנוהלת: AI Search (RAG-as-a-service)
עד היום, בניית מערכת RAG (אחזור מידע מועשר על ידי יצירה — Retrieval-Augmented Generation) דרשה מכם להקים "צינור מידע" (Data Pipeline) מורכב ומלכלך. הייתם צריכים לקחת את קבצי המקור שלכם (כמו קבצי PDF, מסמכי Word או דפי אינטרנט), לבצע תהליך של "צ'אנקינג" (Chunking — פירוק הטקסט למקטעים קטנים בעלי משמעות), לשלוח כל מקטע למודל ייעודי כדי להפיק ממנו "אמבדינג" (Embedding — ייצוג מתמטי של הטקסט כוקטור), ולשמור את הכל במסד נתונים וקטורי דוגמת Vectorize. כשמשתמש שאל שאלה, הייתם צריכים להפוך גם אותה לוקטור, לבצע חיפוש דמיון מתמטי בקצה (Edge), לשלוף את המקטעים הרלוונטיים ביותר, ורק אז להזין אותם כקשר (Context) למודל השפה (LLM) כדי שיפיק תשובה מבוססת עובדות. עבור "Vibe Coders" שרוצים להתמקד בבניית חוויית המשתמש והלוגיקה העסקית, מדובר בהרבה עבודה שחורה ותחזוקה מיותרת.

בדיוק בגלל זה השיקה Cloudflare את שירות AI Search. מדובר בפתרון RAG מנוהל מקצה לקצה (RAG-as-a-service), שמבטל לחלוטין את הצורך בניהול מסדי נתונים וקטוריים, בחירת מודלי אמבדינג או כתיבת אלגוריתמים לפירוק טקסט. אתם פשוט מצביעים על כתובת אתר (URL) שברצונכם לסרוק או מעלים קבצים ישירות אל המערכת, וקלאודפליי מטפלת בכל השאר: מהסריקה, דרך הפירוק והקידוד הוקטורי, ועד למתן ממשק שאילתות פשוט בשפה חופשית שמחזיר מיד את התשובה המדויקת או את קטעי המקור הרלוונטיים ביותר.

איך זה עובד מתחת למכסה המנוע?
כאשר אתם מקימים מופע (Instance) של AI Search, המערכת מייצרת עבורכם תשתית אחזור מנוהלת ומבודדת. בניגוד לעבודה ידנית שבה אתם מוגבלים על ידי מימדי הוקטורים של מודל ספציפי (למשל, 384 מימדים במודל bge-small-en-v1.5 הפופולרי או 768 מימדים במודל הגדול יותר), AI Search מנהל את סכמת האינדקס בצורה דינמית ואוטומטית. הדבר מאפשר לכם להוסיף גם שדות מטא-דאטה (Metadata) מותאמים אישית (עד 5 שדות בגרסה החינמית) כדי לסנן ולמיין את תוצאות החיפוש בצורה מתוחכמת.

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


  

    

      
משאב / מגבלה
      
במסלול החינמי (Workers Free)
      
במסלול בתשלום (Workers Paid - החל מ-5$/חודש)
    
  
  

    

      
שאילתות חיפוש
      
20,000 שאילתות בחודש (ללא עלות)
      
ללא הגבלה (תמחור לפי שימוש בפועל)
    
    

      
כמות קבצים למופע
      
עד 100,000 קבצים מאונדקסים
      
עד 1,000,000 קבצים למופע
    
    

      
סריקת אתרים יומית (Crawl)
      
עד 500 עמודים ביום
      
נפח סריקה מורחב משמעותית
    
    

      
מספר מופעים לחשבון
      
עד 100 מופעים נפרדים
      
עד 5,000 מופעים
    
  


הקאץ' שאתם חייבים להכיר: עיכוב האינדוקס
למרות הפשטות והעוצמה של AI Search, ישנה מגבלה טכנית אחת מהותית שאתם חייבים לקחת בחשבון לפני שאתם מתחילים לתכנן את הארכיטקטורה של האפליקציה שלכם: מנגנון הסריקה והאינדוקס מבוסס ה-Crawl אינו מתרחש בזמן אמת. כאשר אתם מנחים את המערכת לסרוק כתובת אתר מסוימת, המידע מעובד ונכנס לאינדקס החיפוש בעיכוב של כ-24 שעות (עמודים שנסרקו היום יופיעו בתוצאות השאילתות רק מחר). 
המשמעות היא שאם אתם בונים אפליקציה שמסתמכת על מידע דינמי שמשתנה כל כמה דקות (כמו צ'אטבוט המגיב לעדכוני חדשות חמים, פוסטים מפורומים בזמן אמת או מלאי מוצרים שמשתנה ללא הרף), AI Search במתכונת הסריקה האוטומטית שלו לא יתאים למשימה, ותצטרכו לחזור לפתרון המסורתי של כתיבת קוד עצמאי מול Vectorize. עם זאת, עבור מסמכים סטטיים, מדריכי עזרה, קובצי PDF קבועים, נהלי חברה, או ספריות קוד ותיעוד טכני — מדובר בקיצור הדרך האולטימטיבי שיחסוך לכם שבועות של פיתוח ובאגים.



  אינדוקס קובץ וביצוע שאילתה מיידית ב-AI Search 8 דקות
  
על מנת לעקוף את עיכוב ה-24 שעות של סורק האתרים האוטומטי ולראות תוצאות מיידיות, אנחנו נשתמש בממשק שורת הפקודה (Wrangler CLI) כדי ליצור מופע חיפוש חדש, להעלות אליו קובץ טקסט מקומי המכיל מידע ספציפי, ולתשאל אותו מיד בשפה חופשית.
  
  

    

      פתח את הטרמינל והתחבר לחשבון ה-Cloudflare שלך באמצעות פקודת ההתחברות הרשמית:
      
npx wrangler login
      הפלט הצפוי: דפדפן ייפתח ויבקש ממך לאשר את הגישה לחשבון. לאחר האישור, תראה הודעת הצלחה בטרמינל: Successfully logged in!.
    
    

      צור מופע חדש של AI Search בשם my-knowledge-base:
      
npx wrangler ai-search create my-knowledge-base
      הפלט הצפוי: אישור בטרמינל שהמופע נוצר בהצלחה עם מזהה ייחודי (ID).
    
    

      צור קובץ טקסט פשוט בשם company_policy.txt במחשב שלך, המכיל את המידע הבא (ניתן להשתמש בפקודה הבאה ליצירה מהירה):
      
echo "The office kitchen is stocked with fresh fruit every Tuesday. The annual team retreat for 2026 is scheduled for October 12th in Tokyo." > company_policy.txt
    
    

      העלה את הקובץ שיצרת ישירות לתוך מופע ה-AI Search שלך כדי לאנדקס אותו מיידית:
      
npx wrangler ai-search upload my-knowledge-base --file company_policy.txt
      הפלט הצפוי: File company_policy.txt uploaded and indexed successfully.
    
    

      כעת, בצע שאילתה בשפה חופשית כדי לבדוק שהמידע נשלף בהצלחה בזמן אמת:
      
npx wrangler ai-search query my-knowledge-base "When and where is the team retreat?"
      הפלט הצפוי: המערכת תחזיר קטע טקסט ממוקד מתוך הקובץ שהעלית, המציין שהריטריט השנתי יתקיים ב-12 באוקטובר בטוקיו, יחד עם ציון מקור המידע (Score ו-File Path).
    
  
  
  
פלט נראה לעין שתסיים איתו: בטרמינל שלך יוצג אובייקט JSON או פלט מובנה המכיל את התשובה המדויקת שנשלפה מתוך הקובץ שהעלית, בתוספת רמת הדיוק (Confidence Score) של השליפה, מבלי שכתבת שורת קוד אחת של אמבדינג או ניהול וקטורים.
  
  



בינוני5 דקותחינםanalysis
השוואה קרה: Vectorize DIY מול AI Search Managed
כשאתם בונים מערכת RAG (או בשמה המלא: Retrieval-Augmented Generation — אחזור מידע מועשר בג'נרטיבי) בקצה הרשת (Edge — שרתי קצה המבוזרים גלובלית בקרבת המשתמש), המטרה שלכם היא להביא את התשובות המדויקות ביותר במינימום זמן ובמינימום עלות. פלטפורמת Cloudflare מאפשרת לנו לבצע אינפרנס (Inference — הרצת המודל בפועל כדי לקבל תשובה) ישירות על מעבדי ה-GPU שלה הפזורים במאות ערים בעולם, ללא צורך בניהול שרתים או קונטיינרים מסורבלים. אולם, האתגר הארכיטקטוני המרכזי שעימו תתמודדו אינו המודל עצמו, אלא האופן שבו אתם מאחסנים, מנהלים ומחפשים את פיסות המידע הרלוונטיות שלכם.

כאן אנו נדרשים לבצע בחירה טכנולוגית מכרעת בין שתי גישות מנוגדות: בנייה עצמית (DIY) מבוססת Vectorize (מסד הנתונים הוקטורי המנוהל של Cloudflare) בשילוב עם D1 (מסד הנתונים ה-SQL-י מבוסס SQLite), לבין שימוש במוצר המנוהל לחלוטין AI Search (שירות RAG-as-a-Service שהושק באפריל 2026). הבחירה הזו תשפיע באופן ישיר על מורכבות הקוד שלכם, על היכולת לעדכן נתונים בזמן אמת, ועל המקום שבו תפגשו את תקרת החינמיות של הפלטפורמה.

ארכיטקטורת DIY: השילוב של Vectorize, D1 ו-Workers AI
בגישת ה-DIY (עשה זאת בעצמך), אתם שולטים בכל רכיב בצינור המידע שלכם. התהליך מתחיל בחלוקת הטקסט לפסקאות קטנות (Chunking), מעבר שלהן דרך מודל Embeddings (ייצוגים מתמטיים של טקסט המאפשרים חיפוש לפי דמיון סמנטי) כגון @cf/baai/bge-small-en-v1.5, שמירת הוקטורים בתוך Vectorize, ושמירת הטקסט המקורי ומזהי הייחוס שלו בתוך מסד הנתונים D1. כאשר משתמש שואל שאלה, אתם הופכים את השאלה שלו לוקטור, מבצעים חיפוש דמיון קוסינוס (Cosine Similarity) ב-Vectorize, שולפים את מזהי הטקסט התואמים מ-D1, ומזינים את הכל להקשר (Context) של ה-LLM ב-Workers AI.

היתרון הבולט בגישה זו הוא השליטה המלאה בזמן אמת. ברגע שמשתמש מעלה מסמך חדש, אתם יכולים לאנדקס אותו סינכרונית ותוך שבריר שנייה הוא יהיה זמין לשאילתות הבאות. עם זאת, שימו לב לחישוב המגבלות: ה-Free Tier של Vectorize מוגבל ל-5 מיליון ממדים מאוחסנים בחודש. אם תבחרו במודל bge-small-en-v1.5 בעל 384 ממדים, תוכלו לאחסן כ-13,000 מסמכים בחינם. אך אם תעברו למודל איכותי יותר כמו bge-large-en-v1.5 המשתמש ב-768 ממדים, קיבולת האחסון שלכם תיחתך מיידית בחצי — לכ-6,500 מסמכים בלבד.

ארכיטקטורת Managed: שירות AI Search המנוהל
מנגד, שירות ה-AI Search המנוהל פוטר אתכם לחלוטין מכתיבת הקוד שמטפל בחיתוך, המרה לוקטורים וניהול מסדי נתונים מקבילים. אתם פשוט מצביעים על מקור מידע (כמו כתובת אתר לזחילה או תיקיית קבצים ב-R2), והפלטפורמה בונה את תשתית ה-RAG עבורכם מאחורי הקלעים. במסלול החינמי של המוצר, תוכלו לבצע עד 20,000 שאילתות בחודש ולאחסן עד 100,000 קבצים לכל אינסטנס.

זה נשמע מושלם עבור "Vibe Coders" שרוצים לבנות מהר, אך יש כאן מלכוד קריטי: המערכת עובדת בצורה א-סינכרונית (Asynchronous). מנוע הזחילה (Crawler) של AI Search מעבד את המידע החדש בהשהייה מובנית. דפים שנזחלו או קבצים שהועלו היום, יופיעו באינדקס החיפוש ויעמדו לרשות המודל רק למחרת. המשמעות היא שאם האפליקציה שלכם דורשת תגובתיות מיידית לעדכוני תוכן של המשתמשים, גישה זו אינה מתאימה עבורכם.



  

    

      
תכונה
      
Vectorize + D1 (DIY)
      
AI Search (Managed)
    
  
  

    

      
מהירות עדכון (Latency)
      
זמן אמת (סינכרוני מיידי)
      
א-סינכרוני (בדרך כלל עד 24 שעות עיכוב בזחילה)
    
    

      
מורכבות קוד
      
בינונית-גבוהה (נדרש קוד אינדוקס, חיפוש ושליפה)
      
אפסית (קונפיגורציה בלבד, ללא קוד תשתיתי)
    
    

      
נפח אחסון חינמי
      
עד 5 מיליון ממדים (~13,000 מסמכים ב-384D)
      
עד 100,000 קבצים לכל אינסטנס
    
    

      
מגבלת שאילתות חינם
      
עד 30 מיליון שאילתות וקטוריות בחודש
      
עד 20,000 שאילתות בחודש
    
    

      
גמישות מטה-דאטה
      
אינסופית (שאילתות SQL מורכבות על גבי D1)
      
מוגבלת (עד 5 שדות מטה-דאטה מותאמים אישית)
    
  



  קבלת החלטה: Vectorize (DIY) לעומת AI Search (Managed)
  
שאלה 1: האם האפליקציה שלכם דורשת עדכוני נתונים בזמן אמת ושליטה מלאה במבנה הנתונים ומערכות היחסים ביניהם?
  

    
אם התשובה היא כן (למשל: המשתמש מעלה קובץ צ'אט ורוצה לשאול עליו שאלות מיד, או שאתם צריכים לסנן תוצאות לפי שאילתות SQL מורכבות של משתמשים שונים), השתמשו ב-Vectorize + D1. זה יאפשר לכם לבצע עדכונים סינכרוניים מיידיים וליהנות מגמישות פיתוח מלאה.
  
  
שאלה 2: האם מקור המידע שלכם הוא אתר אינטרנט קיים, בלוג או ספריית מסמכי עזרה סטטיים שמשתנים לעיתים רחוקות?
  

    
אם התשובה היא כן, ואתם מעוניינים באפס תחזוקת קוד ובבנייה מהירה של הצ'אטבוט מבלי לכתוב שורת קוד אחת של פרסור קבצים ואינדוקס, בחרו ב-AI Search המנוהל (תוך שמירה על מגבלת 20,000 הקריאות בחודש של המסלול החינמי).
  



  הקמת אינדקס וקטורי מקומי ב-Wrangler 5 דקות
  
כדי לחוות את קלות השימוש ב-Wrangler (כלי ה-CLI הרשמי של Cloudflare) להגדרת תשתית וקטורית, נקים כעת אינדקס פעיל שישמש אתכם בפרויקט ה-RAG העצמאי שלכם.
  
תנאים מוקדמים: ודאו שהתקנתם את NodeJS (גרסה 18 ומעלה) במחשבכם, ושיש לכם חשבון Cloudflare פעיל.
  

    
פתחו את הטרמינל (Terminal) בתיקיית פרויקט חדשה והתחברו לחשבון Cloudflare שלכם:
      
npx wrangler login
      הדפדפן ייפתח ויבקש מכם לאשר את הגישה ל-CLI. לאחר האישור, הטרמינל יציג הודעה שהתחברתם בהצלחה.
    
    
צרו אינדקס וקטורי חדש המותאם למודל ה-Embeddings הפופולרי @cf/baai/bge-small-en-v1.5 (המשתמש ב-384 ממדים ובמדד דמיון קוסינוס):
      
npx wrangler vectorize create my-vibe-index --dimensions=384 --metric=cosine
      הטרמינל יציג את פרטי האינדקס שנוצר בשרתי Cloudflare ויספק לכם את שורות הקונפיגורציה המתאימות.
    
    
צרו קובץ בשם wrangler.toml בשורש תיקיית הפרויקט שלכם, והדביקו בתוכו את הגדרת הקישור (Binding) שקיבלתם בפלט הטרמינל:
      
[[vectorize]]
binding = "VECTOR_INDEX"
index_name = "my-vibe-index"
    
  
  
פלט נראה לעין שתסיים איתו: הגדרה מושלמת של אינדקס וקטורי בענן של Cloudflare, המוכנה לשימוש מיידי בקוד ה-Worker שלכם באמצעות הקריאה ל-env.VECTOR_INDEX ללא שום הגדרת שרתים נוספת.
  



בינוני5 דקותחינםsetup
שמירה על ה-Budget: ניתוב דרך AI Gateway ו-Caching
כאשר אנו בונים מערכות RAG (כלומר Retrieval-Augmented Generation - שליפת מידע והרחבת יצירה) עבור צ'אטבוטים, האתגר הגדול ביותר העומד בפנינו הוא שמירה על מסגרת תקציב הגיונית. כל פנייה של משתמש מפעילה שרשרת פעולות יקרה: המערכת מייצרת ייצוג וקטורי (Embeddings) לשאילתה, מחפשת מסמכים רלוונטיים בתוך Vector DB (מסד נתונים וקטורי כמו Vectorize של Cloudflare), ולבסוף שולחת את כל המידע שנאסף למודל שפה גדול (LLM) כדי שינסח תשובה קוהרנטית. אם המשתמשים שלכם שואלים שאלות דומות או חוזרות (למשל, שאלות נפוצות על מסמכי החברה או תנאי שימוש), הרצת כל התהליך הזה מחדש עבור כל פנייה היא בזבוז משאבים מוחלט.

כאן נכנס לתמונה ה-AI Gateway (שער בינה מלאכותית) של Cloudflare. זהו כלי המשמש כמתווך חכם (Proxy) הממוקם בין ה-Worker שלכם לבין מודל ה-LLM (בין אם מדובר במודל פנימי של Cloudflare ובין אם בספק חיצוני כמו OpenAI). התכונה החזקה ביותר שלו היא Response Caching (שמירת תגובות במטמון מהיר בקצה הרשת). כאשר המערכת מזהה שאילתה זהה לזו שנשאלה לאחרונה, ה-AI Gateway יירט את הפנייה ויחזיר את התשובה השמורה ישירות מרשת ה-Edge (שרתי קצה המבוזרים גלובלית ב-300 ערים בעולם) של Cloudflare, מבלי לפנות כלל למודל השפה.

השימוש במטמון בקצה הרשת חוסך לכם את משאב העיכול היקר ביותר ב-Workers AI: ה-Neurons (יחידות המדידה של Cloudflare לחישובי GPU). בתוכנית החינמית אנו מקבלים מגבלה של 10,000 Neurons ליום עבור מודלים מארחים (Hosted Models). בעוד שמודלים קטנים יחסית כמו Llama 3.1 8B מאפשרים כ-300-350 קריאות ביום במסגרת הזו, שימוש במודלים גדולים יותר כמו Llama 3.3 70B יכלה את כל המכסה היומית שלכם ב-20 קריאות בלבד! מעבר לכך, מהירות התגובה (Latency) משתפרת דרמטית: במקום להמתין 1.5 עד 3 שניות לאינפרנס (Inference - תהליך הרצת המודל ויצירת התשובה), המשתמש מקבל תגובה מיידית בתוך פחות מ-20 מילי-שניות (ms) כיוון שהיא נשלפת ישירות מהמטמון הגיאוגרפי הקרוב ביותר אליו.

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


  

    

      
פרמטר השוואה
      
פנייה ישירה ל-Workers AI (ללא מטמון)
      
פנייה דרך AI Gateway (מטמון פעיל - Cache HIT)
    
  
  

    

      
צריכת משאבים (Neurons)
      
מלאה (לדוגמה: כ-400-600 Neurons לכל קריאה של 500 טוקנים)
      
0 Neurons (הקריאה לא מגיעה ל-GPU)
    
    

      
זמן תגובה ממוצע (Latency)
      
1,200ms - 3,500ms (תלוי בעומס ובגודל המודל)
      
15ms - 40ms (שליפה ישירה מזיכרון ה-Edge)
    
    

      
עלות כספית בתוכנית חינמית
      
מוגבל ל-10,000 Neurons ביום (נחסם ברגע שמגיעים לתקרה)
      
ללא הגבלת נפח קריאות לפעולות מטמון
    
    

      
שרידות תחת עומס (Rate Limits)
      
כפוף למגבלת 300 בקשות בדקה למודל
      
עוקף לחלוטין את מגבלת המודל ומשרת מיליוני בקשות בקצה
    
  



  הקמת ה-Gateway במסך הניהול 2 דקות
  
היכנסו ל-Dashboard של Cloudflare, לחצו על תפריט AI מצד שמאל, ובחרו ב-AI Gateway. לחצו על כפתור Create Gateway, העניקו לו את השם my-rag-gateway והפעילו את אפשרות ה-Caching וה-Rate Limiting בהגדרות שלו. העתיקו את כתובת ה-Universal Endpoint שקיבלתם - נשתמש בה מיד בתרגיל המעשי כדי לנתב את כל השאילתות בצורה מבוקרת.



  טעות נפוצה: חיבור AI Gateway ל-OpenAI והנחה שהאינפרנס משתמש ב-Neurons החינמיים של Cloudflare.
  
למה זה מפתה: אנחנו רוצים לבנות צ'אטבוט סופר-חכם באמצעות מודל חיצוני מוביל כמו GPT-4o, ומניחים שאם ננתב את הקריאות שלו דרך ה-AI Gateway של Cloudflare, נוכל להשתמש ב-10,000 ה-Neurons החינמיים היומיים ש-Cloudflare מציעה כדי לכסות את עלויות הריצה.
  
למה זה טעות: מודלים המונגשים דרך AI Gateway מספקים חיצוניים (מצב המכונה Proxied Models) אינם משתמשים במשאבי ה-GPU הפנימיים של Cloudflare. קריאות אלו עוקפות לחלוטין את חישוב ה-Neurons ומחויבות ישירות ובמלואן בחשבון ה-OpenAI או ה-Anthropic שלכם לפי מחירון הטוקנים הרגיל שלהם. ה-Neurons החינמיים תקפים אך ורק ל-Hosted Models (מודלים המאוחסנים ומורצים על החומרה הפיזית של Cloudflare בקצה, כגון Llama או Qwen).
  
מה לעשות במקום: הגדירו את ארכיטקטורת ה-RAG שלכם כך שתשתמש במודל פנימי וחינמי של Cloudflare כמו @cf/meta/llama-3.1-8b-instruct עבור 90% מהשאילתות הנפוצות והסינון הראשוני, תוך ניתוב דרך ה-Gateway עם מטמון אגרסיבי. שמרו את הקריאות למודלים החיצוניים היקרים רק למשימות קצה מורכבות ביותר הדורשות עיבוד לוגי יוצא דופן.



  אינטגרציה של AI Gateway להוזלת עלויות 15 דקות
  

    

      בדיקת דרישות קדם והתחברות: ודאו שמותקנת אצלכם סביבת Node.js על ידי הרצת הפקודה הבאה בטרמינל שלכם (אם אינה מותקנת, הורידו והתקינו את גרסת LTS העדכנית מאתר nodejs.org):
      
node -v
      הפלט הצפוי הוא מספר הגרסה המותקנת (למשל: v20.11.0). כעת, התחברו לחשבון ה-Cloudflare שלכם דרך ממשק ה-CLI בעזרת הרצת הפקודה הבאה ואישור הגישה בדפדפן שיפתח:
      
npx wrangler login
      הפלט הצפוי בסיום התהליך בטרמינל יהיה: Successfully logged in to Cloudflare!
    
    

      הקמת פרויקט Worker חדש: ניצור פרויקט חדש המבוסס על Hono (פריימוורק מהיר וקל משקל לעבודה עם שרתי קצה) באמצעות תפריט הפיגומים המובנה של Cloudflare:
      
npm create cloudflare@latest my-cached-chatbot -- --framework=hono
      במהלך ההתקנה, לחצו Enter כדי לאשר את כל ברירות המחדל (בחרו ב-TypeScript, ואשרו התקנת תלויות). לאחר שהתהליך מסתיים, היכנסו לתיקיית הפרויקט החדשה שנוצרה:
      
cd my-cached-chatbot
    
    

      כתיבת קוד ה-Worker המנתב קריאות דרך ה-Gateway: פתחו את הקובץ src/index.ts בעיורך המועדף עליכם, ומחקו את תוכנו. הדביקו במקומו את הקוד המלא הבא המבצע קריאת API ישירה ל-AI Gateway ומודד את זמני התגובה ואת מצב ה-Cache:
      
import { Hono } from 'hono'

const app = new Hono()

app.get('/chat', async (c) => {
  // החליפו


מתקדם5 דקותחינםproject
פרויקט מעשי: בניית AI API Facade תואם OpenAI
כשבונים יישומי בינה מלאכותית, אחד המכשולים הגדולים ביותר העומדים בפני מפתחים עצמאיים וצוותים קטנים הוא עלויות השירות והתלות ב-APIs חיצוניים מבוססי תשלום לפי שימוש (כמו OpenAI או Anthropic). רוב הכלים האיכותיים הקיימים כיום בקוד פתוח – החל משרתי ממשק משתמש כמו Open WebUI ועד לספריות פיתוח מתקדמות – נבנו ועוצבו מראש כדי לתקשר עם פרוטוקול ה-API המוכר של OpenAI. במקום לשלם על כל טוקן שיוצא מהמערכת שלכם או לשכתב את כל הקוד של אותם כלי מדף, אתם יכולים להקים "Facade" (תבנית עיצוב של שכבת תיווך) חכם ומהיר על גבי ה-Edge הגלובלי של Cloudflare. שכבה זו תאזין בנתיבים המוכרים של OpenAI, תתרגם את הבקשות בזמן אמת, ותריץ את המודלים ישירות על גבי תשתית ה-GPUs של Cloudflare בחינם לגמרי.

הקמת ה-Facade על גבי פלטפורמת Cloudflare Workers מעניקה לכם יתרון ארכיטקטוני עצום. ה-Workers מבוססים על טכנולוגיית V8 Isolates ולא על קונטיינרים כבדים, מה שמבטיח אפס זמני אתחול קרים (No cold starts) וסקלביליות מיידית לכל היקף תנועה. בנוסף, Cloudflare מעניקה במסלול החינמי שלה כ-10,000 "ניורונים" (Neurons) בכל יום עבור שירותי Workers AI. עבור מודל שפה מוביל ויעיל, כמות זו מתורגמת לכ-350 קריאות והשלמות טקסט מלאות בכל יום – נפח פעילות שמספיק לחלוטין לשלבי הפיתוח, הבדיקות וההרצה הראשונית של המוצר שלכם, מבלי להוציא שקל אחד מהכיס.

התמודדות עם מחזור חיי המודלים: GA מול Beta וסכנת ה-Deprecation
אחת הטעויות הנפוצות ביותר של מפתחים ב-Workers AI היא חוסר הבנה של סיווג המודלים ומחזור החיים שלהם. קטלוג המודלים של Cloudflare מחולק למודלים בשלב בטא (Beta) ומודלים בשלב זמינות כללית (GA - Generally Available). מודלים המסומנים כ-Beta, כמו מודלים ניסיוניים מסוימים או גרסאות קטנות ספציפיות, אינם מבטיחים יציבות לאורך זמן ועשויים להיעלם מהפלטפורמה באופן פתאומי או להשתנות ללא כל התרעה מוקדמת. לעומת זאת, מודלים המסומנים כ-GA מציעים התחייבות ליציבות ה-API ורמת ביצועים קבועה.

נושא זה מתקשר ישירות לבעיית ה-Model Deprecation (הוצאה משימוש של מודלים). Cloudflare מעדכנת את קטלוג המודלים שלה באופן תכוף כדי לפנות מקום למודלים מודרניים ויעילים יותר. מודלים שהיו פופולריים מאוד בעבר, כגון llama-3-8b-instruct, llama-3.1-70b-instruct, llama-2-7b-chat-fp16 ו-mistral-7b-instruct-v0.1, מוגדרים כעת כמודלים בתהליך הוצאה משימוש (Deprecated). אם תפתחו יישומים המסתמכים על מחרוזות שמות המודלים האלו באופן קשיח בקוד (Hardcoded), האפליקציה שלכם תישבר ותחזיר שגיאות ברגע שהמודלים יוסרו סופית מהשרתים. כדי לפתור זאת בצורה אלגנטית, שכבת ה-Facade שאתם בונים צריכה להכיל מנגנון "Model Resolver" (מפענח מודלים דינמי). המנגנון יקבל את שם המודל שהלקוח ביקש (למשל, gpt-3.5-turbo או llama-3) וימפה אותו באופן אוטומטי למודל GA עדכני ויציב השוכן בשרתי Cloudflare, כגון @cf/meta/llama-3.1-8b-instruct. גישה זו מייצרת חסינות ארכיטקטונית ומבטיחה שהשירות שלכם ימשיך לעבוד בצורה חלקה גם בעת שינויים דרסטיים בקטלוג המודלים העולמי.


בצע עכשיו: בנייה ובדיקה של ה-Facade מקומית 10 דקות
<


שגרת עבודה שבועית וחודשית לבקרת תקציב ה-AI שלכם



תדירות
פעולה




יומי
בדיקת לוגים ב-AI Gateway לוודא שאין חריגות משמעותיות בצריכת Neurons (נירונים — יחידות החישוב של Cloudflare) ושגיאות קוד 4006 (מגבלת שימוש).


שבועי
סריקת קוד ה-Workers לאיתור מודלים שעברו Deprecation (הוצאה משימוש) ומעבר למודלי GA עדכניים (כמו llama-4-scout או qwen3).


חודשי
ניקוי ואינדוקס מחדש של ה-Vector Database (מסד נתונים וקטורי) ב-Vectorize כדי למנוע חריגה ממכסת ה-Dimensions (ממדים) החינמית.






דבר אחד שכדאי לעשות עכשיו
הקימו עוד היום AI Gateway ונתבו את כל קריאות ה-Workers AI שלכם דרכו על ידי שינוי שורת ה-Config (הגדרות) שלכם. זה לוקח בדיוק 2 דקות, ומקנה לכם Caching (שמירה בזיכרון מטמון) מלא בחינם שמקצץ מיידית את צריכת ה-Neurons שלכם לאפס עבור שאילתות חוזרות, לצד ניטור מדויק של כל קריאה בזמן אמת ללא תלות בבאגים של ה-Dashboard (לוח הבקרה).



בדוק את עצמך — 5 שאלות

מתי נתקל בשגיאה 4006 ב-Workers AI למרות שב-Dashboard רשום שצרכנו 0 Neurons? (רמז: זכרו את ה-dashboard bug המציג נתונים לא מעודכנים בזמן שהמגבלה האמיתית נאכפת ב-API)
מדוע מודלים כמו Llama 3.3-70B עשויים "לשתות" לכם את התקציב היומי תוך פחות מ-25 קריאות? (רמז: חשבו כמה Neurons לוקח כל Output Token במודל 70B לעומת מודל 8B)
איזה פרמטר ב-Vectorize קובע את כמות המסמכים שתוכלו לאחסן בחינם, וכיצד בחירת מודל ה-Embedding משפיעה עליו? (רמז: החיוב הוא לפי Dimensions מצטברים, ומודל כמו bge-small משתמש ב-384 ממדים לעומת 768 של bge-large)
מדוע לא מומלץ להסתמך על AI Search (RAG-as-a-service המנוהל) עבור אפליקציות הדורשות עדכון מידע בזמן אמת? (רמז: מנגנון ה-Crawl של AI Search פועל בעיכוב של עד יום שלם)
מה קורה לקוד Worker שמשתמש במודל מסומן ל-Deprecation (כמו mistral-7b-v0.1) ברגע שהוא מוסר מהפלטפורמה, והאם ה-Deploy ייכשל? (רמז: ה-Deploy יעבור בהצלחה אך הקריאות בזמן ריצה ייכשלו ללא התרעה מוקדמת בקוד)




סיכום הפרק
בפרק זה צללנו אל מעמקי ה-Edge Inference (הרצת מודלי בינה מלאכותית בקצה הרשת) באמצעות Workers AI. למדנו כיצד לנצל את ה-Free Tier הנדיב של 10,000 נירונים ביום כדי להריץ מודלים מתקדמים כמו Llama ו-Flux, והבנו את המלכודות הנסתרות של תקציב הנירונים וזמני ה-Deprecation של מודלים ישנים בקטלוג.
בנינו צינור RAG (Retrieval-Augmented Generation — ייצור מועשר באחזור) מלא המשלב את Vectorize לאחסון וקטורי מהיר, D1 לניהול מטא-דאטה, ומודלי Embedding מתאימים. השווינו בין הגישה המנוהלת לחלוטין של AI Search לבין שליטה מלאה בצינור הנתונים, ולבסוף הקמנו Facade API (מעטפת ממשק) המאפשרת לכל פרויקט חיצוני לדבר עם מודלי ה-Edge שלנו בחינם כאילו היו OpenAI.
כעת, כשהאפליקציה שלכם יודעת לקרוא ולנתח מידע טקסטואלי ווקטורי במהירות קצה, האתגר הבא הוא ניהול יעיל של קבצי המדיה הגדולים שלכם — התמונות, המסמכים הגולמיים וקבצי הווידאו. בפרק הבא נלמד לנהל קבצי מדיה, תמונות ווידאו ישירות מעל ה-Free Tier של Cloudflare R2, ולהשלים את פאזל האחסון של האפליקציה שלכם בחינם לגמרי.


צ'קליסט — סיכום

הגדרתי את פרויקט Wrangler החדש שלי ותפסתי את ה-Bindings של AI בקובץ הקונפיגורציה.
נרשמתי ל-Cloudflare ואימתתי שחשבון ה-Workers שלי פעיל ותקין.
הרצתי בדיקת חיוניות ראשונה למודל llama-3.1-8b וקיבלתי פלט טקסט תקין ב-Terminal.
הגדרתי אינדקס וקטורי ב-Vectorize באמצעות פקודת wrangler vectorize create עם 384 ממדים.
הטמעתי פונקציית Embedding הממירה פסקאות טקסט לווקטורים באמצעות מודל bge-small.
בניתי מנגנון לאחסון וקטורים ישירות בתוך Vectorize לצד קישור מטא-דאטה בבסיס הנתונים SQL D1.
הגדרתי חוקי ניתוב ו-Caching בתוך AI Gateway כדי לצמצם את צריכת ה-Neurons של קריאות חוזרות.
החלפתי את כל שמות המודלים בקוד ממודלי Beta ישנים למודלי GA (General Availability) יציבים מקטלוג 2026.
פרסתי Worker המשמש כ-API Facade המתרגם קריאות במבנה של OpenAI לקוד ה-Workers AI הפנימי שלנו.
בדקתי את ה-Worker מקומית באמצעות curl ואימתתי קבלת תשובה בפורמט JSON תקין.
הגדרתי מנגנון Rate Limiting מבוסס KV ב-Worker כדי למנוע ממשתמשים חיצוניים "לשתות" את מכסת ה-Neurons היומית שלי.
וידאתי שזמן ה-Reset של ה-Free Tier שלי מסונכרן לשעה 00:00 UTC והתאמתי את התראות השרת שלי בהתאם.



בינוני6 דקותחינםמושג
פרויקט יצירתי: AI API facade — Worker שעוטף Workers AI עם rate-limiting ב-KV וחושף /v1/chat/completions תואם-OpenAI, חינם עד 10k neurons/day
הרעיון של בניית AI API Facade (חזית תוכנה לעבודה מול בינה מלאכותית) נולד מתוך צורך פרקטי מאוד: רוב כלי הקוד הפתוח, ממשקי הצ'אט (כמו LibreChat או OpenWebUI) וספריות הפיתוח המודרניות מונעים על ידי פרוטוקול אחיד — ה-API של חברת OpenAI. הם מצפים לקבל קלט בפורמט מדויק, לשלוח אותו לכתובת /v1/chat/completions ולקבל בחזרה מבנה נתונים קשיח המכיל מערך של "choices" ותתי-שדות נוספים. מצד שני, שירות Cloudflare Workers AI מציע ביצועי Inference (הרצת מודל / הסקת מסקנות — התהליך שבו מודל בינה מלאכותית מפיק פלט מתוך קלט נתון) מהירים במיוחד על גבי ה-Edge (מחשוב קצה — רשת שרתים מבוזרת הממוקמת פיזית קרוב ככל הניתן למשתמש הקצה לצמצום שיהוי גלובלי) ובמחיר ללא תחרות, אך בפורמט פלט שונה לחלוטין. באמצעות פיתוח של שכבת תיווך קלה (Facade), נוכל "לחפש" את מודלי החינם של Cloudflare ולהציג אותם לעולם כאילו היו מודל רשמי של OpenAI, מה שיאפשר לנו לחבר אותם מיידית לכל אפליקציה קיימת ללא שינוי קוד מורכב.

בנוסף ליתרון התאימות, קלאודפלייר מעניקה לכל משתמש מכסה חינמית נדיבה במיוחד של 10,000 Neurons (ניורונים — יחידת המדידה הקניינית של Cloudflare לחישוב נפח העבודה של מודלי בינה מלאכותית) בכל יום. עבור מודלים יעילים ומהירים כמו Llama 3 8B, כמות זו מתורגמת לאלפי מילים ביום ללא עלות כלל. עם זאת, פתיחת ה-API שלכם לרשת ללא הגנה עלולה לגרום לניצול מהיר של המכסה היומית הזו על ידי בוטים או משתמשים זללנים. כדי לפתור זאת, נטמיע מנגנון Rate-Limiting (הגבלת קצב בקשות) עצמאי על גבי רשת הקצה בעזרת KV (Key-Value Store — מסד נתונים מבוזר ומהיר במיוחד השומר מידע במבנה פשוט של מפתח וערך). בכל פעם שבקשה מגיעה ל-Worker, נבדוק ב-KV את כמות השימוש של כתובת ה-IP השולחת באותו יום, ונחסום אותה זמנית אם היא חורגת מהגבול שהגדרנו, ובכך נשמור על המכסה החינמית שלנו בטוחה לחלוטין.

ארכיטקטורת המערכת וזרימת הנתונים
המשתמש או האפליקציה שולחים בקשת POST סטנדרטית של OpenAI לנתיב /v1/chat/completions של ה-Worker שפיתחתם. ה-Worker, הפועל בשרת הקצה הקרוב ביותר למשתמש, מיירט את הבקשה ומחלץ את כתובת ה-IP של השולח מהכותרת (Header) המאובטחת של Cloudflare. הוא פונה ל-KV המקומי ומברר האם ה-IP הנוכחי עבר את מכסת הבקשות היומית. אם המגבלה נחצתה, ה-Worker מחזיר מיד שגיאת 429 Too Many Requests בפורמט JSON קריא. במידה והבקשה מאושרת, ה-Worker מעדכן את המונה ב-KV, מפרק את ה-JSON שקיבל, מנסח אותו מחדש בפורמט המצופה על ידי Workers AI ומריץ את המודל. עם קבלת התשובה מהמודל, ה-Worker אורז אותה מחדש בתוך אובייקט תואם-OpenAI ומחזיר אותה אל המשתמש בשקיפות מלאה.




בניית ה-Facade Worker והגדרת ה-Rate Limiter 20 דקות
בצעו את הצעדים הבאים כדי להקים את הפרויקט מאפס, להגדיר את בסיס הנתונים בקצה ולפרוס מנגנון API תואם OpenAI עם הגבלת קצב בקשות מבוססת IP.


  

    התקנה והתחברות לחשבון Cloudflare:
    פתחו את הטרמינל במחשבכם ובצעו התקנה של כלי הפיתוח Wrangler (ממשק שורת הפקודה של Cloudflare) והתחברו לחשבונכם:
    
npm install -g wrangler
wrangler login
    הפלט הצפוי: הטרמינל יפתח חלון דפדפן לאישור הגישה. לאחר האישור, תופיע בטרמינל ההודעה: Successfully logged in!
  

  

    יצירת פרויקט Worker חדש:
    הריצו את פקודת האתחול הבאה בטרמינל כדי ליצור תיקיית פרויקט חדשה בשם ai-api-facade:
    
npm create cloudflare@latest ai-api-facade -- --type=messaging
    במהלך האתחול, בחרו באפשרות של "Hello World" Worker והעדיפו שימוש ב-JavaScript/TypeScript בסיסי. לאחר מכן היכנסו לתיקייה שנוצרה:
    
cd ai-api-facade
  

  

    יצירת רכיב ה-KV לאחסון המונים:
    ניצור מסד נתונים מסוג KV שישמש לשמירת מוני הבקשות של המשתמשים לפי ה-IP שלהם:
    
wrangler kv:namespace create LIMITER_KV
    הפלט הצפוי: הטרמינל יציג קטע קוד קונפיגורציה המכיל id ייחודי. העתיקו את השורות הללו.
  

  

    הגדרת קובץ ההגדרות wrangler.toml:
    פתחו את הקובץ wrangler.toml בשורש הפרויקט שלכם, ומחקו את תוכנו. הדביקו במקומו את הקוד הבא, תוך החלפת ה-id של ה-KV בערך שקיבלתם בשלב הקודם:
    
name = "ai-api-facade"
main = "src/index.js"
compatibility_date = "2024-01-01"

[[kv_namespaces]]
binding = "LIMITER_KV"
id = "YOUR_KV_NAMESPACE_ID_HERE"

[ai]
binding = "AI"
  

  

    כתיבת קוד ה-Worker:
    פתחו את הקובץ src/index.js והחליפו את כל תוכנו בקוד ה-Facade המלא הבא:
    
export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    // טיפול בבקשות Preflight של דפדפנים (CORS)
    if (request.method === "OPTIONS") {
      return new Response(null, {
        headers: {
          "Access-Control-Allow-Origin": "*",
          "Access-Control-Allow-Methods": "POST, OPTIONS",
          "Access-Control-Allow-Headers": "Content-Type, Authorization",
        }
      });
    }

    // חסימת כל נתיב שאינו נתיב הפניה הרשמי של OpenAI
    if (request.method !== "POST" || url.pathname !== "/v1/chat/completions") {
      return new Response(JSON.stringify({ error: { message: "Only POST /v1/chat/completions is supported." } }), {
        status: 404,
        headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
      });
    }

    // מנגנון Rate-Limiting מבוסס IP
    const clientIP = request.headers.get("CF-Connecting-IP") || "anonymous";
    const today = new Date().toISOString().split('T')[0];
    const kvKey = `rate:${clientIP}:${today}`;

    const currentRequests = parseInt(await env.LIMITER_KV.get(kvKey) || "0");
    const DAILY_LIMIT = 50; // מגבלה יומית של 50 בקשות ל-IP

    if (currentRequests >= DAILY_LIMIT) {
      return new Response(JSON.stringify({
        error: { message: "Daily limit exceeded for your IP. Try again tomorrow." }
      }), {
        status: 429,
        headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
      });
    }

    // עדכון המונה ב-KV עם תוקף של 24 שעות
    await env.LIMITER_KV.put(kvKey, (currentRequests + 1).toString(), { expirationTtl: 86400 });

    try {
      const body = await request.json();
      const messages = body.messages || [];

      // הרצת המודל ב-Workers AI של קלאודפלייר
      const aiResponse = await env.AI.run("@cf/meta/llama-3-8b-instruct", {
        messages: messages
      });

      // בניית מענה תואם לחלוטין למבנה הנתונים של OpenAI
      const openAIResponse = {
        id: `chatcmpl-${crypto.randomUUID()}`,
        object: "chat.completion",
        created: Math.floor(Date.now() / 1000),
        model: "@cf/meta/llama-3-8b-instruct",
        choices: [
          {
            index: 0,
            message: {
              role: "assistant",
              content: aiResponse.response || aiResponse.text || ""
            },
            finish_reason: "stop"
          }
        ],
        usage: {
          prompt_tokens: -1,
          completion_tokens: -1,
          total_tokens: -1
        }
      };

      return new Response(JSON.stringify(openAIResponse), {
        headers: {
          "Content-Type": "application/json",
          "Access-Control-Allow-Origin": "*"
        }
      });

    } catch (err) {
      return new Response(JSON.stringify({ error: { message: err.message } }), {
        status: 500,
        headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
      });
    }
  }
};
  

  

    פריסת ה-Worker לענן (Deploy):
    הפיצו את הקוד שלכם אל שרתי הקצה הגלובליים של Cloudflare בעזרת הפקודה הבאה:
    
wrangler deploy
    הפלט הצפוי: הטרמינל יציג את תהליך ההעלאה ויספק לכם כתובת URL ישירה ל-Worker שלכם, לדוגמה: https://ai-api-facade.YOUR_SUBDOMAIN.workers.dev.
  

  

    בדיקת ה-API עם כלי הבקשות CURL:
    הריצו את הפקודה הבאה בטרמינל שלכם (החליפו את כתובת ה-URL בכתובת שקיבלתם בסעיף הקודם) כדי לבדוק האם ה-Facade עובד ומחזיר פלט במבנה המבוקש:
    
curl -X POST https://ai-api-facade.YOUR_SUBDOMAIN.workers.dev/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"messages": [{"role": "user", "content": "Hello, who are you?"}]}'
  


פלט נראה לעין שתסיים איתו: תקבלו תשובת JSON מובנית המכילה את השדות choices, message ו-content בדיוק בפורמט הרשמי של OpenAI, המיוצרת ישירות על ידי מודל Llama 3 הרץ בחינם על גבי שרתי ה-Edge שלכם.





  תרגיל מעשי: הקמת צ'אטבוט RAG אישי בחינם על Cloudflare Workers 20 דקות
  
  
בתרגיל זה נקים מערכת RAG (Retrieval-Augmented Generation - טכנולוגיה המאפשרת למודל שפה לענות על בסיס מידע ממסמכים חיצוניים) מלאה הרצה כולה על ה-Edge של Cloudflare. נשתמש ב-Workers AI לצורך יצירת וקטורים (Embeddings) והרצת מודל השפה (Llama 3), וב-Vectorize (בסיס הנתונים הווקטורי של Cloudflare) כדי לאחסן את המידע שלנו.

  

    

      
התקנה והתחברות לחשבון Cloudflare:
      
ראשית, עליך להתקין את כלי הפיתוח של Cloudflare בשם Wrangler (הכלי שמנהל את ה-Workers מהטרמינל) ולבצע התחברות לחשבון שלך. פתח את הטרמינל והרצ את הפקודה הבאה:
      
npm install -g wrangler && wrangler login
      
הפלט הצפוי: דפדפן ייפתח ויבקש ממך לאשר את החיבור לחשבון Cloudflare שלך. לאחר האישור, תראה בטרמינל הודעה: Successfully logged in!
    

    

      
יצירת פרויקט Worker חדש:
      
ניצור פרויקט חדש בשם my-rag-chatbot באמצעות תבנית בסיסית:
      
npm create cloudflare@latest my-rag-chatbot -- --type=simple --lang=ts && cd my-rag-chatbot
      
במהלך ההתקנה תישאל האם להשתמש ב-Git והאם להריץ deploy - בחר ב-Yes עבור Git וב-No עבור deploy.
      
הפלט הצפוי: תיקייה חדשה תיווצר עם קבצי הבסיס של הפרויקט, והטרמינל יעבור לתוך התיקייה החדשה.
    

    

      
יצירת אינדקס וקטורי ב-Vectorize:
      
ניצור את בסיס הנתונים הווקטורי שיאחסן את הידע שלנו. נשתמש במודל ה-Embeddings הפופולרי @cf/baai/bge-small-en-v1.5 שמייצר וקטורים בגודל 384 ממדים:
      
npx wrangler vectorize create my-knowledge-db --dimensions=384 --metric=cosine
      
הפלט הצפוי: הודעה המאשרת את יצירת האינדקס עם פרטי ה-ID שלו, למשל: Created index 'my-knowledge-db'.
    

    

      
קונפיגורציית הקובץ wrangler.toml:
      
פתח את הקובץ wrangler.toml שנמצא בשורש הפרויקט, ומחק את תוכנו. הדבק בפנים את הקוד הבא שמקשר בין ה-Worker שלך למודל ה-AI ולבסיס הנתונים הווקטורי:
      
name = "my-rag-chatbot"
main = "src/index.ts"
compatibility_date = "2023-10-30"

[ai]
binding = "AI"

[[vectorize]]
binding = "VECTORIZE"
index_name = "my-knowledge-db"
    

    

      
כתיבת קוד ה-RAG ב-src/index.ts:
      
פתח את הקובץ src/index.ts והחלף את כל תוכנו בקוד הבא. הקוד מכיל שני נתיבים (Endpoints): אחד להזנת מסמך ידע (/ingest) והשני לשאילת שאלות (/query):
      
export interface Env {
  AI: any;
  VECTORIZE: any;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    // 1. נתיב להזנת מידע (Ingest)
    if (url.pathname === "/ingest" && request.method === "POST") {
      const { text, id } = await request.json() as { text: string; id: string };
      
      // הפיכת הטקסט לוקטור (Embedding)
      const embeddingResponse = await env.AI.run("@cf/baai/bge-small-en-v1.5", {
        text: [text]
      });
      const values = embeddingResponse.data[0];

      // שמירת הווקטור ב-Vectorize יחד עם הטקסט המקורי כמטא-דאטה
      await env.VECTORIZE.upsert([
        {
          id: id,
          values: values,
          metadata: { text: text }
        }
      ]);

      return new Response(JSON.stringify({ success: true, message: "המידע נשמר בהצלחה!" }), {
        headers: { "content-type": "application/json" }
      });
    }

    // 2. נתיב לשאילת שאלות (Query)
    if (url.pathname === "/query" && request.method === "POST") {
      const { question } = await request.json() as { question: string };

      // הפיכת השאלה של המשתמש לוקטור
      const queryEmbeddingResponse = await env.AI.run("@cf/baai/bge-small-en-v1.5", {
        text: [question]
      });
      const questionVector = queryEmbeddingResponse.data[0];

      // חיפוש המידע הכי רלוונטי בבסיס הנתונים הווקטורי
      const matches = await env.VECTORIZE.query(questionVector, { topK: 1, returnMetadata: true });
      
      let context = "No database context found.";
      if (matches.matches.length > 0 && matches.matches[0].metadata) {
        context = matches.matches[0].metadata.text as string;
      }

      // שליחת השאלה יחד עם ההקשר שמצאנו למודל השפה Llama 3
      const systemPrompt = `You are a helpful assistant. Use the following context to answer the user's question. Context: ${context}`;
      const aiResponse = await env.AI.run("@cf/meta/llama-3-8b-instruct", {
        messages: [
          { role: "system", content: systemPrompt },
          { role: "user", content: question }
        ]
      });

      return new Response(JSON.stringify({ answer: aiResponse.response, sourceUsed: context }), {
        headers: { "content-type": "application/json; charset=utf-8" }
      });
    }

    return new Response("Not Found", { status: 404 });
  }
};
    

    

      
הרצת השרת מקומית ובדיקת ה-RAG:
      
נריץ את ה-Worker שלנו במצב פיתוח מקומי שמחובר ישירות למשאבי ה-AI וה-Vectorize בענן של Cloudflare:
      
npx wrangler dev --remote
      
הפלט הצפוי: הטרמינל יציג הודעה שהשרת רץ מקומית בכתובת http://localhost:8787.
    

    

      
בדיקה מעשית - הזנת מידע ושאילתה:
      
פתח טרמינל חדש (בזמן שהשרת הראשון עדיין רץ) ובצע הזנה של מידע ספציפי וסודי שלא קיים באינטרנט הציבורי:
      
curl -X POST http://localhost:8787/ingest \
  -H "Content-Type: application/json" \
  -d '{"id": "doc_1", "text": "The secret code word for the Vibe Coders community launch is COCONUT2024"}'
      
הפלט הצפוי: {"success":true,"message":"המידע נשמר בהצלחה!"}
      
      
כעת, נשאל את הצ'אטבוט שאלה שדורשת גישה למידע שהרגע הזנו:
      
curl -X POST http://localhost:8787/query \
  -H "Content-Type: application/json" \
  -d '{"question": "What is the secret code word for the community launch?"}'
    
  

  
פלט נראה לעין שתסיים איתו: תקבל תשובה בפורמט JSON ממודל השפה Llama 3 אשר מבוססת באופן מדויק על המידע שהזנת בצעד הקודם: {"answer":"The secret code word for the Vibe Coders community launch is COCONUT2024.","sourceUsed":"The secret code word for the Vibe Coders community launch is COCONUT2024"}.

  



    קבלת החלטות: בחירת ארכיטקטורת RAG ב-Edge
    
    
שאלה 1: היכן לאחסן את ה-Vector Embeddings (ייצוגים מתמטיים של הטקסט)?
    

        
Cloudflare Vectorize: הבחירה הטבעית ל-Edge. מהיר מאוד, זול, ומאפשר שליפת נתונים ב-latency (זמן השהיה) אפסי ישירות מתוך ה-Worker. מתאים לפרויקטים שרצים במלואם על התשתית של Cloudflare.
        
בסיס נתונים חיצוני (כמו Pinecone או Supabase): מתאים אם יש לכם כבר בסיס נתונים קיים עם המידע שלכם מחוץ ל-Cloudflare, או אם אתם זקוקים לפיצ'רים מתקדמים של סינון היברידי (Hybrid Search) שעדיין לא נתמכים ב-Vectorize.
    

    
שאלה 2: באיזה מודל שפה (LLM) להשתמש ל-Inference (הסקה/יצירת התשובה)?
    

        
מודלים קטנים ומהירים ב-Workers AI (כמו Llama 3 8B): מומלץ לשימוש כללי, מהירות תגובה מקסימלית ואפס עלות (במגבלות ה-Free Tier). המודל רץ ב-Edge קרוב למשתמש.
        
פנייה ל-API חיצוני (כמו OpenAI GPT-4o): מתאים כאשר נדרשת הבנת שפה מורכבת במיוחד, עיבוד לוגי מורכב מאוד, או כתיבה יצירתית ברמה גבוהה, במחיר של זמן תגובה ארוך יותר ועלות כספית לפי שימוש.
    

    
שאלה 3: כיצד לעבד ולפצל את המסמכים (Chunking Strategy)?
    

        
פיצול בצד השרת (On-demand): המשתמש מעלה קובץ, ה-Worker מריץ מודל Embedding ומכניס ל-Vector Database בזמן אמת. מתאים למסמכים קטנים ואישיים.
        
עיבוד מראש (Pre-processing Pipeline): הרצת סקריפט מקומי שמפצל את המסמכים, מייצר את ה-Embeddings ומעלה אותם ל-Vectorize מראש. מתאים למאגרי ידע קבועים, גדולים או מורכבים (כמו ספריות תיעוד שלמות).
    



טעות נפוצה: דחיסת כל קובץ ה-PDF ישירות לתוך ה-Prompt של מודל השפה
למה זה מפתה: כשבונים צ'אטבוט ראשון על מסמכים, הכי פשוט להעתיק את כל הטקסט מהקובץ ולהדביק אותו ישירות לתוך הפרומפט (Prompt - הנחיית המשתמש הנשלחת למודל) של ה-LLM ב-Workers AI, מתוך מחשבה שהמודל כבר "יסתדר" וימצא את התשובה לבד.
למה זה טעות: היתרון הגדול של Workers AI הוא ריצה מהירה ב-Edge (קצוות הרשת הקרובים למשתמש). דחיסת טקסט ארוך לכל שאילתה סותמת את חלון ההקשר (Context Window), מאטה את זמן התגובה (Latency) של הצ'אטבוט בצורה דרמטית, ועלולה לחרוג ממגבלות הזיכרון של המודלים הקטנים והמהירים שרצים על השרתים הכלולים בחבילה החינמית.
מה לעשות במקום: ליישם תהליך RAG (Retrieval-Augmented Generation - אחזור מידע משולב יצירה) אמיתי. אנו נפרק את המסמך לפסקאות קטנות, נהפוך אותן לוקטורים (Embeddings - ייצוג מספרי של משמעות הטקסט) בעזרת מודל ייעודי, ונשמור אותם בתוך Vectorize (מסד הנתונים הוקטורי המובנה והחינמי של Cloudflare). כשמשתמש ישאל שאלה, נשלוף מתוך ה-Database רק את 2-3 הפסקאות הרלוונטיות ביותר, ורק אותן נשלח למודל השפה.