פיתוח אפליקציות מבוססות-AI באמצעות הסביבה העסקית של Google

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

פיתוח התוכנה השתנה. המפתחים הכי מצליחים לא רק כותבים קוד, אלא גם משלבים כלי AI וסוכנים כדי לפתח טוב יותר ומהר יותר. סביבת הכלים של Google מספקת חבילה מקיפה לכל מחזור החיים: יצירת ממשק משתמש, פיתוח אב טיפוס ופריסה של אפליקציות, פיתוח תכונות מבוססות-AI ושילוב מאובטח וניתן להתאמה של קצה עורפי. ב-Codelab הזה תשתמשו ב-Google Stitch כדי לעצב את ממשק המשתמש, ב-Google AI Studio כדי לתכנת בשיטת Vibe coding ולפרוס את האפליקציה, וב-Firebase כדי לפתח תכונות מבוססות-AI ולאחסן מידע בקצה עורפי מאובטח וניתן להתאמה.

האפליקציה שתיצרו ב-Codelab הזה נקראת Decide For Me – עוזר אישי לקבלת החלטות לאנשים שמתקשים להחליט לגבי בחירות בחיים (כמו מעבר דירה, שינוי קריירה או בחירת תחביב). המשתמש מזין דילמה ואת סדרי העדיפויות שלו בחיים, והאפליקציה משתמשת ב-AI כדי לעזור למשתמש להחליט על סמך מה שממזער את האכזבה לטווח הארוך. האפליקציה גם נותנת למשתמשים שלב ראשון ומוחשי. הגרסה הסופית של האפליקציה אמורה להיראות כך:

צילום מסך של אפליקציית Decide For Me שבו מוצגים ממשק הצ'אט וחלונית סדרי העדיפויות

מה תלמדו

  • עיצוב ממשקי משתמש באמצעות Google Stitch.
  • תכנות בשיטת Vibe coding של אפליקציית אינטרנט באמצעות Google AI Studio.
  • אתם יכולים להשתמש ב-Firebase כדי לפתח תכונות מבוססות-AI ולאחסן מידע בענן.
  • פריסת אפליקציית אינטרנט לסביבת ייצור באמצעות Google AI Studio (מופעל על ידי Cloud Run).

