WEBVTT

00:00:00.000 --> 00:00:03.280
שלום לכולם וברוכים הבאים לפרק נוסף של Microsoft Knowledge Nuggets,

00:00:03.400 --> 00:00:04.260
כאן ב-M365.

00:00:04.400 --> 00:00:06.180
אני המנחה שלכם, מרקו פיטרס.

00:00:06.320 --> 00:00:09.280
היום נעסוק במשהו שכל מי שעובד עם בינה מלאכותית שמע עליו,

00:00:09.440 --> 00:00:11.260
אבל כמעט אף אחד לא יודע להסביר בפשטות.

00:00:11.380 --> 00:00:13.860
זהו פרוטוקול הקשר המודל, או בקיצור, MCP.

00:00:14.000 --> 00:00:14.700
דמיינו את זה.

00:00:14.860 --> 00:00:18.380
אתם בטימס ושואלים את עוזר הבינה המלאכותית שלכם שאלה פשוטה כמו

00:00:18.380 --> 00:00:20.040
מה הסטטוס של פרויקט ג'ונסון?

00:00:20.200 --> 00:00:22.720
והוא עונה, אני מצטער, אין לי גישה למידע הזה.

00:00:30.000 --> 00:00:32.760
זו הבעיה המרכזית ש-MCP פותר.

00:00:32.920 --> 00:00:35.200
עד סוף הפרק הזה, תבינו מה זה באמת MCP,

00:00:35.420 --> 00:00:37.740
למה זה חשוב לכל מי שמשתמש במיקרוסופט 365,

00:00:38.300 --> 00:00:40.680
ואיך זה משנה את מה שבינה מלאכותית יכולה לעשות עבורכם.

00:00:40.820 --> 00:00:42.380
נפרק את זה לאבני בניין.

00:00:42.560 --> 00:00:46.260
הבעיה, הפתרון, איך זה עובד, ומה זה אומר בתוך מייקרוסופט.

00:00:46.360 --> 00:00:49.880
אז בואו נתחיל עם הבעיה, כי בטח כבר הרגשתם אותה בעצמכם.

00:00:50.580 --> 00:00:54.220
הבעיה, כל כלי בינה מלאכותית היה צריך להיבנות בהתאמה אישית.

00:00:54.220 --> 00:00:59.360
לפני ש-MCP היה קיים, אם רציתם שעוזר בינה מלאכותית יעשה מה שהוא מועיל לבדוק את היומן שלכם,

00:00:59.560 --> 00:01:02.300
ישלוף קובץ משרפוינט, יחפש רשומת לקוח בדיינמיקס,

00:01:02.380 --> 00:01:04.400
הייתם צריכים לכתוב קוד מותאם אישית לכל אחד.

00:01:04.540 --> 00:01:07.900
כל חיבור בנפרד, כל מקור נתונים בנפרד, קוד נפרד.

00:01:08.040 --> 00:01:08.760
הנה העניין.

00:01:08.940 --> 00:01:11.340
כל מערכת מדברת בשפת ה-API שלה.

00:01:11.460 --> 00:01:13.200
היומן שלכם משתמש בפורמט אחד,

00:01:13.200 --> 00:01:16.160
שרפוינט משתמש באחר, ודיינמיקס משתמש באחר.

00:01:16.160 --> 00:01:20.080
אימות שונה, חוקים שונים, דרכים שונות, לבקש נתונים ולקבל אותם חזרה.

00:01:20.220 --> 00:01:22.660
אם רציתם שהבינה המלאכותית שלכם תדבר עם שלוש מערכות,

00:01:22.860 --> 00:01:24.240
הייתם בונים שלושה ממשקים מותאמים אישית.

00:01:24.400 --> 00:01:25.300
חישבו על זה כך.

00:01:25.460 --> 00:01:28.900
דמיינו שאתם בסלון עם טלוויזיה, מערכת סטריאו ותאורה חכמה.

00:01:29.020 --> 00:01:33.100
כל אחד מגיע עם שלט רחוק משלו, ואף אחד מהשלטים לא עובד עם מכשיר אחר.

00:01:33.100 --> 00:01:36.680
אתם צריכים את שלט הטלוויזיה לטלוויזיה, את שלט הסטריאו לסטריאו,

00:01:36.680 --> 00:01:38.160
ואפליקציה נפרדת לאורות.

00:01:38.260 --> 00:01:40.820
כך נראו פיתוחי בינה מלאכותית לפני MCP.

00:01:40.960 --> 00:01:43.440
כל כלי היה זקוק לאינטגרציה מותאמת אישית משלו.

00:01:43.560 --> 00:01:46.000
עבור משתמשי מייקרוסופט, זה מרגיש קרוב מאוד הביתה.

00:01:46.080 --> 00:01:48.900
תחשבו על מה שקופילות מנסה לעשות כשאתם שואלים אותו שאלה.

00:01:49.000 --> 00:01:51.040
הוא עשוי לבדוק את יומן האקסצ'יינג שלכם לפגישות,

00:01:51.040 --> 00:01:53.320
לקרוא הודעות דואר אלקטרוני אחרונות מלקוח מסוים,

00:01:53.460 --> 00:01:54.920
או לחפש רשומת לקוח בדיינמיקס.

