Integrating your bots and Copilot experiences natively into SharePoint and Viva | BRK144

Summary

このビデオスクリプトは、Microsoft SharePointとViva Connectionsへの新しいCo-Pilot機能の統合について紹介しています。CJ Tanをはじめとするチームは、ゼロコードでカスタマイズ可能なCo-Pilotを作成し、SharePointサイトやドキュメントライブラリに応じた機能を提供します。さらに、Co-Pilot Studioを通じてさらに高度なカスタマイズが可能で、Viva Connections経由でモバイルファーストのユーザーにも情報を提供します。また、SharePoint EmbeddedアプリケーションへのカスタムCo-Pilotの統合も紹介されています。これにより、開発者は独自のアプリケーションにAIを組み込み、ユーザーはMicrosoft 365 Co-Pilot内で情報を操作できます。

Takeaways

• 😀 SharePointとOneDriveに新しいコパイロット機能が追加され、チーム内でのコミュニケーションと情報を共有するのに役立つと期待されています。
• 👥 CJ Tan、Luca Bandinelli、Mark Windel、Chris Whittenがそれぞれの専門分野から新しいコパイロット機能について紹介しています。
• 🔧 'Click to CoPilot' 機能を使うと、SharePoint内でコードなしでカスタムコパイロットを作成・拡張することが可能です。
• 📚 SharePointは組織の知識を保存する場所であり、チームが共同で作成するアセットを含んでいます。
• 🎯 カスタムコパイロットは特定の目的に合わせてチームを支援するため、Microsoft Chatの力をサイト、ドキュメント、フォルダ、またはライブラリに絞り込むことができます。
• 🛠️ SharePointの新しいエントリーポイントからコパイロットを操作し、サイトオーナーはデフォルトのコパイロットを設定することができます。
• 🗣️ Teams内でコパイロットと対話することができるだけでなく、SharePointサイト上でも相互作用が可能です。
• 🌐 SharePointからカスタムコパイロットを作成し、それをTeamsやメールで共有することが可能です。
• 🔄 デモでは、SharePointサイトからの組み込みコパイロットの開始点として機能するデモンストレーションが行われています。
• 📈 また、ファイル選択からカスタムコパイロットを作成し、それをCopilot Studioで拡張するプロセスも紹介されています。

Q & A

SharePointとViva Connectionsへのコパイロットの統合とは何ですか？

SharePointとViva Connectionsへのコパイロットの統合は、SharePointとViva Connectionsのプラットフォームに新しい機能を追加し、チームで共同作業を行う際にサポートするカスタムコパイロットを作成・拡張するプロセスです。これにより、コードを記述することなく、SharePoint内の特定のサイト、ドキュメント、フォルダ、またはドキュメントライブラリに焦点を当てたカスタムコパイロットを作成できます。

Click to CoPilotはどのような機能ですか？

Click to CoPilotは、SharePoint内でカスタムコパイロットを作成するプロセスを簡素化する機能です。これにより、組織内の全ユーザーが管理者や開発者でなくても、SharePointからカスタムコパイロットを作成してチームの生産性を向上させることができます。

SharePoint Embeddedとは何ですか？

SharePoint Embeddedは、開発者がSharePointのストレージ機能をカスタムアプリケーションに埋め込む方法です。これにより、開発者はコンテンツ管理のコア機能、アクセス許可、ファイル管理などを自分でコーディングする必要なしに、カスタムアプリケーションを構築できます。

Viva Connectionsにおけるコパイロットのロールは何ですか？

Viva Connectionsにおいては、コパイロットがモバイルデバイスを使用している従業員やフロントラインワーカーに対して、企業の情報を直接提供する役割を果たします。これにより、ユーザーはデスクトップではなく、モバイルデバイスを通じて必要な情報を得ることができます。

カスタムコパイロットを作成する際に利用できるインターフェースはありますか？

はい、カスタムコパイロットを作成する際には、SharePointサイト内からのエントリーポイントと、選択したコンテンツからのエントリーポイントの2つの方法があります。これにより、ユーザーは異なるニーズに応じて最も適した方法を選択できます。

SharePoint Embeddedアプリケーションにカスタムコパイロットを追加するにはどうすればよいですか？

SharePoint Embeddedアプリケーションにカスタムコパイロットを追加するには、Reactコンポーネントとそれを制御するためのJavaScript APIを使用します。これにより、アプリケーションのユーザーがSharePoint Embeddedに格納されているコンテンツをMicrosoft 365コパイロットでアクセス、理論、要約することができます。

Copilot Studioを拡張する際にどのような機能が利用できますか？

Copilot Studioを拡張する際には、PowerAppsとVisual Studio Codeを使用して独自のカスタムコネクタを作成し、Microsoft 365、SharePoint、Dynamics 365などのMicrosoftサービスやSalesforce、Adobe、Workdaysなどの非Microsoftサービスに接続できます。さらに、アダプティブカードフレームワークを利用して、視覚的にインタラクティブなカードにレスポンスを変換できます。

カスタムコパイロットをViva Connectionsに統合するにはどうすればよいですか？

カスタムコパイロットをViva Connectionsに統合するには、Viva Connectionsのダッシュボードでカードデザイナーを使用して、Copilot Studioで作成されたカスタムコパイロットを選択し、ダッシュボードに追加します。その後、カードをカスタマイズしてエンドユーザーが使用できるようにします。

SharePoint Embeddedアプリケーションでカスタムコパイロットをカスタマイズするにはどうすればよいですか？

SharePoint Embeddedアプリケーションでカスタムコパイロットをカスタマイズするには、Reactコンポーネントに独自のプロンプト、テーマ、ヘッダーなどを設定し、アプリケーションのデザインに合わせることができます。また、ランタイムコンテキストに基づいてプロンプトを動的に変更することも可能です。

Microsoft 365 Copilotでのコミュニケーションカードの利点とは何ですか？

Microsoft 365 Copilotでは、コミュニケーションカードを通じてユーザーはテキストベースのインタラクションだけでなく、視覚的にインタラクティブなカードを使用して情報を得ることができます。これにより、ユーザーはより直感的で効率的な方法で情報を操作し、必要に応じてアクションを実行できます。

Outlines

00:00

😀 イントロダクションとClick to CoPilotの紹介

