יצירת תוכן באמצעות מודלים של AI

בלב הבינה המלאכותית הגנרטיבית נמצאים מודלים של AI. שתי הדוגמאות הבולטות ביותר למודלים גנרטיביים הן מודלים גדולים של שפה (LLM) ומודלים ליצירת תמונות. המודלים האלה מקבלים קלט שנקרא הנחיה (בדרך כלל טקסט, תמונה או שילוב של שניהם), וממנו יוצרים פלט של טקסט, תמונה או אפילו אודיו או וידאו.

התוצר של המודלים האלה יכול להיות משכנע להפליא: מודלים גדולים של שפה (LLM) יוצרים טקסט שנראה כאילו אדם כתב אותו, ומודלים ליצירת תמונות יכולים ליצור תמונות שדומות מאוד לתמונות אמיתיות או ליצירות אמנות שנוצרו על ידי בני אדם.

בנוסף, מודלים של שפה גדולה הוכיחו שהם מסוגלים לבצע משימות מעבר ליצירת טקסט פשוט:

  • כתיבת תוכנות מחשב.
  • תכנון משימות משנה שנדרשות כדי להשלים משימה גדולה יותר.
  • ארגון נתונים לא מאורגנים.
  • הבנה וחילוץ של נתוני מידע ממאגר טקסט.
  • מעקב אחר פעילויות אוטומטיות וביצוע שלהן על סמך תיאור טקסט של הפעילות.

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

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

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

לפני שמתחילים

כדי להריץ את דוגמאות הקוד בדף הזה, צריך לבצע קודם את השלבים שמפורטים במדריך תחילת השימוש. כל הדוגמאות מבוססות על ההנחה שכבר התקנתם את Genkit כיחס תלות בפרויקט.

מודלים שנתמכים על ידי Genkit

Genkit תוכנן כך שיהיה גמיש מספיק לשימוש בכל שירות של מודל בינה מלאכותית גנרטיבית. ספריות הליבה מגדירות את הממשק המשותף לעבודה עם מודלים, ופלאגינים של מודלים מגדירים את פרטי ההטמעה לעבודה עם מודל ספציפי ועם ה-API שלו.

צוות Genkit מנהל יישומי פלאגין לעבודה עם מודלים שסופקו על ידי Vertex AI,‏ Google Generative AI ו-Ollama:

טעינה והגדרה של יישומי פלאגין של מודלים

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

הפונקציה genkit.Generate()

ב-Genkit, הפונקציה genkit.Generate() היא הממשק הראשי שבו מתבצעת האינטראקציה עם מודלים של בינה מלאכותית גנרטיבית.

הקריאה הפשוטה ביותר של genkit.Generate() מציינת את המודל שבו רוצים להשתמש והנחיית טקסט:

import (
    "context"
    "log"

    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)

func main() {
    ctx := context.Background()

    g, err := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-2.0-flash"),
    )
    if err != nil {
        log.Fatal(err)
    }

    resp, err := genkit.Generate(ctx, g,
        ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    )
    if err != nil {
        log.Fatal(err)
    }

    log.Println(resp.Text())
}

כשמריצים את הדוגמה הקצרה הזו, מודפסים פרטי ניפוי באגים מסוימים, ואחריהם הפלט של הקריאה ל-genkit.Generate(), שבדרך כלל הוא טקסט Markdown כמו בדוגמה הבאה:

## The Blackheart's Bounty

**A hearty stew of slow-cooked beef, spiced with rum and molasses, served in a
hollowed-out cannonball with a side of crusty bread and a dollop of tangy
pineapple salsa.**

**Description:** This dish is a tribute to the hearty meals enjoyed by pirates
on the high seas. The beef is tender and flavorful, infused with the warm spices
of rum and molasses. The pineapple salsa adds a touch of sweetness and acidity,
balancing the richness of the stew. The cannonball serving vessel adds a fun and
thematic touch, making this dish a perfect choice for any pirate-themed
adventure.