00:01:54.920 --> 00:01:57.660
אלו שלושה חיבורי API שונים, שלוש אינטגרציות נפרדות,

00:01:57.820 --> 00:01:59.580
כשכל אחת דורשת עבודת פיתוח מותאמת אישית.

00:01:59.760 --> 00:02:03.100
התוצאה, רוב כלי הבינה המלאכותית בחרו בדרך הקלה ונשארו גנריים.

00:02:03.320 --> 00:02:05.500
היית שואל שאלה על העבודה שלך, והאיי היה אומר,

00:02:05.680 --> 00:02:06.940
אני לא יכול לגשת לנתונים האלה.

00:02:07.020 --> 00:02:08.840
או, אני צריך שתגדיר חיבור קודם.

00:02:08.940 --> 00:02:11.320
אינטגרציה אמיתית דרשה פיתוח מותאם אישית יקר,

00:02:11.500 --> 00:02:13.060
ורוב הארגונים מעולם לא הגיעו לזה.

00:02:13.220 --> 00:02:14.820
עכשיו, הנה החלק המפתח.

00:02:14.820 --> 00:02:17.440
מודל השפה הגדול עצמו הוא עוצמתי להפליא.

00:02:17.520 --> 00:02:20.260
הוא יכול להסיק מסקנות, לסכם, לייצר ולנתח,

00:02:20.520 --> 00:02:22.860
אבל בלי גישה לנתונים האמיתיים שלך, הוא עיוור.

00:02:23.000 --> 00:02:26.340
זה כמו שיש לך את העוזר הכי חכם בעולם נעול בחדר בלי חלונות,

00:02:26.560 --> 00:02:29.940
הוא יכול לחשוב בצורה מבריקה, אבל הוא לא יכול לעזור לך בשום דבר אמיתי.

00:02:30.100 --> 00:02:32.740
הפתרון, MCP בתור תקא אוניברסלי.

00:02:32.860 --> 00:02:34.780
אז מה אם היה תקא אוניברסלי אחד?

00:02:34.780 --> 00:02:37.940
דרך סטנדרטית אחת לחבר כל איי לכל מקור נתונים,

00:02:38.080 --> 00:02:39.760
בלי לכתוב קוד מותאם לכל חיבור.

00:02:39.760 --> 00:02:42.020
הנה העניין, זה בדיוק מה שפרוטוקול הקשר המודל,

00:02:42.200 --> 00:02:44.360
Model Context Protocol, עושה, או MCP בקיצור.

00:02:44.520 --> 00:02:47.700
אנטרופיק, החברה מאחורי קלוד, הציגה אותו בסוף 2024,

00:02:48.240 --> 00:02:49.140
והוא תפס מהר מאוד.

00:02:49.320 --> 00:02:53.080
MCP הוא תקן פתוח שמגדיר דרך עקבית אחת עבור יישומי AI

00:02:53.080 --> 00:02:54.840
לתקשר עם כלים ומקורות נתונים.

00:02:55.040 --> 00:02:56.740
תחשבו על זה כמו USB-C.

00:02:56.940 --> 00:02:59.940
לפני USB-C, כל מכשיר היה צריך כבל מיוחד משלו.

00:02:59.940 --> 00:03:02.420
הטלפון שלך השתמש בסוג אחד, המחשב הנייד באחר,

00:03:02.520 --> 00:03:03.520
והאוזניות שלך בשלישי.

00:03:03.520 --> 00:03:06.000
הייתה לך מגירה מלאה בכבלים, ואף פעם לא מצאתה את הנכון.

00:03:06.120 --> 00:03:09.260
ואז הגיע ה-USBC, כבל אחד, תקן אחד, והכל פשוט עובד.

00:03:09.380 --> 00:03:11.620
MCP עושה את אותו הדבר עבור חיבורי AI.

00:03:11.800 --> 00:03:13.600
פרוטוקול אחד עובד עבור מסדי נתונים,

00:03:13.800 --> 00:03:17.140
מערכות קבצים, ממשקי API, וכן, אפילו שירותי מייקרוסופט.

00:03:17.220 --> 00:03:19.720
במקום לבנות מחברים מותאמים לכל מקור נתונים,

00:03:19.980 --> 00:03:24.020
בונים שרת MCP אחד, וכל אפליקציית AI תואמת יכולה להשתמש בו.

00:03:24.020 --> 00:03:25.300
האימוץ קרה מהר.

00:03:25.300 --> 00:03:28.660
תוך חודשים, אלפי שרתי MCP מוכנים מראש הופיעו עבור

00:03:28.660 --> 00:03:32.620
Google Drive, GitHub, Slack, ומסדי נתונים כמו PostgreSQL וSQLi.

00:03:32.800 --> 00:03:35.720
ועבור משתמשי מייקרוסופט, כאן זה נהיה ממש מעניין.

00:03:35.880 --> 00:03:38.400
כלי ה-AI שלך יכולים כעת להתחבר לשארפוינט,

00:03:38.500 --> 00:03:40.420
אקשיינג, דיינמיקס ופאור פלטפורם.

00:03:40.560 --> 00:03:41.900
הכל דרך אותו ממשק סטנדרטי.

00:03:42.000 --> 00:03:44.540
בשורה התחתונה, אתה כבר לא בונה חיבורים מותאמים אישית.