ビデオの冒頭では、CJ TanがSharePointとOneDriveに関する新しいCoPilot機能を紹介し、チームの他のメンバーも自己紹介を行いました。CJはClick to CoPilotと呼ばれる新しい機能を説明し、これはSharePoint内でコードなしでカスタマイズされたCoPilotを作成し、チームと協力するためのものだと述べています。この機能は管理者や開発者だけでなく、組織内のすべてのユーザーを対象としており、SharePointが組織の知識を保管している場所であることを理由にしています。

05:02

🔧 SharePointでのCoPilotのカスタマイズと共有

この段落では、SharePointサイトでのCoPilotのカスタマイズ方法と、それをチームと共有する方法について説明しています。サイトオーナーはデフォルトのCoPilotを選択し、特定の機能のために作成されたカスタムCoPilotを紹介できます。また、Teams内でCoPilotをグループチャットや一対一のチャットで共有する方法も紹介されています。さらに、SharePointサイトに組み込まれたCoPilotを作成する方法と、コンテンツから始めてCoPilotを構築する方法の2つの異なるシナリオも説明されています。

10:02

🖥️ SharePoint EmbeddedとCoPilotの統合デモ

デモでは、SharePoint EmbeddedアプリケーションにカスタムCoPilotを追加する方法が紹介されています。まず、SharePointサイトに組み込まれたCoPilotをカスタマイズし、サイトアイコンと名前を使って特定の振る舞いを設定する方法が説明されています。次に、ファイル選択からCoPilotを作成し、編集機能を使ってアイデンティティを設定し、テストして保存する方法も紹介されています。また、CoPilot StudioでCoPilotを拡張し、より強力なアプリを作成できることも触れられています。

15:04

📲 Viva ConnectionsへのCoPilotの統合

この段落では、Viva ConnectionsアプリケーションにMicrosoft CoPilot Studioで作成されたカスタムCoPilotを統合する方法について説明されています。Viva Connectionsはモバイルデバイスを使用するフロントラインワーカーに情報を提供するアプリケーションです。オペレーターはダッシュボードを作成し、特定のユーザーグループにターゲットを設定できます。CoPilot Studioで作成されたCoPilotをCard Designerカードに追加し、Viva Connectionsに展開して使用する方法が紹介されています。

20:05

🛠️ SharePoint EmbeddedへのPコードCoPilotの追加

最後の段落では、SharePoint EmbeddedアプリケーションにPコードを使用してカスタムCoPilotを追加する方法が紹介されています。SharePoint EmbeddedはカスタムアプリケーションにSharePointのストレージ機能を埋め込む方法を提供するAPIです。アプリケーション開発者は、SharePointのコアコンテンツ管理機能をコードせずに利用でき、テナントの管理者はアプリのコンテンツがテナント内に保管されるためのセキュリティとコンプライアンスの機能を利用できます。SharePoint Embeddedの一般提供と、新しいプライベートプレビュープログラムへの登録方法も説明されています。

Keywords

💡SharePoint

SharePointは、マイクロソフトが提供するウェブベースのコラボレーションプラットフォームとドキュメント管理システムです。ビデオではSharePointが組織の知識を蓄積する場所として提唱されており、新しい機能として「Click to CoPilot」が紹介されています。これはSharePoint上で協力して作成されたアセットを管理し、チームに特定の目的でサポートするカスタムCoPilotを作成することを可能にする機能です。

💡CoPilot

CoPilotは、ビデオの主題であり、マイクロソフトが提供する新しい機能です。これはユーザーの作業を支援し、特にSharePoint上でドキュメントを作成し、管理するプロセスを効率化することを目的としています。ビデオではCoPilotを通じてゼロコードでカスタムツールを作成し、チームと協力して情報を管理できるようになるというアイデアが強調されています。

💡OneDrive

OneDriveは、マイクロソフトが提供するクラウドストレージサービスです。ビデオではOneDriveとSharePointチームの一員であるLuca Bandinelliが紹介されており、OneDriveとSharePointの統合が開発者や感度の高いユーザーにとって重要な要素となっています。

💡Viva Connections

Viva Connectionsは、組織内のユーザーに情報を提供するアプリケーションです。ビデオではViva ConnectionsとMicrosoft CoPilot Studioを使用してカスタムCoPilotsを作成し、モバイルやデスクトップの両方のエクスペリエンスで使用できるようにする機能が紹介されています。

💡Copilot Studio

Copilot Studioは、マイクロソフトが提供する開発環境であり、ビデオではカスタムCoPilotsの作成とカスタマイズに使用されています。ビデオではCopilot Studioを使用してSharePointやViva Connectionsと統合された強力なアプリケーションを作成することができると強調されています。

💡Zero Code

ゼロコードは、ビデオで強調されている概念で、プログラミングの知識や技術を持たないユーザーでもシステムやアプリケーションを構築できることを意味します。ビデオではSharePoint上でCoPilotを作成するプロセスがゼロコードで行えると示しており、これは技術的なスキルを必要としないユーザーにもアクセス可能であることを意味します。

💡Dataverse

Dataverseは、マイクロソフトが提供するデータプラットフォームであり、ビデオでは外部データソースとして機能します。ビデオではDataverseから情報を取得し、CoPilot Studioを使用してカスタムCoPilotsに統合する方法が紹介されています。

💡Adaptive Card

アダプティブカードは、ビデオで説明されている視覚的にインタラクティブなカードです。Copilot Studioを通じて応答をアダプティブカードに変換し、強力で視覚的にインタラクティブなカードを作成することができます。ビデオではアダプティブカードフレームワークを使用して、Viva ConnectionsのダッシュボードにカスタムCoPilotsを表示する方法が紹介されています。

💡SharePoint Embedded

SharePoint Embeddedは、ビデオで説明されている機能で、カスタムアプリケーションにSharePointのストレージ機能を埋め込むことができます。ビデオではSharePoint EmbeddedアプリケーションにカスタムCoPilotを追加し、ユーザーがアプリケーション内でコンテンツを操作できるようにする方法が紹介されています。

💡Microsoft 365

Microsoft 365は、マイクロソフトが提供するオンラインサービスとデスクトップアプリケーションのパッケージです。ビデオではMicrosoft 365 Copilotが強調されており、これはMicrosoft 365サービスと統合されたCoPilotであり、組織のテナント内での情報にアクセスし、ユーザーがモバイルデバイスから情報を取得できるようにする機能です。

Highlights