מריצים שוב את הסקריפט ומקבלים פלט שונה.

דוגמת הקוד הקודמת שלחה את בקשת היצירה למודל ברירת המחדל שציינתם כשהגדרתם את המכונה של Genkit.

אפשר גם לציין מודל לקריאה יחידה של genkit.Generate():

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.5-pro"),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)

מזהה מחרוזת של דגם נראה כך: providerid/modelid, כאשר מזהה הספק (במקרה הזה, googleai) מזהה את הפלאגין, ומזהה הדגם הוא מזהה מחרוזת ספציפי לפלאגין לגרסה ספציפית של דגם.

הדוגמאות האלה גם מדגימות נקודה חשובה: כשמשתמשים ב-genkit.Generate() כדי לבצע קריאות למודל של AI גנרטיבי, כדי לשנות את המודל שבו רוצים להשתמש צריך להעביר ערך שונה לפרמטר של המודל. השימוש ב-genkit.Generate() במקום ב-SDK של המודלים המקוריים מאפשר לכם להשתמש בקלות רבה יותר בכמה מודלים שונים באפליקציה ולשנות מודלים בעתיד.

עד עכשיו ראינו רק דוגמאות לקריאות genkit.Generate() פשוטות ביותר. עם זאת, genkit.Generate() מספק גם ממשק לאינטראקציות מתקדמות יותר עם מודלים גנרטיביים, כפי שיתואר בקטעים הבאים.

הנחיות מערכת

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

אם המודל שבו אתם משתמשים תומך בהנחיות מערכת, תוכלו לספק אחת באמצעות האפשרות WithSystem():

resp, err := genkit.Generate(ctx, g,
    ai.WithSystem("You are a food industry marketing consultant."),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)

במודלים שלא תומכים בהנחיות מערכת, WithSystem() מדמה את ההנחיה על ידי שינוי הבקשה כך שתופיע כמו הנחיה מערכתית.

פרמטרים של מודל

הפונקציה genkit.Generate() מקבלת את האפשרות WithConfig(), שבאמצעותה אפשר לציין הגדרות אופציונליות ששולטות באופן שבו המודל יוצר תוכן:

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    ai.WithConfig(&googlegenai.GeminiConfig{
        MaxOutputTokens: 500,
        StopSequences:   ["<end>", "<fin>"],
        Temperature:     0.5,
        TopP:            0.4,
        TopK:            50,
    }),
)

הפרמטרים המדויקים שנתמכים תלויים במודל הספציפי וב-API של המודל. עם זאת, הפרמטרים בדוגמה הקודמת נפוצים כמעט בכל מודל. בהמשך מוסבר על הפרמטרים האלה:

פרמטרים ששולטים באורך הפלט

MaxOutputTokens

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

הפרמטר 'מספר הטוקנים המקסימלי בפלט' מגדיר את המגבלה על מספר הטוקנים שייווצרו באמצעות ה-LLM. יכול להיות שכל מודל משתמש ב-tokenizer שונה, אבל מומלץ להתייחס למילה אנגלית אחת ככזו שמכילה 2 עד 4 אסימונים.

כפי שצוין קודם, יכול להיות שחלק מהאסימונים לא ימופו לרצפי תווים. דוגמה לכך היא שלרוב יש אסימון שמציין את סוף הרצף: כש-LLM יוצר את האסימון הזה, הוא מפסיק ליצור אסימונים נוספים. לכן, יכול להיות, ולרוב זה המצב, שמודל LLM יוצר פחות אסימונים מהמספר המקסימלי כי הוא יצר את האסימון 'stop'.

StopSequences

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

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

פרמטרים ששולטים ב'קריאייטיב'

הפרמטרים temperature,‏ top-p ו-top-k קובעים יחד את מידת היצירתיות של המודל. בקטע הזה מוסבר בקצרה מה המשמעות של הפרמטרים האלה, אבל הנקודה החשובה יותר היא: הפרמטרים האלה משמשים להתאמת אופי הפלט של LLM. הערכים האופטימליים שלהם תלויים ביעדים ובהעדפות שלכם, וסביר להניח שאפשר למצוא אותם רק באמצעות ניסוי וטעייה.

