היסטוריית צ'אט עבור יישומי AI עם Azure Cosmos DB Go SDK

פוסט הבלוג הזה מכסה איך לבנות יישום להיסטוריית צ'אט באמצעות Azure Cosmos DB עבור NoSQL Go SDK ו-LangChainGo. אם אתה חדש ב-Go SDK, היישום לדוגמה של צ'אטבוט שמוצג בבלוג מהווה הקדמה פרקטית, כוללת פעולות בסיסיות כמו קריאה, עדכון, וכדומה. הוא מציג גם איך להשתמש במדמה הלינוקסי של Azure Cosmos DB (בתצורת תצוגה מקדימה בזמן הכתיבה) עבור בדיקות אינטגרציה עם Testcontainers עבור Go.

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

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

מהו היסטוריית צ'אט, ולמה זה חשוב ליישומי AI מודרניים?

דרישה נפוצה ליישומי AI שמתמקדים בשיחה היא היכולת לאחסן ולשחזר הודעות שנשלחו כחלק מהשיחה. נקרא לכך לעיתים "היסטוריית צ'אט". אם השתמשת ביישומים כמו ChatGPT (שגם הוא משתמש ב-Azure Cosmos DB, על דרך!), יתכן שתהיה מוכר עם המושג הזה.

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

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

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

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

איך להפעיל את הצ'אטבוט

כפי שציינתי קודם, היישום הדוגמה הוא דרך שימושית עבורך לחקור את "langchaingo", מימוש ההיסטוריה של צ'אט ב-Azure Cosmos DB, כמו גם את Go SDK.

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

סקירת היישום

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

צד שרת

יש לו חלקים מרובים:

• מימוש היסטוריית הצ'אט ב-Azure Cosmos DB.
• פעולות יסוד כגון פתיחת שיחה, שליחת/קבלת הודעות, ואחזור היסטוריית השיחה נגישות דרך API REST.
• ה-REST API משתמש בשרשרת langchaingo כדי לטפל בהודעות משתמש. השרשרת משתמשת באופן אוטומטי בהיסטוריית הצ'אט כדי לוודא ששיחות קודמות נשלחות ל-LLM. langchaingo מטפלת באורכסטרציה כוללת – קריאה ל-LLM, כלולות בהיסטוריית צ'אט, ועוד, מבלי לדרוש יישום ידני.

Frontend

הוא נבנה באמצעות JavaScript, HTML, ו-CSS. הוא מאורז כחלק משרת האינטרנט של Go (באמצעות חבילת ה-embed) וקורא ל-REST APIs של הבסיס נתונים בתגובה לאינטראקציות של המשתמש.

יישום היסטוריית צ'אט באמצעות Azure Cosmos DB

LangChainGo הוא מסגרת ניתנת להתקנה, כוללת את רכיב ההיסטוריה שלו (או זיכרון). כדי לשלב את Azure Cosmos DB, עליך ליישם את ממשק ה-schema.ChatMessageHistory, אשר מספק שיטות לניהול ההיסטוריה של הצ'אט:

• AddMessage להוספת הודעות לשיחה (או להתחיל שיחה חדשה).
• Messages לאחזור את כל ההודעות של שיחה.
• Clear למחיקת כל ההודעות בשיחה.

בעוד ניתן ליצור מופשט ישירות של CosmosDBChatMessageHistory ולהשתמש בשיטות אלו, הגישה המומלצת היא לאינטגרציה שלה באפליקצית langchaingo. להלן דוגמא לשימוש בהיסטוריית צ'אט של Azure Cosmos DB עם LLMChain:

// יצירת מופע של היסטוריית צ'אט
cosmosChatHistory, err := cosmosdb.NewCosmosDBChatMessageHistory(cosmosClient, databaseName, containerName, req.SessionID, req.UserID)
if err != nil {
    log.Printf("Error creating chat history: %v", err)
    sendErrorResponse(w, "Failed to create chat session", http.StatusInternalServerError)
    return
}