CJ Tan介绍了将副驾驶集成到SharePoint和Viva Connections的新功能，称为Click to Copilot，允许用户在SharePoint中创建和扩展副驾驶，无需编码。

Luca Bandinelli强调了OneDrive和SharePoint团队专注于开发者和可感知性的工作。

Mark Windel讨论了他在Microsoft的OneDrive和SharePoint组织中作为产品经理的工作，专注于SharePoint Embedded。

Chris Whitten作为Microsoft Copilot Studio的工程总监，介绍了他们的工作。

CJ Tan展示了如何通过Click to Copilot在SharePoint中创建自定义副驾驶，目标是所有用户而不仅仅是管理员或开发人员。

介绍了副驾驶在SharePoint站点上的新入口点，允许用户选择为该站点创建的副驾驶。

CJ Tan演示了如何在Teams中与副驾驶交互，包括在群聊或一对一聊天中共享副驾驶。

讨论了从SharePoint站点创建内置副驾驶的场景，以及如何从内容选择开始构建副驾驶。

CJ Tan展示了如何在SharePoint站点中编辑和自定义内置副驾驶的行为。

演示了如何从文件选择创建副驾驶，并展示了编辑功能，如重命名和选择图标。

介绍了如何将SharePoint中创建的自定义副驾驶扩展到Copilot Studio以创建更强大的应用程序。

展示了如何将Copilot Studio中的副驾驶集成到Viva Connections中，以及如何使用卡片设计器卡。

Luca Bandinelli讨论了如何将使用Microsoft Copilot Studio创建的副驾驶带入Viva Connections。

Chris Whitten演示了如何在Copilot Studio中创建基于卡片的副驾驶，并解释了如何使用自适应卡片框架。

Mark Windel介绍了SharePoint Embedded的概念，以及如何将其与自定义副驾驶集成。

讨论了SharePoint Embedded的好处，包括核心内容管理功能和与Office的集成。

Mark Windel演示了如何在Visual Studio Code中将自定义副驾驶添加到SharePoint Embedded应用程序。

展示了如何自定义副驾驶的外观和行为，以匹配应用程序的主题和上下文。

强调了SharePoint Embedded内容的安全性和合规性，以及它如何与Microsoft 365副驾驶集成。

鼓励参与者注册两个私人预览计划，以尝试SharePoint Embedded和自定义副驾驶的新功能。

Transcripts

CJ TAN: Welcome to

Integrating Co pilot into

SharePoint and Viva Connections. I'm CJ Tan.

I'm a group product manager working on SharePoint

and OneDrive and introducing new copilot experiences.

And I'm here with Luca, Mark, Chris.

LUCA BANDINELLI: Hi everybody.

Name is Luca Bandinelli.

I'm a PM in the OneDrive and SharePoint team

that takes care of developer and sensibility.

MARK WINDEL: Hey everyone. Mark Windel.

Also a product manager working at Microsoft in

the OneDrive and SharePoint Organization

working on SharePoint Embedded.

CHRIS WHITTEN: My name is Chris Whitten.

I'm a director of Engineering for Microsoft Copt Studio.

CJ TAN: All right.

We've got lots of

great content and demos to share with you today.

So we're going to get going

and trying to get through everything.

If there's time for questions,

we'll try and take some at the end,

but let's get started.

First, with copilots and SharePoint.

So I'm going to introduce a set of

new capabilities I like to call Click to copilot.

This is because we're trying to make it

really easy for you to create and

extend copilots that help

you and your team write within SharePoint.

With zero code, you'll be able

to soon create these custom copilots from SharePoint.

This is a capability that we're targeting all users

in your organization and not

just administrators or developers.

So why SharePoint?

SharePoint is where we know that you're

storing your organizational knowledge,

not just things that are recent and current that you want

authoritative authority on when you share them,

but also things that you collaborate with your team on.

These are the assets that you create together.

With this, we want to

be able to introduce custom copilots

here so that you can help yourself

and your team with a specific purpose.

Basically, take Microsoft chat all of that power,

scope it down to a site,

or a set of documents,

or a folder, or your document library,

and create something that you can use

over and over again to help your team.

This, we want to do without

any specialized skills or technical skills,

because really, you know what the content is,

you know who you're working with, and you know

what you need to get done to do that.

So this is called Click to copilot to

try and express how easy it's going to be.

It's going to be easy to create.

It's going to be simple to use,

and it's going to save you

time because you're going to get

the right help that you need from

this copilot that you create.

But of course, if you're creating something,

is it actually something that's helpful?

Is it going to get used?

That's really the important thing.

We're introducing a couple of ways that

you can actually interact with these custom copilots.

First, it's around interacting with them on SharePoint.

What you see on the left here is

a new entry point for copilot on a SharePoint site.

When you open that, it's got this switcher that lets you

pick the copilots that have been created for that site.

Now, this is all site owner controlled,

so you can pick a default copilot.

So something that you would like people to

interact with when they come to your site?

Then you can introduce

all these other custom copilots that you've created

for purpose built functionality

for the people that come to visit.

This will also be a place where we think that

when you're creating your own copilots,

we'll show it here.

So this is something that we're introducing now,

but there's lots of time for feedback.

We're going to be inviting lots of

customer feedback as we introduce this product as well.

What you see on the right hand side

is how you would interact with this in Teams.

We're going to give you an easy way

to share this copilot that you

created within a group chat

or within a one-on-one chat as well.

Let's get to the two main scenarios here

that will introduce custom copilots from SharePoint.

The first one is around having this

built in copilot for every SharePoint site that you have,

one that we'll introduce on your existing sites and

also allow you to add whenever you create a new site.

Then the other entry point is

really about starting from the content,

selecting the content that you want to ground

your copilot and then

building the customizations out from then.

They've got two different starting points,

but they really have the same functionality.

Both of these, as I'll show you, can be customized.

You'll be able to share this copilot with

others through Teams and e mail,

and the copilot itself is going to

respond back with the permissions

of the person who's asking.

So that's going to be using

your permissions in the same way

that Microsoft Chat does.

The one thing that's different

here is that the scenario where we've got

the default copilot or that built

in copilot on your SharePoint site,

you're going to have some site owner

controls around that as well.

Let's move on to the demo.

We're going to start first with looking at the built in

copilot site as a starting point

for these customizations.

Within a SharePoint site,

you're going to see that panel

come out with a copilot button,

and there's going to be a menu that allows you to edit.

We'll jump to the demo here.

When you see that built in copilot,