טמפרטורה

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

ערכים נמוכים של הטמפרטורה – בין 0.0 ל-1.0 – מגבירים את ההבדל בשיעורי הסבירות בין האסימונים, וכתוצאה מכך הסבירות שהמודל ייצור אסימון שכבר העריך כבלתי סביר תהיה נמוכה עוד יותר. לרוב, התוצאה היא תוכן פחות יצירתי. מבחינה טכנית, הערך 0.0 הוא לא ערך תקף, אבל במודלים רבים הוא מתייחס לכך שהמודל צריך לפעול באופן דטרמיניסטי, ולשקול רק את האסימון הסביר ביותר.

ערכים גבוהים של טמפרטורה – ערכים שגדולים מ-1.0 – מפחיתים את ההבדלים בשיעורי הסבירות בין האסימונים, וכתוצאה מכך יש סיכוי גבוה יותר שהמודל ייצור אסימונים שהמערכת העריכה בעבר שהם לא סבירים. לרוב, התוצאה היא תוכן יצירתי יותר. בחלק מ-API של מודלים יש טמפרטורה מקסימלית, לרוב 2.0.

TopP

Top-p הוא ערך בין 0.0 ל-1.0 שקובע את מספר האסימונים האפשריים שהמודל ייחשב, על ידי ציון ההסתברות המצטברת של האסימונים. לדוגמה, ערך של 1.0 מציין שצריך להביא בחשבון כל אסימון אפשרי (אבל עדיין להביא בחשבון את ההסתברות של כל אסימון). ערך של 0.4 מציין שצריך להביא בחשבון רק את האסימונים הסבירים ביותר, שההסתברויות שלהם מצטברות ל-0.4, ולהחריג את האסימונים הנותרים מההתחשבות.

TopK

Top-k הוא ערך שלם שגם קובע את מספר האסימונים האפשריים שרוצים שהמודל יבחן, אבל הפעם על ידי ציון מפורש של המספר המקסימלי של האסימונים. אם מציינים ערך של 1, המשמעות היא שהמודל צריך להתנהג באופן דטרמיניסטי.

ניסוי עם פרמטרים של מודלים

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

התאמת המודל לתצורה שלו

מכיוון שלכל ספק או אפילו למודל ספציפי יכולה להיות סכימה משלו של הגדרות או הגדרות מסוימות, הגדרת אפשרויות נפרדות באמצעות WithModelName() ו-WithConfig() עלולה לגרום לשגיאות, כי הסוג של WithConfig() לא תואם לסוג של WithModelName().

כדי להתאים מודל להגדרות שלו, אפשר ליצור הפניה למודל שאפשר להעביר לקריאה ליצירה במקום זאת:

model := googlegenai.GoogleAIModelRef("gemini-2.0-flash", &googlegenai.GeminiConfig{
    MaxOutputTokens: 500,
    StopSequences:   ["<end>", "<fin>"],
    Temperature:     0.5,
    TopP:            0.4,
    TopK:            50,
})

resp, err := genkit.Generate(ctx, g,
    ai.WithModel(model),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)
if err != nil {
    log.Fatal(err)
}

ה-constructor של ההפניה למודל יאלץ את המערכת לספק את סוג ההגדרה הנכון, וכך לצמצם את מספר אי ההתאמות.

פלט מובנה

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

ב-Genkit, אפשר לבקש פלט מובנה מדגם על ידי ציון סוג הפלט בזמן הקריאה ל-genkit.Generate():

type MenuItem struct {
    Name        string   `json:"name"`
    Description string   `json:"description"`
    Calories    int      `json:"calories"`
    Allergens   []string `json:"allergens"`
}

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    ai.WithOutputType(MenuItem{}),
)
if err != nil {
  log.Fatal(err) // One possible error is that the response does not conform to the type.
}