00:03:44.540 --> 00:03:48.160
אתה מתחבר ל-MCP, פרוטוקול אחד, כל מקור נתונים, כל אפליקציית AI.

00:03:48.160 --> 00:03:49.320
זה הכסם שבדבר.

00:03:49.500 --> 00:03:52.200
הארכיטקטורה, מערך, הוסט, לקוח, קליינט, בשרת, סרוואר.

00:03:52.300 --> 00:03:54.060
אז איך זה בעצם עובד מאחורי הקלעים?

00:03:54.180 --> 00:03:55.160
תן לי לפרק את זה.

00:03:55.320 --> 00:03:59.100
MCP משתמש בהגדרה פשוטה בעלת שלושה חלקים, מערך, לקוח ושרה.

00:03:59.300 --> 00:04:02.180
ברגע שמבינים את שלושת החלקים האלה, כל התמונה מתחברת.

00:04:02.320 --> 00:04:04.880
המערך הוא אפליקציית AI שאתה משתמש בה בפועל.

00:04:04.880 --> 00:04:09.600
זה יכול להיות קופיילוט במיקרוסופט 365, קלו דסקטופ, או סוכן מותאם אישית שבנית בעצמך.

00:04:09.600 --> 00:04:11.860
המערך הוא המקום שבו אתה שואל את שאלתך.

00:04:12.000 --> 00:04:13.460
זהו החלק שפונה למשתמש.

00:04:13.640 --> 00:04:16.560
בתוך המערך הזה נמצא משהו שנקרא לקוח MCP.

00:04:16.720 --> 00:04:18.800
זהו החלק שמדבר את פרוטוקול ה-MCP.

00:04:18.980 --> 00:04:23.620
אתה לא רואה אותו או מקיים איתו אינטראקציה ישירה, אבל הוא המתורגמן, החלק שיודע לדבר עם שרתי MCP.

00:04:23.740 --> 00:04:25.260
לאחר מכן יש לך את השרת.

00:04:25.260 --> 00:04:30.540
שרת ה-MCP הוא תוכנית קלה שיושבת בין ניסום ה-AI שלך לבין מקור הנתונים האמיתי שלך.

00:04:30.660 --> 00:04:33.180
הוא חושף כלים ומשווים שה-AI יכול להשתמש בהם.

00:04:33.180 --> 00:04:37.200
השרת יודע איך להגיע לאתר ה-SharePoint שלך, לטבעת הדואר ב-Exchange ולמסד הנתונים בדיינמיקס.

00:04:37.320 --> 00:04:39.420
ה-AI לא צריך לדעת אף אחד מהפרטים האלו.

00:04:39.500 --> 00:04:40.740
הוא פשוט מדבר עם השרת.

00:04:40.920 --> 00:04:42.520
הנה האופן שבו הנתונים זורמים.

00:04:42.720 --> 00:04:46.580
כשאתה שואל את ה-AI שלך שאלה, הבקשה עוברת מהמערך ללקוח ה-MCP.

00:04:46.800 --> 00:04:49.400
הלקוח שולח הודעה דרך פרוטוקול ה-MCP לשרת.

00:04:49.400 --> 00:04:53.380
השרת ניגש למקור הנתונים שלך, משיג את מה שאתה צריך, ושולח את זה בחזרה.

00:04:53.540 --> 00:04:56.040
מערך ללקוח לפרוטוקול לשרת לנתונים שלך.

00:04:56.040 --> 00:04:57.640
נקי, פשוט ומתוקנן.

00:04:57.780 --> 00:04:59.140
תחשוב על זה כמו על מסעדה.

00:04:59.220 --> 00:05:01.060
המערך הוא אתה שיושב ליד השולחן.

00:05:01.220 --> 00:05:04.340
לקוח ה-MCP הוא המלצר שלוקח את ההזמנה שלך ומביא אותה למטבח.

00:05:04.500 --> 00:05:06.420
ושרת ה-MCP הוא המטבח עצמו.

00:05:06.560 --> 00:05:08.380
אתה לא צריך לדעת איך המטבח עובד.

00:05:08.540 --> 00:05:11.180
אתה רק אומר למלצר מה אתה רוצה, והאוכל מופיע.

00:05:11.180 --> 00:05:14.140
מערך אחד יכול להתחבר למספר שרתים בו זמנית.

00:05:14.300 --> 00:05:17.360
כך, ה-AI שלך בטימס יכול להגיע למסמכי ה-SharePoint,

00:05:17.360 --> 00:05:19.920
ליומן האקסצ'יינג' ולרשומות הדיינמיקס שלך,

00:05:20.060 --> 00:05:20.860
הכל בשיחה אחת.

00:05:20.940 --> 00:05:24.900
התקשורת בין הלקוח לשרת משתמשת במה שהוא שנקרא JSON-RPC.

00:05:25.100 --> 00:05:28.120
פשוט דרך קלה וסטנדרטית לשלוח הודעות הלוך ושוב.

00:05:28.320 --> 00:05:30.740
ללא תקור הכבדה, ללא חיבות מותאם אישית.

00:05:30.740 --> 00:05:34.900
מה שרתי-MCP מכילים, כלים, משאבים והנחיות PROMAPTS?