it's going to start with the name of the site and

also the site icon as far as its identity goes.

By default, it's going to take

in the entire scope of the site.

What that means is it's going to have your site pages,

it's going to have your document libraries

, everything's included there.

The picker does allow you to

select sources as well from here.

Then the part of the customization that is

probably interesting is how

do you want people to interact with it?

You get to start figuring out and

entering what behavior you want for this copilot.

This is a fairly important part of the process here.

If you're trying to convey basically how

you expect people to use

it when information that they want.

What's interesting here is that

on the right hand side of this,

you can test this copilot before you actually save

it and make these changes appear

for everybody that's coming to use the site.

The space here allows you to have

a look at some test queries that you could put in,

as well as different

different ways to introduce that copilot.

But that's it. Once it's done,

I save it and close it,

and that will immediately show me

how it's going to appear within the SharePoint site.

One of the things that makes this

built in copilot different from just creating

a custom copilot is there's going to be

some site settings that we

want you to be able to set as a site owner.

For one, like I mentioned,

there's going to be one that we give you by default.

There's going to be one that you can

tell people when they come to the site,

this is the one you should use.

We want to give you a setting that lets you choose that.

We will build you one automatically as part of the site.

But you could pick

any other custom co pilot that you've created for

that site to choose

for when people come to visit that site.

The second thing that you can do is basically choose

the copilots that appear for the users on that site.

If you remember in that switcher,

we had a list of copilots that

were created from that site.

So the site owner can actually choose

the ones that they think are going to be the

most useful for the users

and the audience that they're trying to target.

Now, let's look at the second demo.

This one is going to be looking at creating

a copilot from a selection of files.

I'm here in my Comms folder,

and I'm going to create a custom copilot around some

of the delivery drone press releases on the site.

Simply select a few files and create copilot.

This starting screen is really meant

to give you a sense of what you're going to be creating.

You can see right away you can click try it.

What they'll do is create that copilot

and you can use it right away on that site panel.

But I'm going to show you some of

that edit functionality that we have.

In this case, because it's something that's customized,

I think that folder name that's put in

there by default isn't going to be expressive enough,

so I'm going to give it a different name.

You can give it an identity.

Here I'm going to choose

a new icon to say that this is about the delivery drone.

Then we can go to the sources.

I had shown you previously that default to site.

Here we've got that pre-selected three files

that I had originally selected to start the copilot.

Just so that I can

show you what this browsing looks like,

I'm going to select another file

and add that to the list as well.

And in the same way that we saw in the previous demo,

part of this, I'm showing a little bit repetitive,

just to give you a sense that it's

the same flow regardless of

which entry point that you're actually coming from.

Whoops. Let's put

another different text here.

Then in the same way that I had shown you earlier,

you can also test it out

here before you save

it and make all of your different changes that way.

Once that's done, again,

I'm going to hit "Save" and

have that show up again in the window so that you

can see what the end user is going to

end up seeing when they start using this copilot as well.

Once we hit Save, we can close it,

and that'll pull up the window there,

so it's ready for people to

use with the customizations that you made.

So one of the things

that the builder does is

actually give you a starting point

for your custom Copilots.

The next set of things that

you can do is that you can actually

extend this custom Copilot that you made,

that's really just grounded in

that SharePoint data into Copilot Studio.

And we let you do that

because there's so much more that you can get

from Copilot Studio as well

that isn't that simple click thing.

So the target audience here is

not necessarily just the every user,

but it's somebody that's comfortable

using Copilot Studio.

We want them to be able to

create this much more robust app.

So you're going to be able to add knowledge that's not in

OneDrive in SharePoint through Copilot Studio.

You can customize actions,

and you can also publish and deploy

this app to all the places

that are supported in Copilot Studio.

So for this one, I'm just going to roll

a video to show how this is going to work.

SPEAKER 1: This Microsoft Copilot

that can be extended with Copilot Studio.

Let's look at another example of how you

can extend a Copilot within SharePoint.

This SharePoint site has

all the event details for a major event, ReleCon 2024.

The attendees can quickly get

information from the Copilot.

However, employees looking for

food vendor information couldn't get

answers from the Copilot due to

the information not being available on SharePoint.

To fix it, the Copilot can easily be customized

via Copilot Studio to connect to external sources.

With a simple click, the user is

now able to continue editing

their Copilot in Copilot

Studios full authoring experience.

ReleCon's catering vendor information is

available as records in Dataverse.

From Copilot Studio, it can easily

be added as additional knowledge sources.

And to give attendees even more menu details,

they can also add the catering vendors public website

as another knowledge source.

This way, the Copilot can answer

any additional meal questions from the attendees.

Providing information is great,

but the Copilot can take it further by allowing

attendees to submit

their meal choices ahead of the event.

This can be easily done by adding

an action in Copilot Studio.

In this case, the action updates employees meal

choice as part of the attendee records in Dataverse.

There you have it. Now the Copilot will take the action

automatically without needing additional configuration.

When they're satisfied with

the Copilot's additional capabilities,

they can easily publish their changes to become

available on the ReleCon 2024 SharePoint site.

C J TAN: So now, the last part

of this demo that I wanted to

show you is what you do after you've created these.

So now I've shown you that you can create them from

SharePoint as just a file selection.

We've got this built-in one that we're creating.

You can extend it to Copilot Studio,

and we'll look at how we can share it.

So there's the delivery drone site

that I had created earlier,

and it's as simple as grabbing

a link to this Copilot to share.

So you'll see that this is

a familiar dialogue around sharing.

You've probably seen this if you've ever shared a file.

You copy that link.

And when we drop it into Teams,

this is the step that you take to just say,

hey, I'm working with Mona here.

I'm going to give her this Copilot

so that we can add it to our chat,

and we can start conversing with it and

start learning and using

the information we get from

this delivery drone custom Copilot in our flow.

So this is all coming into preview this summer.

I've got a registration here that you

can nominate you and your company

to join our private preview and

try out these great features,

and also, hopefully, give

us a lot of feedback as you're using it as well,

so we can make this really awesome.

I'm going to hand it over to Luca for the next section.

LUCA BANDINELLI: Thank you, CJ.

Wow, this is cool stuff.

Hard for us to keep the bar high.

You didn't make easy that for us.

Okay, let's switch gears now a little bit,

and let's focus on how do we bring Copilots that can be

created using Microsoft Copilot Studio