2. עיצוב ממשק המשתמש באמצעות Stitch

  1. מורידים את התמונה לדוגמה (DecideForMeScreen.jpeg) ושומרים אותה בתיקייה מקומית שקל למצוא.
  2. עוברים אל Stitch, מאתרים את השדה להזנת קלט ובוחרים באפשרות אינטרנט. (ב-Codelab הזה נתמקד בחוויית השימוש באינטרנט, אבל אפשר להשתמש ב-Stitch גם כדי ליצור מסכים לנייד).
  3. מעלים את תמונת המוקאפ:
    1. לוחצים על + (כפתור ההוספה).
    2. לוחצים על העלאת קבצים.
    3. מצרפים את התמונה שהורדתם בשלב ההגדרה (DecideForMeScreen.jpeg). המוקאפ הזה שצויר ביד מאפשר לכם לבדוק את היכולות המולטי-מודאליות של Stitch.
  4. מעתיקים את ההנחיה הבאה ומדביקים אותה בשדה להזנת קלט:
    # General Guidance
    Create a modern, clean, and highly polished UI for a web application called
    "Decide For Me" - a hyper-rational decision assistant.
    
    CRITICAL: Replicate the exact layout, structure, and element placement shown in
    the hand-drawn mockup file DecideForMeScreen.jpeg. Do not add any extra menus,
    sidebars, buttons, or top/bottom navigation bars that are not explicitly drawn
    in the file. Stick strictly to the skeleton provided in the mockup.
    
    # Layout & Structure
    - Two-Column Split Screen:
      - Left Side (Main Chat Area): Takes up roughly 70-75% of the screen width. It
        should feel like a premium, focused workspace.
      - Right Side (Configuration Panel): A sidebar taking up 25-30% of the screen
        width with a distinct, subtle background color to separate it from the
        chat.
    
    # Right Panel: Configuration Screen
    - Header: Title it "My Priorities" with a clean, minimalist typography.
    - Content Card: A styled card containing a text box or paragraph area
      showcasing the user's priorities.
    - Interactions: Include a clear "Edit Priorities" button. When clicked, this
      area should visually toggle into an editable textarea or input field.
    
    # Left Panel: Chat & Dilemma Decision Screen
    - Chat History: A clean vertical flow of message bubbles.
      - The first message bubble must be aligned to the left (system message) and
        say: "Tell me your dilemma". Use a friendly, neutral background color for
        this bubble.
    - Bottom Input Area: Instead of a traditional single-line chat bar, create a
      unified, beautiful "Decision Submission" layout positioned at the bottom:
      - Dual Input Fields: Place two horizontal or cleanly stacked input fields.
        - Input 1 label: "Option A"
        - Input 2 label: "Option B"
      - Action Button: A prominent, styled "Go" action button to trigger the
        reasoning loop.
    
    # Theme & Aesthetic
    - Vibe: Hyper-rational, clean, trustworthy, and modern. Use a sophisticated
      color palette (e.g., deep slates, clean whites/grays, and a sharp accent
      color like a subtle indigo or teal for active states and buttons).
    - Spacing & Typography: Use generous whitespace, soft rounded corners
      (border-radius) for cards and buttons, and a highly legible sans-serif font.
    
  5. לוחצים על החץ ליצירת התמונה בפינה השמאלית התחתונה של השדה להזנת קלט. ‫Stitch יוצר את המסך ואת כל מערכת העיצוב, כולל לוח צבעים, אפשרויות גופנים, איקונוגרפיה והתחושה הכללית של רכיבי ממשק המשתמש:

ממשק של Stitch שמוצגים בו העיצוב ומערכת העיצוב של ממשק המשתמש שנוצר ב-Decide For Me