00:05:35.000 --> 00:05:38.300
אז, מה שרת-MCP באמת נותן ל-AI כשהם מתחברים?

00:05:38.500 --> 00:05:41.360
שלושה דברים, כלים, משאבים ותבניות הנחיה.

00:05:41.500 --> 00:05:45.440
תחשוב עליהם כעל ערכת הכלים שה-AI נעזר בה כשהוא צריך לבצע משהו.

00:05:45.640 --> 00:05:47.260
בואו נפרק את זה לשפה פשוטה.

00:05:47.400 --> 00:05:48.320
ראשית, כלים.

00:05:48.500 --> 00:05:52.200
כלים הם פעולות שה-AI יכול לבצע שבאמת משנות דברים בעולם האמיתי.

00:05:52.360 --> 00:05:55.860
כלי עשוי לחפש במסד נתונים, לשלוח אימייל או ליצור מסמך.

00:05:55.860 --> 00:05:58.540
בכל פעם שה-AI מפעיל כלי, מה שהוא קורא.

00:05:58.640 --> 00:06:01.760
קובץ נשמר, הודעה נשלחת, רשומה מתעדכנת.

00:06:01.880 --> 00:06:03.540
כלים הם הפעלים של המערכת.

00:06:03.700 --> 00:06:04.940
הם מה שגורם לדברים לקרות.

00:06:05.120 --> 00:06:06.080
עכשיו, משאבים.

00:06:06.080 --> 00:06:08.960
משאבים הם מידע לקריאה בלבד שה-AI יכול להסתכל עליו.

00:06:09.080 --> 00:06:11.180
משאב יכול להיות רשימת לקוחות מדיינמיקס,

00:06:11.360 --> 00:06:14.280
מסמך מדיניות בשארפוינט או סיכומי פגישות מתקאמס.

00:06:14.400 --> 00:06:17.080
הבינה המלאכותית יכולה לקרוא אותם, לנתח אותם ולהתייחס עליהם,

00:06:17.200 --> 00:06:18.840
אך אינה יכולה לשנות אותם ישירות דרך משאב.

00:06:18.840 --> 00:06:21.820
הם פשוט מעניקים לבינה המלאכותית את ההקשר הדרוש לה כדי לעבוד בצורה חכמה יותר.

00:06:21.960 --> 00:06:24.240
לאחר מכן יש לך תבניות הנחיה, פרומפט טמפלאצס.

00:06:24.240 --> 00:06:26.480
אלו הוראות מובנות מראש שחוסכות לך זמן.

00:06:26.660 --> 00:06:29.240
במקום לנסח את ההנחיה המושלמת בכל פעם מחדש,

00:06:29.460 --> 00:06:31.480
השרת מגיש לך אחת שכבר עברה אופטימיזציה.

00:06:31.640 --> 00:06:35.840
למשל, שרת MCP של שירפוינט עשוי לכלול תבנית לסיכום תוכן של תיקייה.

00:06:35.840 --> 00:06:38.040
אתה פשוט אומר, סכם את התיקייה הזו.

00:06:38.140 --> 00:06:39.940
והתבנית מטפלת בכל השאר.

00:06:40.060 --> 00:06:43.300
זה כמו להחזיק קיצור דרך יהודי לדברים שאתה עושה שוב ושוב.

00:06:43.460 --> 00:06:45.540
הנה דוגמה מוחשית כדי לחבר את הכל.

00:06:45.540 --> 00:06:47.760
דמיין שרת MCP של שירפוינט.

00:06:47.920 --> 00:06:51.440
הוא מציע כלי בשם חיפוש מסמכים שמוצא קבצים לפי מילת מפתח.

00:06:51.620 --> 00:06:56.860
הוא מציע משאב בשם רשימת אתרים שמעניק גישת קריאה בלבד לכל אתרי שירפוינט הזמינים.

00:06:56.860 --> 00:07:02.520
והוא כולל תבנית הנחיה בשם סיכום תוכן תיקייה שאומרת לבינה המלאכותית בדיוק איך להציג סיכום נקי.

00:07:02.620 --> 00:07:06.760
כל מה שהבינה המלאכותית צריכה כדי לעזור לחיים שירפוינט נמצא ממש שם במקום אחד.

00:07:06.920 --> 00:07:08.440
עכשיו, הנה החלק המגניב.

00:07:08.440 --> 00:07:11.880
הבינה המלאכותית מגלה את כל זה אוטומטית כשהיא מתחברת לשרת.

00:07:12.060 --> 00:07:13.520
אין צורך בתכנות מוקדם.

00:07:13.680 --> 00:07:15.340
השרת בעצם מציג את עצמו.

00:07:15.500 --> 00:07:18.780
הנה הכלים שלי, המשאבים שלי, תבניות ההנחיה שלי.

00:07:18.940 --> 00:07:21.140
והבינה המלאכותית מבינה איך להשתמש בהם.

00:07:21.140 --> 00:07:23.100
זה מה שהופך את MCP לעוצמתי.

00:07:23.200 --> 00:07:26.080
השרת אומר לבינה המלאכותית מה אפשרי, והיא מטפלת בשאר.

00:07:26.220 --> 00:07:27.620
זו מערכת שמתארת את עצמה.