in another application that is powered by SharePoint,

which is Viva Connections.

Where are we? Okay. When we start that,

we start in Copilot Studio,

and in Copilot Studio,

we go and create our custom Copilots.

We can either use the rich set of

controls and capabilities that Copilot Studio provides to

you or we can use

the conversational Copilot experience

that Copilot Studio brings to

us and basically ask help for the Copilot

itself to help us building new custom Copilots.

While we're building the custom Copilots,

we can leverage the 1,500 and plus connectors

that Microsoft Copilot Studio

gives the ability for us to use.

Those are connectors for Microsoft services,

just like Microsoft 365 or SharePoint Dynamics 365,

as well as non Microsoft services;

Salesforce, Adobe, Workdays, etc.

And for customer services,

developers can basically build

their own custom connectors by using

the power of PowerApps and Visual Studio code

or your favorite IDE.

And then when you are building the custom Copilot,

you're focusing on prompts

and you're focusing on the outputs.

And in Copilot Studio,

one of the things you can do,

and you will see that in a second,

is that you can leverage the power of

adaptive card framework in order to

transform the responses in

powerful visually interactive cards.

So once you've done your Copilot

and you're publishing your Copilot,

it's now time for use that in Viva Connections.

And we will look at Viva Connection in a second.

But basically, Viva Connection is

an application that you can use in order to

bring the information and the content of your company

directly to the users of your organizations,

especially in situations where

those users are not in front of a desktop,

but they are mobile and they are front line workers,

and they need to work with mobile devices.

So really, Viva Connection is the tool you use

in order to bring this information

directly to the user so they can do the job

done without wrangling around

and trying to find the right information.

From there, you have the operator

that is the persona that

is in charge of building the dashboard,

and these persona can use

a lot of cards to build the experience.

One of these cards is called the card designer,

and the card designer basically

provides the ability to select

custom Copilots that has been

built by using Copilot Studio.

From there, the operator can create the dashboard,

can target the dashboard

in the cards to a specific set of users.

You can also have multiple dashboards if

your organization is a

conglomerate of multiple companies.

And then when you're ready,

you are able to use the custom Copilot in Teams desktop,

mobile, or a tablet experience.

Okay, let's see how it works.

Let me switch to my damn machine,

and let's be sure that I did

my prayers to the demo god

in the right way this morning. I think I did good.

Let's see how it goes. So this

is the dashboard in Viva Connections.

And you can see that you have a lot of cards here.

You can see that I have first party cards,

so cards provided by Microsoft,

like the tasks card,

Viva Learning, Praise.

Cards have these capabilities to

connect to external application like the Praise one.

Cards have also capability to provide an

in-dashboard experience with the card view,

and then you click on the card itself,

and you have this concept of quick view from where

you can fill up information and context.

All of these cards, both cards

provided by Microsoft and cards built by

third party developers can be done by using

the SharePoint framework which is

a powerful development tool that is

based on TypeScript and JavaScript that

is able to create cards and is able

to connect your data and bring this kind of

functionalities on multiple of Microsoft 365 canvases,

including in this case,

Viva Connections through what are

called cards or adaptive card extensions.

So from there, let's see that I am an operator,

and now I want to add the new card.

I click. I go to the edit,

I edit my dashboard.

From here, I can add a card, and as I can see,

I have this card designer card,

and I have a lot of other cards here.

I have cards from third party developers as

well as card provided by Microsoft directly.

From here, I click to the "Card Designer". I added that.

And from the card designer itself, immediately,

what I can see is that I have a Copilot Studio option.

When I select in the Copilot Studio option,

I will be able to bring

my Copilots here and use that in the card designer.

Right now, I don't have any of

these Copilots available, but conveniently,

I can click here on this "Create a

Copilot" and Microsoft Copilot Studio opens for me.

Now, let's see how I can

build a Copilot using Copilot Studio,

and this is where Chris is going to

help me with that. Four, please.

CHRISTOPHER WHITTEN: Yes. Okay. Let's build

a Copilot a card based Copilot using Copilot Studio.

So here I am in the home page of the product.

Normally, if I were creating a new Copilot,

I would use the conversational creation experience or

perhaps select from one of the

templates that we have available.

I'm limited on time though,

so I've already got an existing Copilot

that's called Stock Assist

that I'm going to use and extend

and describe how it all works.

The scenario or the Copilot that we're going to build

is one around taking

stock availability for internal employees

who maybe want to request

new hardware, maybe it's a laptop.

You can drill down into details of

that particular laptop or computer,

and you can request to

maybe your IT department a new machine to be sent to you.

So let's go ahead and build that functionality.

I'm going to drop into

the Stock Assist Copilot that I have set up.

And I see here that I've set up some things.

I've set up these things that are called

topics and these things that are called actions.

There are actually a couple of ways to send

adaptive cards via Copilot Studio.

Actions, in this case,

are essentially just wrapped rest APIs.

Well, it is a deployed web endpoint

that serves my stock data.

And the second API that I have is one that will send

a new request with some stock that

I'd like to present to a new employee.

When you call an action,

you can actually bind its response to be a message.

And that message itself could be an adaptive card.

So right there, you can bind

a card-based rich media view in response to an action.

It could be a call to an internal database.

It could be Dataverse, it could be

Salesforce, and so on.

I'm not going to do that for this demo, though.

I'm actually going to use topics because I want to

demonstrate how Copilot Studio

is really driven off of triggers and events.

And what invokes this topic,

and a topic is basically

structured and controlled dialogue,

it's fully programmable,

this event that I've configured is

basically in response to a card submission,

a user clicking a button or perhaps a form submission.

When that is triggered, it invokes this flow.

And I have a card set up here already.

It's welcome to Stock Assist.

That's the name of the Copilot that we're building.

And the other topics that we have around fulfillment,

where you want to create a request or drill

down or show the products in a list for the user.

Let's go and implement the topic

for servicing the list of products.

I've got my event configured.

What I'm going to do is I'm going to add one of

those actions that I showed

earlier through this little action wizard here.

I'll search Stock Assist.

The get products endpoint.

Bind a connection to it.

MARK WINDEL: I'm going to change the authentication mechanism

to be Copilot author based,

so the maker credential

will be used to actually invoke this API,

but it can be configured for

end user authentication as well.

Like I said, it's going to be calling an API

and returning in this case, a JSON payload.

I want to store that somewhere.

I'm going to store that in