3. פיתוח האפליקציה באמצעות Google AI Studio

  1. יוצרים פרויקט ב-Firebase:
    1. נכנסים למסוף Firebase באמצעות אותו חשבון Google שבו השתמשתם ב-Stitch.
    2. לוחצים על הכפתור כדי ליצור פרויקט חדש, ואז מזינים שם לפרויקט (לדוגמה, Decider App).
    3. לוחצים על המשך.
    4. אם מוצגת בקשה, קוראים ומאשרים את התנאים של Firebase ולוחצים על המשך.
    5. (אופציונלי) מפעילים את העזרה מבוססת-AI במסוף Firebase (נקראת "Gemini ב-Firebase").
    6. ב-Codelab הזה לא צריך את Google Analytics, אז משביתים את האפשרות של Google Analytics.
    7. לוחצים על Create project, מחכים שהפרויקט יוקצה ולוחצים על Continue.
  2. מייצאים את המסך שיצרתם ב-Stitch אל Google AI Studio:
    1. לוחצים על העיצוב שנוצר ב-Stitch.
    2. לוחצים על ייצוא בפינה השמאלית העליונה של המסך.
    3. מוודאים שהאפשרות שנבחרה היא Google AI Studio.
    4. גוללים למטה לשדה תיאור.
  3. מעתיקים את ההנחיה הבאה ומדביקים אותה בשדה Description. מחליפים את [FIREBASE_PROJECT_ID] במזהה הפרויקט האמיתי משלב 1 (אם אתם לא זוכרים את מזהה הפרויקט, אתם יכולים למצוא אותו בהגדרות הפרויקט):
    # General Guidance
    Build the "Decide For Me" app: A hyper-rational decision assistant for
    chronically indecisive people facing life choices (moving apartments, changing
    careers, picking a hobby). The user enters a dilemma and their top priorities
    in life. The app will help with the decision. Follow the instructions below to
    build it:
    
    # UI Instructions
    Using the design artifacts exported from Stitch (the PNG image and HTML file),
    build a fully functional web application that accurately mirrors the design and
    layout.
    
    # App Architecture & Initialization Instructions
    - Initialize the latest Firebase JS SDK for client-side services. Use the
      Firebase project with ID [FIREBASE_PROJECT_ID].
    - Enable Firebase Authentication in this project using the Google provider.
      If a user is not logged in, show a clean, minimalist sign-in state. If the
      user is logged in, take them directly to the dilemma decision screen.
    - Initialize Firebase App Check in debug mode with the following code:
      `self.FIREBASE_APPCHECK_DEBUG_TOKEN = true;`
      `initializeAppCheck(app, { /* App Check options */ });`
    
    
    # State & Database Management Instructions
    - User Priorities:
      - Once authenticated, pull the user's saved priorities from Firebase
        Firestore at the path: `users/{userId}`. Each document should contain one
        string field: 'priorities'.
      - Bind this data to the Right Panel ("My Priorities").
      - When the user clicks the "Edit" button, toggle the view to a textarea, with
        a 'save' button. When saved, write the updated string back to
        `users/{userId}`.
      - Make sure to implement and deploy strong Security Rules for Firestore.
    
    # UI Stream Update & Display Instructions
    - Once the user submits option A and option B in the dilemma decision screen,
      display both options as a single message on the user side of the chat. Then,
      display a sleek loading state in the main chat panel. Leave the app in this
      "loading" state and do nothing else, we will process both options and build
      the server-side thinking later.
    
  4. לוחצים על פיתוח פתרונות עם Google AI Studio. ‫Google AI Studio ייפתח בכרטיסייה חדשה, וקובצי העיצוב וההנחיה יועברו אליו:
    1. מוודאים שההנחיה הועברה במלואה.
    2. אם אתם רואים רק חלק מההנחיה, הדביקו שוב את ההנחיה המלאה.
  5. לוחצים על Build. ‫Google AI Studio מתחיל ליצור את האפליקציה Decide For Me לפי ההנחיה ועיצוב ממשק המשתמש:
    1. בזמן שהיא נוצרת, מוצעים עיצובים חלופיים לממשק המשתמש (אפשר להתעלם מהעיצובים האלה ב-Codelab הזה, אבל אפשר לבחור עיצובים שונים בעתיד).
    2. כשמופיעה בקשה להפעיל את Firebase, לוחצים על הפעלה.
  6. בודקים ומאמתים את האפליקציה שנוצרה:
    1. בודקים את האפליקציה בכרטיסייה תצוגה מקדימה.
    2. עוברים לכרטיסייה קוד כדי לבדוק את כל הקבצים והקוד שנוצרו.
    3. בנוסף, Google AI Studio יצר פרויקט ב-Firebase, הפעיל את אימות ב-Firebase ואת Firestore והגדיר את Firebase בבסיס הקוד שלכם. בשלב הבא של ה-Codelab הזה, תיגשו לפרויקט Firebase הזה ותעבדו איתו.

4. רישום של טוקן ניפוי הבאגים של App Check

כש-Google AI Studio יוצר את האפליקציה, הוא יוצר פרויקט ב-Firebase ומחבר אליו את האפליקציה. צריך לגשת לפרויקט Firebase הזה ולרשום את סביבת הפיתוח שלך בשירות אבטחה חשוב שנקרא Firebase App Check.

גישה לפרויקט Firebase

  1. מוצאים את מזהה הפרויקט ב-Firebase שנוצר על ידי Google AI Studio:
    1. עוברים לכרטיסייה Code ב-Google AI Studio.
    2. פותחים את הקובץ firebase-applet-config.json.
    3. מעתיקים את הערך של השדה projectId.
  2. עוברים אל מסוף Firebase ומחפשים את הפרויקט באמצעות המזהה הזה.