00:07:27.780 --> 00:07:31.880
שלוש הקטגוריות הללו עובדות יחד כך שלבינה המלאכותית יש תמונה מלאה של מה שהיא יכולה לעשות.

00:07:31.880 --> 00:07:34.480
MCP פוגש את מה שכבר קיים במייקרוסופט.

00:07:34.520 --> 00:07:36.580
אז, בואו נביא את זה לעולם של מייקרוסופט.

00:07:36.640 --> 00:07:40.100
כאן זה הופך לאמיתי עבור כל מי שמשתמש במיקרוסופט 365 או באז'ר.

00:07:40.240 --> 00:07:41.860
בואו ננפץ מיתוס נפוץ כבר עכשיו.

00:07:41.860 --> 00:07:44.780
יש אנשים שחושבים ש-MCP הוא רק ניסוי צדדי של מייקרוסופט.

00:07:44.860 --> 00:07:45.580
זה לא המצב.

00:07:45.760 --> 00:07:46.900
זהו כיוון הסטרטגי.

00:07:47.020 --> 00:07:49.680
ניתן לראות זאת בבירור בשירות ה-AI-אג'נט של אז'ור.

00:07:49.800 --> 00:07:52.080
אם אתה בונה סוכני בינה מלאכותית מותאמים באז'ור,

00:07:52.080 --> 00:07:55.660
כעת ניתן להוסיף שרתי MCP מרוחקים ישירות מתוך Azure Eye Foundry.

00:07:55.820 --> 00:07:59.100
מגדירים תווית שרת, כתובת URL וחותרות עימות אופציונליות,

00:07:59.280 --> 00:08:01.760
והסוכן שלך יכול להתחיל להפעיל כלים מהשרת הזה.

00:08:01.760 --> 00:08:05.000
הטיעוד של מייקרוסופט עצמה מכנה זאת אינטגרציה מהדרגה הראשונה.

00:08:05.160 --> 00:08:08.420
זו לא שפה של פרויקט צדדי, אבל זה הולך עמוק יותר מ-Azure בלבד.

00:08:08.540 --> 00:08:11.900
מייקרוסופט פרסמה התייחסויות רשמיות לשרתי MCP עבור הפארר פלטפורם,

00:08:12.040 --> 00:08:14.480
כולל Power Automate, Power Apps ואפילו Process Mining.

00:08:22.260 --> 00:08:23.600
הנה מה שזה אומר בפועל.

00:08:23.760 --> 00:08:28.060
בינה מלאכותית יכולה לקחת כלת לא מובנה, כמו אימייל, הודעת צ'אט או מסמך שרוק,

00:08:28.280 --> 00:08:30.200
ולהפוך אותו לרשומה מובנית בדטאברס.

00:08:30.320 --> 00:08:32.780
הבינה המלאכותית מציעה את הרשומה, ואתה מאשר אותה.

00:08:32.780 --> 00:08:34.680
מעורבות אנושית מובנית ישירות בתהליך.

00:08:34.780 --> 00:08:37.400
שרת ה-MCP של Power Automate לוקח את זה צעד אחד קדימה.

00:08:37.480 --> 00:08:39.340
אתה מתאר זרימת עבודה בשפה פשוטה,

00:08:39.440 --> 00:08:42.400
משהו כמו כאשר מגיע אימייל חדש עם המילה, דחוף בנושא,

00:08:42.400 --> 00:08:44.620
צור משימה בפלנר ושלח התראה למנהל שלי.

00:08:44.740 --> 00:08:46.800
הבינה המלאכותית בונה את הזרימה הזו עבורך.

00:08:46.920 --> 00:08:48.560
ללא גרירה ושחרור של מחברים.

00:08:48.760 --> 00:08:50.020
ללא חיפוש אחר טריגרים.

00:08:50.200 --> 00:08:51.360
פשוט תאר מה אתה רוצה.

00:08:51.360 --> 00:08:53.980
ושרת ה-MCP מתרגם את זה לאוטומציה ממשית.

00:08:54.140 --> 00:08:58.020
מייקרוסופט הציגה גם שרתי MCP עבור תוכן של Microsoft Learn.

00:08:58.200 --> 00:09:02.920
דמיין סוכן בינה מלאכותית ששואל את כל ספריית התיעוד של מייקרוסופט כמשאב.

00:09:03.100 --> 00:09:04.540
לא גרידת דפי אינטרנט,

00:09:04.540 --> 00:09:08.600
אלא דרך שרת MCP מובנה שחושף תיעוד כנתונים מובנים.

00:09:08.800 --> 00:09:09.820
זה כבר עובד היום.

00:09:10.040 --> 00:09:12.380
זה הכיוון שאליו הולכים כלי המייקרוסופט שלך.

00:09:12.380 --> 00:09:15.160
הם הופכים לנגישים ל-MCP כחלק מהתכנון שלהם.

00:09:15.260 --> 00:09:16.220
הפלטפורמה נפתחת.

00:09:16.280 --> 00:09:20.140
וככל שזה קורה, חוויית המיקרוסופט 365 שלך רק תהפוך לחכמה יותר.

00:09:20.320 --> 00:09:23.220
האינטגרציה מתרחשת עכשיו, והיא מובנית ביסודות המערכת.

00:09:23.360 --> 00:09:24.960
MCP הוא לא רק למפתחים.