a variable that the Copilot can

reference later on in the flow of the conversation.

I've saved my variable.

The last thing I need to do,

is I need to send the card that has the data

from the API back interpreted in it.

I select adaptive card.

This is where you could go to

the adaptive card designer or

perhaps another card designer tool that

might support the adaptive card schema.

In this case, I have this payload in

my clipboard that I can paste here.

It's declarative and that should be it.

All I need to do at this point is save.

I I implemented my products topic

that sends the product list card.

I can test it right here.

When I start a conversation with the Copilot,

here's my welcome view.

I will click "Request New Order."

There's the list of products that I just configured,

and you'll see that it actually navigated

to the products topic.

I'm going to click on one of these.

That navigated me to the product drill down topic.

It's going to present a new card

hitting the other action API that I described.

I can muck with

the quantity and then click requests when I'm satisfied.

Then we'll navigate me to the fulfillment requests

submitted view that we'll

be experienced in VIVA. I'm happy with that.

To get this back to VIVA.

What we need to do is publish it.

Hopefully, this only takes a few seconds.

SPEAKER 1: Go to the jokes

in the mid time.

There we go. Here we go.

MARK WINDEL: This is the development.

All right.

It's published and then once a Copilot is published,

you can actually enable your Copilot

to work on many different things that we call channels.

The Channel could be Microsoft Teams

or Slack or Facebook messenger.

In this case, we've added

VIVA Connections is a new channel type.

All you need to do at this point is to go to

the Viva Connections Channel tile and

click "Turn on Viva Connections."

When this completes, it'll be discoverable back on

Luca's machine where you can then add

it into his dashboard.

SPEAKER 1: And guess what? Here it is.

You can see that now in the car designer I have

the Circasist Copilot that was

built by Chris using Microsoft Copilot Studio.

Now here, I can see that I have a couple of options as

the author of my dashboard.

The first thing that I see is that, Oh, look at that.

I have exactly the same adaptive card

powered by Copilot that Chris

was showing Copilot Studio

available here in my dashboard.

Now, the only thing that I have to do is to

craft my card experience so that

the end user can use that in

the dashboard and interact

with the Copilot from Viva connection.

The first thing I'm doing,

I'm going to come here and move

my size to card size too large.

I have a little bit more real estate if I need that.

I go here and I change the title

and use that as a order management.

Then the other thing that I can do as an operator,

I can either leave the card it is.

So then when I click on the card,

I will start interacting with the Copilot

indirectly and bring

the adaptive card experience from Copilot.

Or another thing that I can do,

I can elevate some of the prompts that Chris designed and

in the custom In-copilot studio

before and bring them directly.

In the card view. In this way,

I can basically have

the opportunity to promote and elevate some of

the critical functionalities that they

want the user to interact

with directly in the card

without having to go and dig deeper in the quick view.

From now on, let's keep that in this way.

I go back, I go back to the description.

I take a look at the description text.

I probably do something different,

just like this one.

I feel good about this.

Now I can see a preview how the card looks like,

how the quick view looks like,

and I'm going to republish that to my dashboard.

I go back to my dashboard,

refresh to be sure that my changes are here.

And then I show more and guess what

this is my card that is available right now.

If I now, let's say that I am an operator,

I am an end user, I am on the floor.

I am in front of my machine.

I click here, and immediately,

I can see that the Copilot replies back to me.

But instead of giving me

a textual experience or

an interactive experience via text,

it gives me that interactive experience.

We adaptive card, I click on a "Request

order," and then the next card comes up.

In the same way that Chris was

testing his copilot in Copilot Studio.

I can click to an information.

I can select the quantity.

I can make a request,

and I am done.

I've been able to do everything from here

directly and interacting with

Copilot in a graphical information.

That's pretty cool. Do you like it? Come on.

Thank you. The other thing that I want to show is that,

as a developer, you are building these cards,

and this card are fantastic in VIVA connections.

We just discussed all the benefits

and how end users can use them.

But we are in the era of Copilot.

And really, we believe that Copy backers of

365 Copilot can bring a lot of value on you.

One of the things that we are also working

on is the ability to try to bring

the investments that you have made in

building your cards above

and beyond just VIVA connection.

For example, let's say that I

am an employee at Real Cloud.

I've worked on this delivery drone launch

for a long time.

I'm super busy.

I'm super stressed out.

I need to have some days off because I have borne out.

What I could do I could go to

the HR web and I could take

a look at the information of a DR.

But one of the things that I can do,

I can also ask this question to Copilot to

Microsoft 365 Copilot and

try to get that information back.

What I'm expecting because my content

is grounded inside of my tenancy,

I am expecting to get

the information just like a policy document from HR web.

Instead, what I got is a powerful card.

The same card we've seen in the dashboard before,

directly in Microsoft 365 Copilot.

Not only that, when I am in Microsoft 365 Copilot,

I can interact directly from

the card within the Microsoft 365 Copilot.

I can select some information.

I can put mental health day.

I can basically fill up all of

my information and do everything from

here without getting distracted from a different focus.

This work for several amount of cards.

I can work with this one.

I can have another prompt

or question just like asking for my pay day.

Basically, the dashboard is part of our tenancy,

and all the content inside of the dashboard

is grounded and Copilot,

Microsoft 365 Copilot understands about that.

It's able to see if there is a card that

is able to fulfill

the requirements that you have and show that to you.

From here, I can go there and do everything else.

This is basically what it is.

Very quick recap.

What we have seen here, basically,

from the Microsoft Copilot

and Viva Connection integration,

you can see that in Copilot Studio,

you are able to create

a Cipilot available in the card designer.

You can select them. You can basically get the prompts,

make the prompts available in

the card to have even a more precise experience.

Once you're there, the card information is provided to

you by the power of

adaptive card and Microsoft Copt Studio.

Then those cards can also surface

in your Microsoft 365 Copilot directly.

The copilot understand the card intention

because it's grounded in your tenancy,

and if there is a card that fulfill a specific need,

the car will surface.

You do not have to change your cards.

If you already have invested in your cards

by using SharePoint framework

and building your custom cards,

these cards will be already available.

The Copilot will understand the debt and we bring

that information based on

the content that is already there,

text description, and stuff like that.

Moving forward, we will also give

the opportunity for developers to even

better specify the intent of the card by

making some changes in the manifest in order to do that.

I think we are far off from

the fast from the half of the presentation,