רישום של אסימון ניפוי הבאגים

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

מכיוון שהאפליקציה פועלת בסביבת התצוגה המקדימה של Google AI Studio, היא משתמשת בספק אימות לצורכי ניפוי באגים של App Check ‏ (self.FIREBASE_APPCHECK_DEBUG_TOKEN = true). כשאפליקציית האינטרנט נטענת, Firebase מוציאה באופן אוטומטי אסימון ניפוי באגים למסוף המפתחים של הדפדפן.

  1. מוצאים את אסימון ניפוי הבאגים:
    1. ב-Google AI Studio, פותחים את הכלים למפתחים בדפדפן בזמן שצופים בתצוגה המקדימה של האפליקציה:
      • ב-Chrome, ב-Edge או ב-Firefox: מקישים על F12 (או לוחצים לחיצה ימנית במקום כלשהו בתצוגה המקדימה ובוחרים באפשרות בדיקה), ואז בוחרים בכרטיסייה מסוף.
      • ‫macOS: מקישים על Cmd+Option+I ובוחרים בכרטיסייה Console.
    2. ביומני המסוף, מאתרים את הודעת ניפוי הבאגים של App Check:
      AppCheck debug token: "123a4567-b89c-12d3-e456-789012345678".
      You will need to safelist it in the Firebase console for it to work.
      
    3. מעתיקים את מחרוזת הטוקן (בלי המירכאות).
  2. רושמים את הטוקן לניפוי באגים:
    1. במסוף Firebase, עוברים אל אבטחה > App Check > הכרטיסייה אפליקציות.
    2. מוצאים את אפליקציית האינטרנט ברשימה, לוחצים על סמל האפשרויות הנוספות (⋮) ובוחרים באפשרות ניהול אסימוני ניפוי באגים.
    3. לוחצים על הוספת אסימון ניפוי באגים, מדביקים את האסימון שהועתק, מזינים שם כמו Google AI Studio Preview ולוחצים על שמירה.
    צילום מסך של האפשרות Manage Debug Tokens (ניהול אסימוני ניפוי באגים) בתפריט של מסוף Firebase

5. בדיקת האפליקציה

עכשיו, כשהפרויקט מחובר ואסימון ניפוי הבאגים רשום ב-App Check, אפשר לבדוק את התכונות הבסיסיות: אימות ו-Firestore.

  1. בודקים את אימות המשתמשים ושומרים את סדרי העדיפויות:
    1. בתצוגה המקדימה של האפליקציה Decide For Me ב-Google AI Studio, בודקים את מסך האימות על ידי כניסה באמצעות חשבון Google.
    2. שומרים את סדרי העדיפויות בחיים באמצעות החלונית השמאלית (סדרי העדיפויות שלי).
  2. מאמתים את האימות במסוף Firebase:
    1. עוברים למסוף Firebase ופותחים את Authentication (אימות).
    2. מוודאים שחשבון Google שבו השתמשתם כדי לאמת את האפליקציה Decide For Me מופיע ברשימה:
    דף האימות במסוף Firebase שבו מוצג חשבון Google המאומת
  3. אימות של מאגר הנתונים ב-Firestore:
    1. פותחים את Firestore במסוף Firebase.
    2. מוודאים שסדרי העדיפויות מאוחסנים במסמך בנתיב users/{userId}:
    מסד נתונים של Firestore במסוף Firebase שבו מוצגות העדפות שמאוחסנות בנתיב users/{userId}‎

6. יצירת תהליך קבלת החלטות מבוסס-AI באמצעות Firebase

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