סוגי הפלט של המודלים מצוינים כסכימה של JSON באמצעות החבילה invopop/jsonschema. כך מתבצעת בדיקת סוגים בזמן ריצה, שמאפשרת לגשר על הפער בין סוגי Go סטטיים לבין הפלט הבלתי צפוי של מודלים של AI גנרטיבי. המערכת הזו מאפשרת לכתוב קוד שיכול להסתמך על העובדה שקריאה מוצלחת ל-generate תמיד תחזיר פלט שתואם לסוגי Go שלכם.

כשמציינים סוג פלט ב-genkit.Generate(), Genkit מבצע כמה פעולות מאחורי הקלעים:

  • הנחיות נוספות לגבי פורמט הפלט שנבחר מתווספות להנחיה. לפעולה הזו יש גם השפעה משנית: היא מאפשרת לציין למודל בדיוק איזה תוכן אתם רוצים ליצור (לדוגמה, לא רק להציע פריט תפריט, אלא גם ליצור תיאור, רשימת אלרגנים וכו').
  • מוודאים שהפלט תואם להסכימה.
  • יצירת פורמט של הפלט של המודל לסוג של Go.

כדי לקבל פלט מובנה מבקשת generate מוצלחת, צריך להפעיל את Output() בתגובה של המודל עם ערך ריק מהסוג:

var item MenuItem
if err := resp.Output(&item); err != nil {
    log.Fatalf(err)
}

log.Printf("%s (%d calories, %d allergens): %s\n",
    item.Name, item.Calories, len(item.Allergens), item.Description)

לחלופין, אפשר להשתמש ב-genkit.GenerateData() כדי לבצע קריאה תמציתית יותר:

item, resp, err := genkit.GenerateData[MenuItem](ctx, g,
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)
if err != nil {
  log.Fatal(err)
}

log.Printf("%s (%d calories, %d allergens): %s\n",
    item.Name, item.Calories, len(item.Allergens), item.Description)

הפונקציה הזו דורשת את הפרמטר של סוג הפלט, אבל מגדירה באופן אוטומטי את האפשרות WithOutputType() ומפעילה את resp.Output() לפני שהיא מחזירה את הערך.

טיפול בשגיאות

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

  • מנסים מודל אחר. כדי ליצור פלט מובנה, המודל צריך להיות מסוגל ליצור פלט בפורמט JSON. המודלים החזקים ביותר של LLM, כמו Gemini, הם גמישים מספיק כדי לעשות זאת. עם זאת, מודלים קטנים יותר, כמו חלק מהמודלים המקומיים שבהם משתמשים ב-Ollama, עשויים לא להיות מסוגלים ליצור פלט מובנה באופן מהימן, אלא אם הם אומנו במיוחד לעשות זאת.

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

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

סטרימינג

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

ב-Genkit, אפשר להעביר פלט בסטרימינג באמצעות האפשרות WithStreaming():

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Suggest a complete menu for a pirate themed restaurant."),
    ai.WithStreaming(func(ctx context.Context, chunk *ai.ModelResponseChunk) error {
        // Do something with the chunk...
        log.Println(chunk.Text())
        return nil
    }),
)
if err != nil {
    log.Fatal(err)
}

log.Println(resp.Text())

קלט מרובה מצבים

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

היכולת לקבל קלט מדיה וסוג המדיה שבו אפשר להשתמש תלויים לחלוטין במודל וב-API שלו. לדוגמה, סדרת המודלים של Gemini 2.0 יכולה לקבל תמונות, סרטונים ואודיו בתור הנחיות.

כדי לספק הנחיה של מדיה למודל שתומך בה, במקום להעביר הנחיה פשוטה של טקסט אל genkit.Generate(), מעבירים מערך שמכיל חלק של מדיה וחלק של טקסט. בדוגמה הזו מצוין קובץ תמונה באמצעות כתובת URL מסוג HTTPS שגלויה לכולם.

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithMessages(
        NewUserMessage(
            NewMediaPart("image/jpeg", "https://example.com/photo.jpg"),
            NewTextPart("Compose a poem about this image."),
        ),
    ),
)