00:09:24.960 --> 00:09:30.860
הוא מיועד לכל מי שמשתמש במיקרוסופט 365 ורוצה שהבינה המלאכותית שלו תעבוד בצורה חלקה עם הנתונים שלו.

00:09:31.040 --> 00:09:31.860
תרחיש אמיתי.

00:09:32.040 --> 00:09:34.120
הבינה המלאכותית שסוף סוף עובדת.

00:09:34.520 --> 00:09:35.960
אז איך זה נראה בפועל?

00:09:36.180 --> 00:09:37.840
תן לי לעבור על דוגמה אמיתית.

00:09:37.960 --> 00:09:41.080
אתה יושב במיקרוסופט Teams ומקליד את זה לקופילות.

00:09:41.280 --> 00:09:44.720
מה הסטטוס של פרויקט אקמי ומי בפיגור עם המשימות שלו?

00:09:44.860 --> 00:09:45.880
אתה לוחץ על Enter.

00:09:46.620 --> 00:09:50.480
כעת, מאחורי הקלעים, קורה משהו שונה ממה שהיה קורה לפני שנה.

00:09:50.480 --> 00:09:55.160
עוזר הבינה המלאכותית של איך מתחבר לשרת MCP המקושר לפרויקט אונליין או לפלנר.

00:09:55.300 --> 00:09:58.100
השרת הזה מפרסמת הכלים שהוא יכול להשתמש בהם.

00:09:58.160 --> 00:10:03.080
דברים כמו רשימת משימות, קבלת סטטוס משימה, בדיקת הקצאות וקבלת לוח זמנים של פרויקט.

00:10:03.220 --> 00:10:05.620
הבינה המלאכותית לא צריכה שום הכוונה כאן.

00:10:05.760 --> 00:10:09.860
היא מגלה את הכלים האלה אוטומטית כי השרת פשוט אומר, הנה מה שאני יכול לעשות.

00:10:09.960 --> 00:10:12.420
והבינה המלאכותית משיבה, מעולה, השתמש בזה.

00:10:12.420 --> 00:10:15.940
אף אחד לא צריך להגיד, היי, לך תסתכל על נקודת הקצה הזו של ה-API קודם.

00:10:16.040 --> 00:10:16.940
וזה פשוט עובד.

00:10:17.060 --> 00:10:19.740
אז, הבינה המלאכותית קוראת לכלי רשימת המשימות.

00:10:19.920 --> 00:10:22.820
אחר כך מקבלת סטטוס עבור כל משימה, ואז בודקת הקצאות.

00:10:22.980 --> 00:10:26.420
שרת ה-MCP מטפל בכל האימות ושליפת הנתונים מאחורי הקלעים.

00:10:26.580 --> 00:10:29.600
כמה שניות לאחר מכן, הבינה המלאכותית חוזרת עם תשובה ברורה.

00:10:29.740 --> 00:10:31.380
פרויקט אקמי במסלול הנכון.

00:10:31.540 --> 00:10:34.220
ישנן שלוש משימות באיחור, כולן הוקצו לשרה.

00:10:34.220 --> 00:10:36.100
האם תרצה שהשלח לה תזכורת?

00:10:36.520 --> 00:10:37.520
הנה מה שחשוב.

00:10:37.700 --> 00:10:40.080
לא נכתב קוד מותאם אישית עבור שאילתה זו.

00:10:40.180 --> 00:10:44.200
אף מפתח לא השקיע שבועיים בבניית חיבור בין קופיילוט לפרויקט אונליין.

00:10:44.420 --> 00:10:46.660
שרת ה-MCP טיפל באינטגרציה כולה.

00:10:46.800 --> 00:10:50.480
שרת אחד, פרוטוקול סטנדרטי אחד, וה-AI ידע בדיוק איך להשתמש בו.

00:10:50.580 --> 00:10:52.500
כעת, בואו ניקח את זה צעד קדימה.

00:10:52.620 --> 00:10:54.820
לאחר קבלת מצב הפרויקט, אתם שואלים,

00:10:54.820 --> 00:10:59.060
בדוק ביומן שלי פגישה עם שרה מחר ונסח עדכון סטטוס על סמך מה שקורה.

00:10:59.220 --> 00:11:01.540
ה-AI משתמש בשרת MCP של אקסצ'יינג'

00:11:01.600 --> 00:11:04.760
כדי לבדוק את היומן, מחפש הודעות אימייל קשורות דרך אותו שרת,

00:11:04.980 --> 00:11:07.940
ואז קורא לשרת MCP של וורד כדי לנסח את העדכון.

00:11:08.120 --> 00:11:11.500
שיחה אחת, מקורות מידע מרובים, אפס פיתוח מותאם אישית.

00:11:11.640 --> 00:11:13.580
זה רגע האוריקה עם MCP.

00:11:13.760 --> 00:11:17.200
זה הופך את ה-AI לשימושי בתוך סביבת העבודה האמיתית שלכם,

00:11:17.200 --> 00:11:20.320
לא רק צ'אדבוט גנרי שיכול לענות רק על שאלות כלליות,

00:11:20.560 --> 00:11:22.380
אלא עוזר שרואה את הנתונים שלכם,

00:11:22.560 --> 00:11:26.040
מבין את ההקשר שלכם ונוקט פעולה הכל דרך תקן פשוט אחד.