הגדרת Firebase AI Logic

  1. מפעילים את Gemini Developer API ב-Firebase AI Logic:
    1. פותחים את Firebase AI Logic במסוף Firebase ולוחצים על Get started.
    2. בוחרים באפשרות Gemini Developer API ופועלים לפי ההוראות במסוף כדי להפעיל את ה-API.
  2. קובעים את ההגדרות של Firebase AI Logic:
    1. עוברים לכרטיסייה הגדרות.
    2. מעבירים את המתג של האפשרות Enforce template-only mode (אכיפת מצב תבנית בלבד) למצב Enforced (נאכף).
    3. מעבירים את האפשרות אכיפת מצב משתמשים מאומתים למצב נאכפת.

יצירת תבנית לפרומפט בשרת

ב-Codelab הזה תשתמשו בתבניות לפרומפטים בשרת כדי לקיים אינטראקציה עם Gemini API באמצעות Firebase AI Logic.

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

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

כך יוצרים ובודקים תבנית לפרומפט בצד השרת:

  1. יוצרים את תבנית לפרומפט של השרת:
    1. עוברים לכרטיסייה תבניות לפרומפטים.
    2. לוחצים על יצירת תבנית.
    3. בוחרים באפשרות תבנית ריקה.
    4. יוצרים את התבנית הראשונה באמצעות הפרטים הבאים:
      • שם התבנית: Decider Flow
      • מזהה התבנית: decider-flow
      • הגדרה (frontmatter)
        model: "gemini-3.5-flash-lite"
        input:
          schema:
            priorities: "string, user's core priorities"
            optionA: "string, option A under consideration"
            optionB: "string, option B under consideration"
        output:
          format: json
          schema:
            verdict: string
            justification: string
            firstStep: string
        
      • הנחיה והוראות מערכת (אופציונלי)
        {role "system"}
        You are the Decider Agent, a multi-stage reasoning engine that
        combines the roles of an honest and polite behavioral economist, a
        long-term strategic forecaster, and an executive decision coach.
        Your job is to take a user's dilemma and their core priorities, run
        them through a rigorous, adversarial 3-phase thinking process, and
        output a highly analytical, reasoning-backed final verdict. You must be
        direct, sharp, and realistic. Do not give generic platitudes or claim
        that "both options are great." You must force a clear choice.
        
        {role "user"}
        # Context & Inputs
        You are analyzing a critical life decision for the user. Base your
        entire multi-phase reasoning flow strictly on these three specific
        inputs:
        - User's Core Priorities: {{priorities}}
        - Option A under consideration: {{optionA}}
        - Option B under consideration: {{optionB}}
        
        Execute your reasoning flow through the following three phases:
        
        # Phase 1: Cynical Breakdown (Input-Driven Analysis)
        Analyze {{optionA}} and {{optionB}} strictly through the lens of the
        user's explicit {{priorities}}. Do not evaluate them in a vacuum.
        - Identify the hidden flaws, compromises, and psychological costs
          embedded in both choices.
        - Pinpoint exactly how {{optionA}} could directly conflict with or
          undermine their {{priorities}}.
        - Pinpoint exactly how {{optionB}} could directly conflict with or
          undermine their {{priorities}}.
        - Uncover any cognitive biases (like status quo bias or loss aversion)
          the user might be falling for in either option.
        
        # Phase 2: Long-Term Regret Projection
        Project the user 5 years into the future. Apply the Regret Minimization
        Framework to both paths:
        - The {{optionA}} Timeline: Quantify the absolute worst-case, deep,
          structural 5-year regret of choosing this path. Focus heavily on
          failures of courage vs. failures of action based on their
          {{priorities}}.
        - The {{optionB}} Timeline: Quantify the matching 5-year regret for
          this path.
        - Contrast these two timelines. Which option carries the kind of regret
          that fundamentally breaks the user's {{priorities}}?
        
        # Phase 3: Final Recommendation & Action Step
        Synthesize the cynical critiques and long-term regret scores.
        Weigh them against the user's {{priorities}} to determine which
        choice minimizes long-term disappointment.
        - Verdict: You must declare either {{optionA}} or {{optionB}} as the
          definitive winner. No compromise, no "it depends," and no hybrid
          options.
        - Justification: Provide a sharp, reasoning-backed explanation showing why
          the losing option was eliminated based on the Phase 1 and Phase 2
          analysis.
        - First Step: Give one microscopic, low-friction task the user can
          execute within the next 15 minutes to commit to or move toward the
          chosen verdict.
        
        מוסיפים עוד {} מסביב ל-{role "system"} ול-{role "user"} כדי לכתוב את הוראות המערכת וההנחיה בתחביר הנכון: 9db2a4f2c5cf2ec7.png
      • קלט לבדיקה
        {
          "priorities": "Be financially stable, have a good work-life balance where I can travel twice a year",
          "optionA": "Buy a house for 615000 British pounds with a mortgage of 2800 per month for the next 35 years",
          "optionB": "Keep renting for 2400 per month for the foreseeable"
        }
        
  2. לוחצים על שמירת תבנית.
  3. בודקים את התבנית:
    1. לוחצים על הרצת בדיקת הנחיה.
    2. מאתרים את תגובת הבדיקה ומוודאים שהיא כוללת את כל השדות שציינתם בהנחיה (verdict,‏ justification ו-firstStep).
    3. אם הכול תואם לתגובה הצפויה, נועלים את התבנית באמצעות סמל הנעילה בפינה השמאלית העליונה של התבנית כדי להבטיח את יציבות הגרסה ולמנוע שינויים מקריים.