// יצירת זיכרון עם ההיסטוריה של הצ'אט
chatMemory := memory.NewConversationBuffer(
    memory.WithMemoryKey("chat_history"),
    memory.WithChatHistory(cosmosChatHistory),
)

// יצירת שרשרת LLM
chain := chains.LLMChain{
    Prompt:       promptsTemplate,
    LLM:          llm,
    Memory:       chatMemory,
    OutputParser: outputparser.NewSimple(),
    OutputKey:    "text",
}

מנקודת מבט של Azure Cosmos DB, חשוב לשים לב שהמימוש בדוגמה זו הוא רק אחת מהאפשרויות הרבות. המימוש המוצג כאן מבוסס על קיבוץ מזהה המשתמש כמפתח המחצה ומזהה השיחה (גם מכונה מידת הסשן לעיתים) כהמפתח הייחודי (id של פריט Azure Cosmos DB).

זה מאפשר לאפליקציה:

• לקבל את כל ההודעות לשיחה. זהו קריאת נקודה באמצעות המזהה הייחודי (מזהה השיחה) ומפתח המחצה (מזהה המשתמש).
• הוסף הודעה חדשה לשיחה. זה משתמש בפעולת upsert (במקום create) כדי למנוע את הצורך ב- read לפני הכתיבה.
• מחק שיחה ספציפית. זה משתמש בפעולת delete כדי להסיר שיחה (ואת כל ההודעות שלה).

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

פשוט נסיון עם אמולטור של Azure Cosmos DB ו- Testcontainers

היישום לדוגמה כולל מקרי בדיקה בסיסיים לשני התחומים – ההיסטורית השיחות של Azure Cosmos DB והיישום הראשי. שווה להדגיש את השימוש ב־testcontainers-go כדי לאינטגרציה עם תוכנת ה־אמולטור המבוסס על Linux של Azure Cosmos DB בתוך תוצרת ה־docker.

הדבר מעולה לבדיקות אינטגרציה מאחר שמסד הנתונים זמין מקומית והבדיקות רצות הרבה יותר מהר (בלי לשכוח את חסכון העלויות גם!). הקירחה על העוגה היא שאין צורך לנהל באופן ידני את מחזור חיי ה־Docker container. ההתייחסות לכך מתבצעת כחלק מאופציות הבדיקה, תודות ל־API של testcontainers-go המקלה על התחלת ה־container לפני ריצת הבדיקות ועל סיום פעולתו לאחר שהן הושלמו.

ניתן לעיין במקרי הבדיקה ביישום הדוגמה למידע נוסף. הנה קטע מהשימוש ב־testcontainers-go:

func setupCosmosEmulator(ctx context.Context) (testcontainers.Container, error) {
    req := testcontainers.ContainerRequest{
        Image:        emulatorImage,
        ExposedPorts: []string{emulatorPort + ":8081", "1234:1234"},
        WaitingFor:   wait.ForListeningPort(nat.Port(emulatorPort)),
    }

    container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: req,
        Started:         true,
    })
    if err != nil {
        return nil, fmt.Errorf("failed to start container: %w", err)
    }

    // Give the emulator a bit more time to fully initialize
    time.Sleep(5 * time.Second)

    return container, nil
}

אם אתה מעוניין להשתמש ב־Azure Cosmos DB Emulator בצינורות CI, עדכן ב־פוסט הבלוג.

עיקום

יכולת לאחסן היסטוריית שיחות היא חלק חשוב באפליקציות של בינה מלאכותית שיחתית. הן יכולות לשמש כהוספה נהדרת לטכניקות קיימות כמו RAG (יצירה מואצת על ידי חיפוש). נסו את אפליקציית הצ'אט והודיעו לנו מה דעתכם!

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

חלק מהדרישות שלך עשויות לכלול:

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

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

האם כבר משתמשים או מתכננים להשתמש ב-Azure Cosmos DB עבור היישומים שלכם ב-Go? אנחנו רוצים מאוד לשמוע מכם! שלחו לנו את שאלותיכם ומשובכם.