00:11:26.180 --> 00:11:28.340
הבטחה, שמירה על המידע שלכם.

00:11:28.480 --> 00:11:30.580
כל הגמישות הזו מעלה שאלה גדולה.

00:11:30.680 --> 00:11:33.220
אם ה-AI שלכם יכול פתאום לגשת לשארה פוינט,

00:11:33.340 --> 00:11:35.300
אקסצ'יינג' ודיינמיקס דרך MCP,

00:11:35.560 --> 00:11:36.820
איך שומרים על המידע הזה בטוח?

00:11:36.820 --> 00:11:38.100
הנה התשובה הקצרה.

00:11:38.240 --> 00:11:40.600
MCP מאובטח בדיוק כפי שאתם הופכים אותו לחזה.

00:11:40.720 --> 00:11:43.420
הפרוטוקול אינו עוקף את אמצעי ההבטחה הקיימים שלכם.

00:11:43.540 --> 00:11:44.260
הוא עובד איתם.

00:11:44.420 --> 00:11:46.580
MCP תומך באוף 2.1,

00:11:46.820 --> 00:11:49.860
אותו תקן עימות בתעשייה שמגן על כניסת המייקרוסופט שלכם.

00:11:50.020 --> 00:11:51.760
כאשר שרת MCP דורש עימות,

00:11:51.980 --> 00:11:55.780
לכוח ה-AI שלכם חייב להוכיח שהוא מורשה לפני שהוא יכול לגשת למידע כלשהו.

00:11:55.940 --> 00:11:57.500
שרתים יכולים להשתמש בחותרות עימות,

00:11:57.620 --> 00:11:59.620
מפתחות API או גישה מבוססת הסימונים.

00:11:59.620 --> 00:12:02.520
אותם דפוסים שאתם כבר מכירים להבטחת ממשקי API,

00:12:02.720 --> 00:12:05.360
אבל יש שכבה נוספת שחשובה מאוד לשימוש ארגוני.

00:12:05.520 --> 00:12:09.060
ה-AI חייב לבקש רשות תחילה לפני שהוא יכול באמת להריץ חיפוש,

00:12:09.260 --> 00:12:10.760
לשלוח הודעה או לשנות רשומה.

00:12:10.860 --> 00:12:11.740
הוא מבקש מכם.

00:12:11.900 --> 00:12:14.260
אתם רואים את הבקשה ישירות בממשק הצ'אט שלכם.

00:12:14.400 --> 00:12:15.760
אתם בוחנים מה הכלי יעשה,

00:12:15.940 --> 00:12:17.220
ואתם מאשרים או דוחים זאת.

00:12:17.300 --> 00:12:19.960
זה אומר ששום כלי לא מופעל ללא הסכמתכם המפורשת.

00:12:19.960 --> 00:12:21.640
ה-AI שלכם יכול להציע פעולות,

00:12:21.780 --> 00:12:23.500
אך הוא לא יכול לבצע אותן מבלי שתגידו,

00:12:23.600 --> 00:12:25.160
כן, זו רשת ביטחון טובה.

00:12:25.160 --> 00:12:26.920
דבר אחד שצריך להיזהר ממנו.

00:12:27.040 --> 00:12:29.160
קיימים אלפי שרתי MCP ציבוריים,

00:12:29.380 --> 00:12:30.220
ולא כולם אמינים.

00:12:30.380 --> 00:12:33.140
ישנם מאגרים ציבוריים שבהם כל אחד יכול לפרסם שרת.

00:12:33.340 --> 00:12:34.860
חלקם מצוינים, חלקם לא.

00:12:35.040 --> 00:12:37.800
האחריות היא עליכם להשתמש בשרתים שאתם בותחים בהם.

00:12:37.940 --> 00:12:39.940
בסביבות מייקרוסופט, יש לכם יתרון.

00:12:39.940 --> 00:12:45.060
שרתי ה-MCP שלכם יכולים להשתמש באותם בקרות זהות וגישה כמו שירותי המייקרוסופט הקיימים שלכם.

00:12:45.180 --> 00:12:48.300
אם למשתמש אין הרשאה לקרוא ספריית מסמכים בשרפוינט,

00:12:48.300 --> 00:12:50.180
שרת MCP לא יכול לעקוף זאת.

00:12:50.260 --> 00:12:54.440
השרת יורשת אותן גבולות, אותה אימות, אותן מדיניות ואותו ממשל.

00:12:54.600 --> 00:12:57.160
מתחילים חוויית ה-MCP הראשונה שלכם.

00:12:57.280 --> 00:12:59.560
אז השתכנתם ואתם רוצים לנסות זאת בעצמכם.

00:12:59.720 --> 00:13:03.220
מאיפה מתחילים, הדרך הקלה ביותר היא לבחור מערך התואם ל-MCP.

00:13:03.220 --> 00:13:06.860
לקלאוד דסקטופ יש תמיכה מובנית ב-MCP וגם GitHub Copilot עובד.

00:13:06.980 --> 00:13:09.440
שניהם מאפשרים לכם לחבר שרתים כמעט ללא הגדרה.

00:13:09.580 --> 00:13:12.140
לאחר מכן, בדקו את מאגרי ה-MCP הציבוריים.