התבנית מוכנה לשימוש באפליקציה.

7. שימוש בתבנית לפרומפט "קבלת החלטות" באפליקציה

כדי להגדיר שאפליקציית האינטרנט תשתמש בתבנית:

  1. חוזרים לאפליקציה ב-Google AI Studio.
  2. מבקשים מהסוכן של Google AI Studio להטמיע את הפעולה Decide For Me:
    1. מעתיקים את ההנחיה הבאה:
      Now let's implement the "Decide For Me" button action. When clicked, it
      should call the Firebase AI Logic SDK using a Template Generative Model.
      The prompt is stored in a prompt template with the id "decider-flow". When
      calling the API, pass the following variables as the input payload object:
      - priorities
      - optionA
      - optionB
      
      The API will return a JSON object. Handle the response asynchronously and
      extract:
      - verdict
      - justification
      - firstStep
      
      Once the data is received, update the UI state to append a new message to
      the chat array. Ensure it renders as a system chat bubble positioned on
      the left side of the chat screen, mapping these three fields clearly into
      the bubble's layout.
      
      Please provide the necessary front-end component state updates and the
      Firebase SDK call.
      
    2. מדביקים את ההנחיה בתיבת הצ'אט של Google AI Studio ולוחצים על Send (שליחה).
  3. מאמתים את ההגדרות ובודקים את עוזר קבלת ההחלטות:
    1. מחכים עד ש-Google AI Studio יסיים להוסיף את Firebase AI Logic לאפליקציה.
    2. עוברים לכרטיסייה Code ומוודאים שיש מפתח API בקובץ firebase-applet-config.json. אם מפתח ה-API של Firebase לא נמצא בקובץ התצורה, בקשו מ-Google AI Studio לייבא אותו.
    3. עוברים לכרטיסייה Preview.
    4. שולחים את אפשרויות א' וב' ומוודאים שה-AI מחזיר את ההחלטה, את הנימוק ואת השלב הראשון.

לשם השוואה, הקוד שנוצר על ידי Google AI Studio אמור להיראות כך:

const aiInstance = getAI(app);
const templateModel = getTemplateGenerativeModel(aiInstance);

const result = await templateModel.generateContent('decider-flow', {
  priorities: priorities,
  optionA: optA,
  optionB: optB
});

const rawText = result.response.text();

// Parse response text to extract fields
const cleaned = rawText.replace(/```json|```/g, '').trim();
const parsedData: { verdict?: string; justification?: string; firstStep?: string } = JSON.parse(cleaned);