אפשר גם להעביר נתוני מדיה ישירות על ידי קידוד שלהם ככתובת URL של נתונים. לדוגמה:

image, err := ioutil.ReadFile("photo.jpg")
if err != nil {
    log.Fatal(err)
}

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithMessages(
        NewUserMessage(
            NewMediaPart("image/jpeg", "data:image/jpeg;base64," + base64.StdEncoding.EncodeToString(image)),
            NewTextPart("Compose a poem about this image."),
        ),
    ),
)

כל המודלים שתומכים בהזנת מדיה תומכים גם בכתובות URL של נתונים וגם בכתובות URL מסוג HTTPS. חלק מהיישומי פלאגין של המודלים מוסיפים תמיכה במקורות מדיה אחרים. לדוגמה, הפלאגין של Vertex AI מאפשר גם להשתמש בכתובות URL של Cloud Storage‏ (gs://).

השלבים הבאים

מידע נוסף על Genkit

  • כמפתחי אפליקציות, הדרך העיקרית שבה אתם יכולים להשפיע על הפלט של מודלים של AI גנרטיבי היא באמצעות הנחיות. במאמר ניהול הנחיות באמצעות Dotprompt מוסבר איך Genkit עוזר לכם לפתח הנחיות יעילות ולנהל אותן בבסיס הקוד.
  • genkit.Generate() הוא הליבה של כל אפליקציה שמבוססת על בינה מלאכותית גנרטיבית, אבל בדרך כלל צריך לבצע עבודות נוספות לפני ואחרי שמפעילים מודל של בינה מלאכותית גנרטיבית באפליקציות בעולם האמיתי. כדי לשקף את זה, Genkit מציג את המושג flows, שהם מוגדרים כמו פונקציות אבל מוסיפים תכונות נוספות כמו יכולת תצפית ופריסה פשוטה יותר. למידע נוסף, ראו הגדרת תהליכי עבודה של AI.

שימוש מתקדם ב-LLM

יש שיטות שבהן האפליקציה יכולה להשתמש כדי להפיק תועלת רבה יותר מ-LLM.

  • אחת הדרכים לשפר את היכולות של מודלים LLM היא להציג להם רשימה של דרכים שבהן הם יכולים לבקש מכם מידע נוסף, או לבקש מכם לבצע פעולה כלשהי. התהליך הזה נקרא קריאה לכלי או קריאה לפונקציה. מודלים שהודרכו לתמוך ביכולת הזו יכולים להגיב להנחיה בתגובה בפורמט מיוחד, שמציינת לאפליקציה הקוראת שהיא צריכה לבצע פעולה מסוימת ולשלוח את התוצאה בחזרה ל-LLM יחד עם ההנחיה המקורית. ב-Genkit יש פונקציות ספרייה שמאפשרות להפוך לאוטומטיות את יצירת ההנחיות ואת רכיבי הלולאה של קריאה-תגובה של הטמעת קריאה של כלי. מידע נוסף זמין במאמר קריאה לכלי.
  • יצירת תוכן באמצעות השלמה מחיפוש (RAG) היא שיטה שמשמשת להוספת מידע ספציפי לדומיין לפלט של מודל. כדי לעשות זאת, מוסיפים מידע רלוונטי להנחיה לפני שמעבירים אותה למודל השפה. כדי להטמיע את RAG באופן מלא, צריך לשלב כמה טכנולוגיות: מודלים ליצירת הטמעת טקסט, מסדי נתונים של וקטורים ומודלים גדולים של שפה. במאמר יצירה עם שיפור אחזור (RAG) מוסבר איך Genkit מפשט את תהליך התיאום בין הרכיבים השונים האלה.