00:13:12.140 --> 00:13:18.440
יש אלפי שרתים מוכנים מראש לשירותים כמו Google Drive, Slack, מסדי נתונים, מערכות קבצים וכן גם שירותי מייקרוסופט.

00:13:18.520 --> 00:13:23.240
אם אתם משתמשי מייקרוסופט, התחילו עם הפניות ה-MCP של מייקרוסופט עצמה עבור Power Platform.

00:13:23.440 --> 00:13:24.360
ההגדרה פשוטה.

00:13:24.360 --> 00:13:27.720
רוב המערכים משתמשים בקובץ JSON שבו אתם מפרטים את השרתים שלכם.

00:13:27.820 --> 00:13:32.880
אתם נותנים לכל אחד שם, מספקים את הפקודה או ה-URL כדי להגיע אליו ומגדירים אישורי אימות כלשהם.

00:13:33.000 --> 00:13:35.200
זה הכל והמערך מטפל בכל השאר.

00:13:35.200 --> 00:13:39.420
לא נדרש תכנות לשימוש בסיסי, כך שלא צריך להיות מפתח או לכתוב קוד אינטגרציה.

00:13:39.540 --> 00:13:43.960
פשוט מגדירים קובץ JSON, ופתאום ה-AI שלכם יכול לגשת לנתונים שלא היה יכול לגעת בהם קודם.

00:13:44.080 --> 00:13:47.960
קובץ ה-JSON הוא כמו קובץ הגדרות שאומר למערך שלכם לאילו שרתים להתחבר.

00:13:47.960 --> 00:13:51.380
חישבו על MCP כמתרגם אוניברסלי עבור ה-AI שלכם.

00:13:51.480 --> 00:13:54.800
במקום ללמוד שפה שונה לכל שירות, הוא דובר פרוטוקול אחד.

00:13:54.800 --> 00:13:59.840
התחילו בקטן על ידי חיבור מקור נתונים אחד, כמו היומן שלכם דרך שרת MCP של אקסצ'יינג'.

00:13:59.840 --> 00:14:03.460
ואז שאלו את ה-AI שעלה על הלוז שלכם וצפו איך הוא מגלה את הכלים הזמינים.

00:14:03.620 --> 00:14:08.940
בדקו את אישור האדם בלולאה, מה שאומר שאתם צריכים לאשר כל פעולה לפני שה-AI מבצע אותה.

00:14:08.940 --> 00:14:13.080
זה משאיר אתכם בשליטה, ווודאו שאתם מבינים את מודל ההבטחה לפני שמרחיבים.

00:14:13.240 --> 00:14:17.380
ברגע שאתם מרגישים בנוח, הרחיבו על ידי הוספת שרת נוסף עבור ספריית המסמכים שלכם,

00:14:17.540 --> 00:14:18.940
ואז מערכת ניהול המשימות שלכם.

00:14:19.060 --> 00:14:22.400
כל שרת מוסיף יכולות חדשות, וכל אחד עוקב אחר אותו פרוטוקול.

00:14:22.560 --> 00:14:27.460
אם אתם רוצים לבנות שרת MCP משלכם, אולי כדי לחשוף אפליקציה עסקית מותאמת אישית או מסד נתונים פנימי,

00:14:27.460 --> 00:14:30.020
ה-Azure Functions של מייקרוסופט עובדים מצוין כ-back-end.

00:14:30.140 --> 00:14:35.000
אתם עוטפים את ה-API או מקור הנתונים הקיים שלכם בשרת MCP עם כמה שורות קוד בלבד.

00:14:43.080 --> 00:14:44.640
תגישה לי מקורות הנתונים שלכם.

00:14:44.760 --> 00:14:46.720
אז זה המודל קונטקסט פרוטוקול.

00:14:46.860 --> 00:14:50.100
תקן אחד של לבסוף מאפשר לכלי AI להגיע לנתונים האמיתיים שלכם.

00:14:50.220 --> 00:14:53.360
קבצי השרפוינט שלכם, יומן האקשיינג שלכם, רשומות הדיינמיקס שלכם.

00:14:53.460 --> 00:14:56.360
לפני MCP, הייתם צריכים לבנות חיבורים מותאמים אישית לכל מערכת.

00:14:56.360 --> 00:14:59.680
עכשיו מתחברים לפרוטוקול אחד והבינה המלאכותית שלכם יכולה לדבר עם כולן.

00:14:59.780 --> 00:15:02.660
הבינה המלאכותית הופכת לשימושית בתוך סביבת העבודה האמיתית שלכם.

00:15:02.660 --> 00:15:05.920
זו לא רק נוחות, זה משנה את הדרך שבה אתם עובדים עם בינה מלאכותית.

00:15:06.020 --> 00:15:10.320
התחילו עם שרת MCP1, חברו מקור נתונים יחיד וראו את ההבדל בעצמכם.

00:15:10.480 --> 00:15:14.940
אם זה היה מועיל, שתפו עם עמית שמתקשה עם בינה מלאכותית שלא יכולה לגשת לנתונים שלו.

00:15:14.940 --> 00:15:16.980
הרשמו לעוד טיפים ומידע מהסוג הזה.

00:15:17.120 --> 00:15:19.480
אני מרקו פיטרס, ואראה אתכם בפרק הבא.