const verdict = parsedData.verdict;
const justification = parsedData.justification;
const firstStep = parsedData.firstStep;

ניפוי באגים ומעקב אחרי בקשות

אם באפליקציה יש שגיאות, אם היא לא מצליחה ליצור תשובה או אם אתם רוצים לבדוק את התנועה ב-API בפירוט, אתם יכולים להשתמש בכלי הניתוח והמעקב המובנים של Firebase AI Logic:

  1. במסוף Firebase, עוברים אל שירותי AI‏ > AI Logic > הכרטיסייה מעקב אחרי שימוש בתכונות AI.
  2. בודקים את המדדים הכמותיים במרכז הבקרה:
    • נפח הבקשות והסטטוס שלהן: בודקים אם הבקשות הנכנסות מגיעות לקצה העורפי ומחזירות את הערך 200 OK או נכשלות בגלל שגיאות בצד הלקוח או שגיאה בחיבור לשרת.
    • זמן אחזור: בודקים את תרשים זמן האחזור כדי לבדוק את זמן התגובה מקצה לקצה.
    • מספר הטוקנים: מעקב אחרי השימוש בטוקנים של קלט ופלט בכל בקשה.
  3. בדיקת מעקבים של בקשות ספציפיות לצורך ניפוי באגים מעמיק:לוחצים על מעקב של בקשה ספציפית בטבלת המעקבים כדי לבדוק את המטען הייעודי (payload) שלה.
    • קלט: ודאו שהמשתנים (priorities,‏ optionA ו-optionB) הועברו בצורה תקינה מאפליקציית הלקוח.
    • פלט: אפשר לראות את הטקסט הגולמי שהמודל יצר כדי לוודא שהוא החזיר קובץ JSON תקין שתואם לסכימה.
    • פרטי השגיאה: אם בקשה נכשלת, בודקים את יומן השגיאות של המעקב כדי לראות את הסיבות, כמו אסימוני App Check לא תקינים, דחיית אימות, מגבלות מכסה או שגיאות באימות ההנחיות.
  4. פתרון בעיות שקשורות ל-Google AI Studio:
    • אם זיהיתם שגיאה במעקב (לדוגמה, ניתוח של תגובת JSON בפורמט שגוי או פרמטרים חסרים), העתיקו את הודעת השגיאה או את המטען הייעודי (payload).
    • חוזרים ל-Google AI Studio ומבקשים מהעוזר הדיגיטלי לתקן את הבעיה המתאימה בקוד האפליקציה.

8. אופציונלי: פריסת האפליקציה

עכשיו, כשהאפליקציה פועלת במצב תצוגה מקדימה, אפשר לפרוס אותה בסביבת הייצור.

כדי להגן על נקודות הקצה של Firebase בסביבת הייצור, צריך להגדיר ספק אימות בסביבת הייצור לשימוש עם Firebase App Check (ב-Codelab הזה תשתמשו ב-reCAPTCHA גרסה 3).

קודם צריך לפרוס את האפליקציה כדי לקבל את כתובת ה-URL הפעילה המדויקת שלה, כדי שתוכלו לרשום את הדומיין הספציפי ב-reCAPTCHA במקום לאפשר את כל האפליקציות של ai.studio.