and we didn't do any code.

I feel bad about that.

Can you bring some coding here, Mark please.

Fantastic. Thanks so much.

All right. Thanks, Luca.

Hey, everybody. My name is Mark Windel,

product manager at Microsoft

that we've already talked about.

Yeah, so we saw how you can add

custom copilot using low code,

no code to share point experiences.

Today, I'm going to share with you how you can add

P code custom copilot

to your SharePoint embedded application.

So we're going to go through a few slides,

cover some context and theory.

And then we're going to do some

hacking together and visual studio code,

and take a look at what that looks like

and kind of build it together.

Before I get into making

custom co pilots for SharePoint embedded,

I want to give a quick primer on what

SharePoint embedded is if you haven't come across it.

At a high level, SharePoint

embedded is a way for you to embed

SharePoint storage capabilities into

your custom application, okay?

It is a headless set of pay as you

go APIs that allows you to

create and manage a partition of

content in an M 365 tenant.

Basically, you can build custom applications

on SharePoint embedded and that

lets you create a custom content partition

in an M through 65 tenant.

As an app developer,

when you build your app on SharePoint Embedded,

you get a whole bunch of capabilities right out of

the platform that you don't need to code yourself.

Core content management capabilities

like permission management files,

and all that stuff that you'd expect from SharePoint.

That's already kind of built in.

You can just use the graph APIs

and you get that stuff and in fact,

interacting with content uses

the same drive and drive item APIs

that you might be used to.

You also have the ability to embed office web and

desktop experiences right from your application

so you can have an app that has office documents in it.

Users of your application can actually collaborate,

co author at mention,

and do all of that stuff that they've come to expect with

the office experiences directly

in your custom application.

It also gives you the ability to

have security trim search.

Right from you in your app,

all of the contents automatically

indexed when it's stored in SharePoint embedded,

and so you can do,

full security aware searching,

either in your app experiences, or if you enable it,

users can discover your app's content

from other M 65 experiences like one driving share point.

So there's a whole bunch

of capabilities that you kind of just

get as part of the platform when you

develop on SharePoint embedded.

Now, if I am a tenant admin and somebody is installing

an app on my tenant that

is built on top of SharePoint embedded.

I get a whole bunch of benefits as well.

Because when we use that app as my organization,

that apps content is actually going to

be stored inside my tenant.

It's stored inside my tenant.

I have a custom app that's

actually storing content inside

my tenant in a dedicated partition for that app.

I don't need to give permissions to

that app to access SharePoint or one Drive.

It can just access that content.

More importantly, because it's located in my tenant,

I get all of the built in

through 65 security compliance,

and business continuity promises

for free from the platform.

The app developer doesn't need to build them,

and I can feel confident because

the apps built on SharePoint embedded that

I can get those capabilities and have

the security and compliance promises

of my organization honored,

like discovery, audit, DLP,

all on that custom data.

Share Point embeded just went into

general availability this week.

We just announced it a couple of days ago.

If you want to check it out, you can go to that

AK NMS start SPE link.

That's for SharePoint mbedded.

The thing I want to talk about today, though,

is how SharePoint embedded content

is not just search ready,

but it's also copilot

ready and that's the thing that we're

announcing private preview as well this week.

I talked about how all content and SharePoint embedded.

If you put a file in

a custom app and it's stored in SharePoint embedded,

it actually gets fed into

the lexical search index that M 365 uses.

But those files also get put into the Semantic index,

the same one that Microsoft 3605 co pilot uses and so

content is automatically added

in there and vector embeddings are generated.

It's not just making that content AI ready,

super important part, but you know,

if you're using a different store,

you could probably find a way to

do that yourself, you know,

generate vector embeddings on that content,

and without too much difficulty.

But the real value proposition by using

the same semantic index that's built in Microsoft

3605 is that all of

the security descriptors and all of

the security requirements of

your organization continue to be honored,

so if you have information barriers,

permissions are honored and stuff like,

so all of that stuff just works by default.

The two key things, the two key takeaways here.

If you have a custom app that's

written on SharePoint Embedded,

stores content in there.

You can access that content

through Microsoft 3605 copilot.

Now, that can be turned on and

off based on your app settings.

But if you turn it on, users of your app can

actually access, reason over,

summarize the content that is in

your custom application in Microsoft 3605 copilot and,

the thing that we're announcing

today is that you can have

a pro Dv custom copilot

dropped into your sharepoint embedded application.

That's what it looks like.

This is a kind of a mock up screen of

a SharePoint embedded sample application

with a custom copilot.

And so here we're calling it the HR Smart,

so it's an HR recruiting app and it's

a good fit for

an app that should be built on Share Point embedded.

There's a lot of files and content in

here so you might have job descriptions,

resumes that are uploaded by candidates,

interview feedback, offer letters and more, right?

There's a lot of files and content associated with that.

Makes it a good fit for SharePoint Embedded.

But the thing that we're going to talk about today is

this custom copilot that is on the right hand side.

What we're going into private preview

with and what we're announcing is the ability

to drop that custom co pilot into your application and is

either a react component and

an underlying JavaScript API that you

can actually control the experiences of.

This is super powerful.

If we think about a custom application like this.

You get to manage the experience of that copilot

dynamically based on the user

that's visiting that site or page,

what page they're on,

what items they've selected,

what the actual identity of

your particular custom copilot should be.

Using the rich set of APIs,

you can control all of

that stuff and that's what we're going to look at,

and that's what we're going to build together here.

Before I get hands on,

just a quick plug for this.

If that all sounds interesting to you,

I recommend either take a picture or visit that link ACMS

SPE copilot to sign

up your organization for our private preview.

Now I'm going to try and switch over to my demo machine.

Cool. All right.

That same screenshot that we were looking at,

this is kind of like a live version of

that demo application running

on my local developer machine here,

and this is all live so,

you know, cross your fingers.

Hopefully, the demo guns are in my favor as well.

But yeah, so we're looking at an HR recruiting app,

and I'm on the jobs page, right?

And so, we're looking at

a few different job descriptions in here.

Now, each one of those,

if you're familiar with SharePoint embedded already,

in kind of the object model

or information architecture there,

SharePoint embedded has these things this concept called

file storage containers that

you can create inside of a tenant,

so each of these job descriptions

is a file storage container within

my tenant and that's a good place

to store like this job posting document,

for example, or the resumes of

candidates that apply or I