פורסים את האפליקציה ומגדירים את reCAPTCHA:

  1. פורסים את אפליקציית האינטרנט באמצעות Google AI Studio:
    1. ב-Google AI Studio, לוחצים על Publish בסרגל הניווט העליון.
    2. לוחצים על שנתחיל?, בודקים או מתאימים אישית את השם והתיאור של האפליקציה ולוחצים על פרסום האפליקציה.
    3. ממתינים עד ש-Google AI Studio יבנה ויפרוס את האפליקציה (בדרך כלל דקה או שתיים).
    4. מעתיקים את כתובת ה-URL עם השם (vanity URL) שנוצרה (לדוגמה, https://decide-for-me-123.ai.studio) ורושמים את הדומיין שלה (לדוגמה, decide-for-me-123.ai.studio).
  2. יוצרים מפתחות של reCAPTCHA גרסה 3 ב-Google reCAPTCHA:
    1. נכנסים למסוף Google reCAPTCHA Admin.
    2. מזינים תווית (לדוגמה, Decide For Me - Production).
    3. בוחרים באפשרות reCAPTCHA type (סוג reCAPTCHA) > reCAPTCHA v3 (Score-based)‎ (reCAPTCHA גרסה 3 (מבוססת-ניקוד)).
    4. בקטע Domains, מוסיפים את הדומיין המדויק של האפליקציה שנפרסה (לדוגמה, decide-for-me-123.ai.studio, בלי https:// ונתיבים כלשהם) או דומיין מותאם אישית אם אתם מתכננים להשתמש בו.
    5. מאשרים את התנאים וההגבלות ולוחצים על שליחה.
    6. משאירים את הכרטיסייה הזו פתוחה: תצטרכו גם את מפתח האתר (מפתח לקוח ציבורי) וגם את המפתח הסודי (מפתח שרת פרטי).
  3. רושמים את המפתח הסודי במסוף Firebase:
    1. עוברים אל App Check במסוף Firebase.
    2. עוברים לכרטיסייה אפליקציות.
    3. מאתרים את אפליקציית האינטרנט ברשימה, לוחצים עליה (או על סמל האפשרויות הנוספות ⋮) ובוחרים באפשרות reCAPTCHA גרסה 3.
    4. מדביקים את המפתח הסודי של reCAPTCHA בשדה ולוחצים על שמירה.
  4. מגדירים את אפליקציית הלקוח כך שתשתמש ב-ReCaptchaV3Provider:
    1. ב-Google AI Studio, עוברים לחלונית הצ'אט ומבקשים מה-Assistant לעדכן את ההגדרות של App Check לסביבת הייצור:
      Please update our Firebase App Check initialization to use
      ReCaptchaV3Provider with the reCAPTCHA site key "YOUR_RECAPTCHA_SITE_KEY",
      while retaining support for debug tokens in non-production environments.
      
    2. אם אתם בודקים את הקוד ישירות בכרטיסייה קוד, ודאו שההפעלה של App Check תואמת למבנה הזה:
      import { initializeAppCheck, ReCaptchaV3Provider } from "firebase/app-check";
      
      const appCheck = initializeAppCheck(app, {
        provider: new ReCaptchaV3Provider("YOUR_RECAPTCHA_SITE_KEY"),
        isTokenAutoRefreshEnabled: true
      });
      
    3. אחרי שמעדכנים את הקוד, מפרסמים מחדש את האפליקציה ב-Google AI Studio כדי להעביר את ההגדרות המעודכנות של App Check לאתר הפעיל.
  5. מאמתים את התנועה בסביבת הייצור ועוקבים אחרי App Check:
    1. פותחים את כתובת ה-URL של האפליקציה הפעילה בחלון פרטי בדפדפן, נכנסים באמצעות חשבון Google ובודקים את שליחת הדילמה.
    2. חוזרים אל App Check במסוף Firebase, ובודקים את הכרטיסיות APIs ו-Monitoring כדי לוודא שהבקשות נרשמות בהצלחה ב-Firestore וב-Firebase AI Logic.

9. סיכום

מעולה! פיתחתם אפליקציה שימושית עם תכונות מבוססות-AI מאפס, באמצעות כלים ב-Builder Stack של Google. זו רק ההתחלה, ויש עוד הרבה דברים שאפשר לעשות עם הכלים של Google. עכשיו יש לכם פרויקט ב-Firebase וב-Google Cloud. אתם יכולים לבדוק את כל השירותים שזמינים לכם.

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

כדי להמשיך את המסע, עוברים אל goo.gle/builders לשיעור ה-Lab הבא.

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