can set out offer letters or what have you.

I just clicked on one of those job posting documents,

and just to show you how

office experiences are built

right into SharePoint embedded,

so nothing to do with copilot yet,

but you can access an open Word documents,

either in online or in web and collaborate

co author at mention

directly from the SharePoint embedded application.

As this user, I don't need to even have

a license for SharePoint or Muh

65 or any of this because it

is a set of pay as you go APIs that are underlying this.

That's what this app is.

There's a giant open,

empty space on the right.

That's where we want to drop our custom copilot in.

I'm going to open up visual studio code,

and right now I've got an empty react component.

If you're not familiar with react, not a big deal.

It's just a nice way of building web experiences.

I've already got it imported.

Now I'm going to add my chat embedded

widget or react components the proper name for it,

so I've included that.

Now, the compiler is complaining at me, Chat embedded.

I'm missing an off provider.

I have to provide an off provider

property to this component.

I'm going to go make one of those.

The ath provider itself is not complicated.

All it does is it has a method called get Token,

and that lets me get a token for

my particular share point embedded

application for the current user.

It's a delegated token.

Okay. Now I'm going to actually use this ath provider.

I have to instantiate it,

and then I'm going to set it in my react state.

Okay. Cool. We have

an ath provider and now I'm going to pass it as

a property to this react component.

There's one more thing.

For the keenly visible stuff out there,

you can see that health provider could be undefined.

I just have to be careful here and say,

make sure that it is defined before

I actually load my component.

Okay, cool. No more errors.

We have dropped the component in

roughly a minute or so I'm going to go back and we

now have a custom Copilot

embedded in our SharePoint Embedded application.

This thing is already

grounded on the content

in my SharePoint Embedded application.

If for example, here,

I have these job postings I can say,

show me recent job postings, and fingers crossed.

Hopefully, this works.

What that's going to do is show me

the job postings that are in

this particular SharePoint Embedded application.

It's streaming those answers back,

by default, it's going to show

me all three that are in there.

Of course, we're getting this familiar Copilot experience

that you've come to expect so I have

references there for those documents that

you can see on the left. That's awesome.

We also have the ability

to interact with the working set.

If you're familiar with that, I can have the slash here,

and that'll show me some of

the working set of

the people that I've been working with.

I can also use that to reference

a particular file that is in

my custom application stored in

SharePoint Embedded and ask it to summarize that file.

Really powerful stuff.

We have the ability just in

less than a minute drop a custom Copilot into our app.

But it's not very custom yet.

It is operating on my apps data,

but I want to change some things with it.

Number one, the red in

there is not really fitting with my theme.

The header or the title of

this custom Copilot doesn't match my Contoso HR app.

I want to be able to add some custom prompts

and things like that to it.

I'm going to go back individual study code,

and I am going to add some properties here. Chat config.

I will give it a header,

which is just I'm loading these

from a prepopulated singleton object

that I've got in the background.

It has nothing to do with what we're going

to show in private preview,

for example, a header says you can see it there,

and then tell us Contoso HR chat

and then a theme just has a bunch of

colors to try to make it

look a little bit more fitting for my application.

I have to pass that chat configuration

as a property to my react component.

There we go. Once I do that, hot reload.

Looking better. We got some blue here,

and I can say the same types of things that I have,

but now I want to actually add

zero query prompts and suggested prompts.

I'm actually going to have a little bit of fun and

show a pirate prompt.

The point here, once I save

this and go back, it's going to reload.

You'll be able to see there

are these zero query prompts. I can click on them.

I can customize how they show up.

I've got these suggested prompts as well.

I've also told this thing to respond like a pirate.

Now, you probably don't want to do

that in your actual application,

but I'm doing it just to illustrate

the fact that you have full control of the metaprompt

here and you can really

give this custom Copilot an identity.

It says, ahoy Mark.

Here be the summaries of the, and so on.

You really get to tune the experience of it.

This does not have to be statically defined.

You can go through and update

these experiences, these suggested prompts,

zero query prompts, and

the metaprompt as you go through your application,

depending on the context of it.

If your user's looking at a particular job or

maybe looking at hiring

policies or things like that or even just managing users,

you can set this context

dynamically as the user goes through your application.

We probably don't want that pirate metaprompt for real.

I will actually just set it to

an actual metaprompt and then in there,

this is just further showing.

I'm I'm telling it that is

a digital assistant for

a human resources hiring application.

I'm giving an identity.

I'm educating that virtual assistant

on our hiring values.

Now, when I go back and that refreshes

if I use one of these zero query prompts and say,

what are our hiring values?

That's going to come back and

use the metaprompt that I gave

it to give it effectively

the instruction of what our values are,

and it's able to relay that back to me.

Now, you can also add all kinds of contexts,

like what the user's role is in here,

maybe who their particular

hiring manager is or anything like that.

There's a whole bunch of stuff you can do to

customize that runtime in the context of your app,

what the experience is. There's one more thing.

I'll say, if I want to look at

a particular say job posting. I've clicked on this.

If I look right now and say,

show me recent job postings.

What I wish it would do is actually

honor the fact that in the context of this app,

I have selected a particular job posting,

and maybe I was viewing it

and looking on a different page.

But what I wanted to do is

dynamically alter the data source scope

that I have in my application to

that custom Copilot and

that's exactly what I can do here.

I clicked on it. It's showing me

all of the job descriptions.

But what I'm able to do actually is

to build a custom handler here,

that's really just going to give me a handle to

the underlying custom co pilot API,

and then I can get the data sources

that are selected elsewhere on

my app and set that data source on the API.

I just need to do one more thing to make sure it's

all plumbed up. I'll save that.

I do think I need to refresh the page because

it won't reload because it's not updating react state.

But once that's done, now,

when I go in and click

a particular software engineering position,

I can say list and summarize recent job postings,

and it is going to scope the response back

to that particular job posting that I clicked.

Underneath the hood is a file storage container,

and it's going to only look in

that file storage container

because that's what I told it to scope.

Pretty powerful stuff.

You can really customize

your Copilot experiences in

your SharePoint Embedded apps with that capability.

That's it for that demo.

In fact, I think that's it for our talk.

We are a few seconds over.

One final plug here.

If any of this stuff is interesting to you,

you can go to those links to sign up for

the two private preview programs

that we talked about today.

Thank you very much for coming.

I really appreciate it. Thank you, folks.

SPEAKER 2: Thank you.